Types.cs

/*
 * Copyright 2017 Stanislav Muhametsin. All rights Reserved.
 *
 * Licensed  under the  Apache License,  Version 2.0  (the "License");
 * you may not use  this file  except in  compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed  under the  License is distributed on an "AS IS" BASIS,
 * WITHOUT  WARRANTIES OR CONDITIONS  OF ANY KIND, either  express  or
 * implied.
 *
 * See the License for the specific language governing permissions and
 * limitations under the License. 
 */
using CBAM.Abstractions;
using CBAM.SQL.PostgreSQL;
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using UtilPack;

// TODO document these later.
// TODO when (if?) we will have extension properties ( https://www.infoq.com/news/2017/08/CSharp-8 , under "extension everything" ), most of the properties of these types can be refactored into extension properties.
// Writing them now as extension methods would not be feasible in terms of user experience.

#pragma warning disable 1591
namespace CBAM.SQL.PostgreSQL
{
   // TODO implement IPgTypeWithBackendTextFormat
   public struct PgSQLInterval : IComparable, IComparable<PgSQLInterval>, IEquatable<PgSQLInterval>
   {
      //// Getting decimal digits from System.Decimal: http://stackoverflow.com/questions/13477689/find-number-of-decimal-places-in-decimal-value-regardless-of-culture
      //private delegate Int32 GetDigitsDelegate( ref Decimal value );

      //private static class DecimalHelper
      //{
      //   public static readonly GetDigitsDelegate GetDigits;

      //   static DecimalHelper()
      //   {
      //      var value = Expression.Parameter( typeof( Decimal ).MakeByRefType(), "value" );

      //      //return (value.flags & ~Int32.MinValue) >> 16
      //      var digits = Expression.RightShift(
      //          Expression.And( Expression.Field( value, "flags" ), Expression.Constant( ~Int32.MinValue, typeof( Int32 ) ) ),
      //          Expression.Constant( 16, typeof( Int32 ) ) );

      //      GetDigits = Expression.Lambda<GetDigitsDelegate>( digits, value ).Compile();
      //   }
      //}


      #region Consts
      private const Int32 DAYS_PER_MONTH = 30;
      private const Int32 MONTHS_PER_YEAR = 12;
      private const Int64 TICKS_PER_MONTH = TimeSpan.TicksPerDay * DAYS_PER_MONTH;
      internal const Int64 TICKS_PER_MICROSECOND = TimeSpan.TicksPerMillisecond / 1000;
      internal const Int64 MICROSECONDS_PER_SECOND = 1000000;
      internal const Int64 MILLISECONDS_PER_SECOND = 1000;
      internal const Int64 SECONDS_PER_MINUTE = 60;
      internal const Int64 MINUTES_PER_HOUR = 60;

      #endregion

      #region Static

      public static PgSQLInterval MinValue = new PgSQLInterval( Int64.MinValue );
      public static PgSQLInterval MaxValue = new PgSQLInterval( Int64.MaxValue );
      public static PgSQLInterval Zero = new PgSQLInterval( 0 );

      internal static void AppendTimeInformation( StringBuilder sb, Int64 ticks )
      {
         sb.Append( Math.Abs( CalcHours( ticks ) ).ToString( "D2" ) ) // Hours
            .Append( ':' )
            .Append( Math.Abs( CalcMinutes( ticks ) ).ToString( "D2" ) ) // Minutes
            .Append( ':' )
            // Calculate seconds part (total seconds minus whole minutes in seconds)
            .Append( Math.Abs( ticks / (Decimal) TimeSpan.TicksPerSecond - ( ticks / TimeSpan.TicksPerMinute ) * 60 ).ToString( "0#.######", System.Globalization.CultureInfo.InvariantCulture.NumberFormat ) ); // Seconds
      }



      internal static Int32 CalcMicroseconds( Int64 ticks )
      {
         return (Int32) ( ( ticks / TICKS_PER_MICROSECOND ) % MICROSECONDS_PER_SECOND );
      }

      internal static Int32 CalcMilliseconds( Int64 ticks )
      {
         return (Int32) ( ( ticks / TimeSpan.TicksPerMillisecond ) % MILLISECONDS_PER_SECOND );
      }

      internal static Int32 CalcSeconds( Int64 ticks )
      {
         return (Int32) ( ( ticks / TimeSpan.TicksPerSecond ) % SECONDS_PER_MINUTE );
      }

      internal static Int32 CalcMinutes( Int64 ticks )
      {
         return (Int32) ( ( ticks / TimeSpan.TicksPerMinute ) % MINUTES_PER_HOUR );
      }

      internal static Int32 CalcHours( Int64 ticks )
      {
         return (Int32) ( ticks / TimeSpan.TicksPerHour );
      }

      #endregion

      #region Fields
      private readonly Int32 _months;
      private readonly Int32 _days;
      private readonly Int64 _ticks;

      #endregion

      #region Constructors

      public PgSQLInterval( Int64 ticks )
         : this( 0, 0, ticks )
      {

      }

      public PgSQLInterval( TimeSpan span )
         : this( span.Ticks )
      {

      }

      public PgSQLInterval( Int32 months, Int32 days, Int64 ticks )
      {
         this._months = months;
         this._days = days;
         this._ticks = ticks;
      }

      public PgSQLInterval( Int32 days, Int32 hours, Int32 minutes, Int32 seconds )
         : this( 0, days, new TimeSpan( hours, minutes, seconds ).Ticks )
      {
      }

      public PgSQLInterval( Int32 days, Int32 hours, Int32 minutes, Int32 seconds, Int32 milliseconds )
         : this( 0, days, new TimeSpan( 0, hours, minutes, seconds, milliseconds ).Ticks )
      {
      }

      public PgSQLInterval( Int32 months, Int32 days, Int32 hours, Int32 minutes, Int32 seconds, Int32 milliseconds )
         : this( months, days, new TimeSpan( 0, hours, minutes, seconds, milliseconds ).Ticks )
      {
      }

      public PgSQLInterval( Int32 years, Int32 months, Int32 days, Int32 hours, Int32 minutes, Int32 seconds, Int32 milliseconds )
         : this( years * 12 + months, days, new TimeSpan( 0, hours, minutes, seconds, milliseconds ).Ticks )
      {
      }

      #endregion

      #region Whole parts

      public Int64 Ticks
      {
         get
         {
            return this._ticks;
         }
      }

      public Int32 Microseconds
      {
         get
         {
            return CalcMicroseconds( this._ticks );
         }
      }

      public Int32 Milliseconds
      {
         get
         {
            return CalcMilliseconds( this._ticks );
         }
      }

      public Int32 Seconds
      {
         get
         {
            return CalcSeconds( this._ticks );
         }
      }

      public Int32 Minutes
      {
         get
         {
            return CalcMinutes( this._ticks );
         }
      }

      public Int32 Hours
      {
         get
         {
            return CalcHours( this._ticks );
         }
      }

      public Int32 Days
      {
         get
         {
            return this._days;
         }
      }

      public Int32 Months
      {
         get
         {
            return this._months;
         }
      }
      #endregion

      #region Total parts

      public Int64 TotalTicks
      {
         get
         {
            return this._ticks + this._days * TimeSpan.TicksPerDay + this._months * TICKS_PER_MONTH;
         }
      }

      public Double TotalMicroseconds
      {
         get
         {
            return this.TotalTicks / ( (Double) TICKS_PER_MICROSECOND );
         }
      }

      public Double TotalMilliseconds
      {
         get
         {
            return this.TotalTicks / ( (Double) TimeSpan.TicksPerMillisecond );
         }
      }

      public Double TotalSeconds
      {
         get
         {
            return this.TotalTicks / ( (Double) TimeSpan.TicksPerSecond );
         }
      }

      public Double TotalMinutes
      {
         get
         {
            return this.TotalTicks / ( (Double) TimeSpan.TicksPerMinute );
         }
      }

      public Double TotalHours
      {
         get
         {
            return this.TotalTicks / ( (Double) TimeSpan.TicksPerHour );
         }
      }

      public Double TotalDays
      {
         get
         {
            return this.TotalTicks / ( (Double) TimeSpan.TicksPerDay );
         }
      }

      public Double TotalMonths
      {
         get
         {
            return this.TotalTicks / ( (Double) TICKS_PER_MONTH );
         }
      }

      #endregion

      #region Justification

      public PgSQLInterval JustifyDays()
      {
         return new PgSQLInterval( this._months, this._days + (Int32) ( this._ticks / TimeSpan.TicksPerDay ), this._ticks % TimeSpan.TicksPerDay );
      }

      public PgSQLInterval UnjustifyDays()
      {
         return new PgSQLInterval( this._months, 0, this._ticks + this._days * TimeSpan.TicksPerDay );
      }

      public PgSQLInterval JustifyMonths()
      {
         return new PgSQLInterval( this._months + this._days / DAYS_PER_MONTH, this._days % DAYS_PER_MONTH, this._ticks );
      }

      public PgSQLInterval UnjustifyMonths()
      {
         return new PgSQLInterval( 0, this._days + this._months * DAYS_PER_MONTH, this._ticks );
      }

      public PgSQLInterval JustifyInterval()
      {
         return this.JustifyMonths().JustifyDays();
      }

      public PgSQLInterval UnjustifyInterval()
      {
         return new PgSQLInterval( 0, 0, this._ticks + this._days * TimeSpan.TicksPerDay + this._months * TICKS_PER_MONTH );
      }

      public PgSQLInterval Canonicalize()
      {
         return new PgSQLInterval( 0, this._days + this._months * DAYS_PER_MONTH + (Int32) ( this._ticks / TimeSpan.TicksPerDay ), this._ticks % TimeSpan.TicksPerDay );
      }

      #endregion

      #region Arithmetic

      public PgSQLInterval Add( PgSQLInterval another )
      {
         return new PgSQLInterval( this._months + another._months, this._days + another._days, this._ticks + another._ticks );
      }

      public PgSQLInterval Subtract( PgSQLInterval another )
      {
         return new PgSQLInterval( this._months - another._months, this._days - another._days, this._ticks - another._ticks );
      }

      public PgSQLInterval Negate()
      {
         return new PgSQLInterval( -this._months, -this._days, -this._ticks );
      }

      public PgSQLInterval Duration()
      {
         return this.UnjustifyInterval().Ticks < 0 ? this.Negate() : this;
      }

      #endregion

      #region Comparison

      public Int32 CompareTo( PgSQLInterval other )
      {
         return this.UnjustifyInterval().Ticks.CompareTo( other.UnjustifyInterval().Ticks );
      }

      Int32 IComparable.CompareTo( Object obj )
      {
         if ( obj == null )
         {
            // This is always 'greater' than null
            return 1;
         }
         else if ( obj is PgSQLInterval )
         {
            return this.CompareTo( (PgSQLInterval) obj );
         }
         else
         {
            throw new ArgumentException( "Given object must be of type " + this.GetType() + " or null." );
         }
      }

      public Boolean Equals( PgSQLInterval other )
      {
         return this._ticks == other._ticks && this._days == other._days && this._months == other._months;
      }

      public override Boolean Equals( Object obj )
      {
         return obj != null && obj is PgSQLInterval && this.Equals( (PgSQLInterval) obj );
      }

      public override Int32 GetHashCode()
      {
         return this.UnjustifyInterval().Ticks.GetHashCode();
      }

      #endregion

      #region Casts

      public static implicit operator TimeSpan( PgSQLInterval x )
      {
         return new TimeSpan( x._ticks + x._days * TimeSpan.TicksPerDay + x._months * TICKS_PER_MONTH );
      }

      public static implicit operator PgSQLInterval( TimeSpan x )
      {
         return new PgSQLInterval( x ).Canonicalize();
      }

      #endregion

      #region Creation from parts

      public static PgSQLInterval FromTicks( Int64 ticks )
      {
         return new PgSQLInterval( ticks ).Canonicalize();
      }

      public static PgSQLInterval FromMicroseconds( Double microseconds )
      {
         return FromTicks( (Int64) ( microseconds * ( TimeSpan.TicksPerMillisecond / 1000 ) ) );
      }

      public static PgSQLInterval FromMilliseconds( Double milliseconds )
      {
         return FromTicks( (Int64) ( milliseconds * TimeSpan.TicksPerMillisecond ) );
      }

      public static PgSQLInterval FromSeconds( Double seconds )
      {
         return FromTicks( (Int64) ( seconds * TimeSpan.TicksPerSecond ) );
      }

      public static PgSQLInterval FromMinutes( Double minutes )
      {
         return FromTicks( (Int64) ( minutes * TimeSpan.TicksPerMinute ) );
      }

      public static PgSQLInterval FromHours( Double hours )
      {
         return FromTicks( (Int64) ( hours * TimeSpan.TicksPerHour ) );
      }

      public static PgSQLInterval FromDays( Double days )
      {
         return FromTicks( (Int64) ( days * TimeSpan.TicksPerDay ) );
      }

      public static PgSQLInterval FromMonths( Double months )
      {
         return FromTicks( (Int64) ( months * TICKS_PER_MONTH ) );
      }

      #endregion

      #region Operators

      public static PgSQLInterval operator +( PgSQLInterval x, PgSQLInterval y )
      {
         return x.Add( y );
      }

      public static PgSQLInterval operator -( PgSQLInterval x, PgSQLInterval y )
      {
         return x.Subtract( y );
      }

      public static Boolean operator ==( PgSQLInterval x, PgSQLInterval y )
      {
         return x.Equals( y );
      }

      public static Boolean operator !=( PgSQLInterval x, PgSQLInterval y )
      {
         return !( x == y );
      }

      public static Boolean operator <( PgSQLInterval x, PgSQLInterval y )
      {
         return x.UnjustifyInterval().Ticks < y.UnjustifyInterval().Ticks;
      }

      public static Boolean operator <=( PgSQLInterval x, PgSQLInterval y )
      {
         return x.UnjustifyInterval().Ticks <= y.UnjustifyInterval().Ticks;
      }

      public static Boolean operator >( PgSQLInterval x, PgSQLInterval y )
      {
         return !( x <= y );
      }

      public static Boolean operator >=( PgSQLInterval x, PgSQLInterval y )
      {
         return !( x < y );
      }

      public static PgSQLInterval operator +( PgSQLInterval x )
      {
         return x;
      }

      public static PgSQLInterval operator -( PgSQLInterval x )
      {
         return x.Negate();
      }

      #endregion

      #region To and from string

      public override String ToString()
      {
         var sb = new StringBuilder();

         // Months
         if ( this._months != 0 )
         {
            sb.Append( this._months ).Append( Math.Abs( this._months ) == 1 ? " mon " : " mons " );
         }

         // Days
         if ( this._days != 0 )
         {
            if ( this._months < 0 && this._days > 0 )
            {
               sb.Append( '+' );
            }
            sb.Append( this._days ).Append( Math.Abs( this._days ) == 1 ? " day " : " days " );
         }

         // The rest
         if ( this._ticks != 0 || sb.Length == 0 )
         {
            // The sign
            if ( this._ticks < 0 )
            {
               sb.Append( '-' );
            }
            else if ( this._days < 0 || ( this._days == 0 && this._months < 0 ) )
            {
               sb.Append( '+' );
            }
            AppendTimeInformation( sb, this._ticks );
         }

         return sb.ToString( 0, sb[sb.Length - 1] == ' ' ? ( sb.Length - 1 ) : sb.Length );
      }

      public static PgSQLInterval Parse( String str )
      {
         PgSQLInterval result; Exception error;
         TryParse( str, out result, out error );
         if ( error != null )
         {
            throw error;
         }
         return result;
      }

      public static Boolean TryParse( String str, out PgSQLInterval result )
      {
         Exception error;
         TryParse( str, out result, out error );
         return error == null;
      }

      private static void TryParse( String str, out PgSQLInterval result, out Exception error )
      {
         if ( str == null )
         {
            result = default( PgSQLInterval );
            error = new ArgumentNullException( "String" );
         }
         else
         {
            // Easymode for plurals
            str = str.Replace( 's', ' ' );
            error = null;

            // Initialize variables
            var years = 0;
            var months = 0;
            var days = 0;
            var ticks = 0L;

            // Years
            var idx = str.IndexOf( "year" );
            var start = 0;
            if ( idx > 0 && !Int32.TryParse( str.Substring( start, idx - start ), out years ) )
            {
               error = new FormatException( "Years were in invalid format." );
            }
            UpdateStartIndex( str, idx, ref start, 5 );

            // Months
            if ( error == null )
            {
               idx = str.IndexOf( "mon", start );
               if ( idx > 0 && !Int32.TryParse( str.Substring( start, idx - start ), out months ) )
               {
                  error = new FormatException( "Months were in invalid format." );
               }
               UpdateStartIndex( str, idx, ref start, 4 );
            }

            // Days
            if ( error == null )
            {
               idx = str.IndexOf( "day", start );
               if ( idx > 0 && !Int32.TryParse( str.Substring( start, idx - start ), out days ) )
               {
                  error = new FormatException( "Days were in invalid format." );
               }
               UpdateStartIndex( str, idx, ref start, 4 );
            }

            // Time
            if ( error == null )
            {
               Int32 hours, minutes; Decimal seconds; Boolean isNegative;
               ParseTime( str, start, out hours, out minutes, out seconds, out isNegative, ref error, false );

               if ( error == null )
               {
                  try
                  {
                     ticks = hours * TimeSpan.TicksPerHour + minutes * TimeSpan.TicksPerMinute + (Int64) ( seconds * TimeSpan.TicksPerSecond );
                  }
                  catch ( Exception exc )
                  {
                     // E.g. overflow exception
                     error = new FormatException( "Error when calculating ticks, ", exc );
                  }
               }
            }

            result = error == null ?
               new PgSQLInterval( years * MONTHS_PER_YEAR + months, days, ticks ) :
               default( PgSQLInterval );

         }
      }

      private static void UpdateStartIndex( String str, Int32 idx, ref Int32 startIdx, Int32 addition )
      {
         if ( idx >= 0 )
         {
            startIdx = ( idx + addition ) >= str.Length ? str.Length : ( idx + addition );
         }
      }

      internal static void ParseTime( String str, Int32 start, out Int32 hours, out Int32 minutes, out Decimal seconds, out Boolean isNegative, ref Exception error, Boolean timeIsMandatory )
      {
         hours = 0;
         minutes = 0;
         seconds = 0m;

         var seenOtherThanWhitespace = false;
         isNegative = false;
         var curState = 0; // 0 - hours, 1 - minutes, 2 - seconds
         var idx = start;
         var len = str.Length;
         while ( idx < len && error == null )
         {
            var c = str[idx];
            if ( !Char.IsWhiteSpace( c ) )
            {
               if ( c == '-' )
               {
                  if ( seenOtherThanWhitespace || isNegative )
                  {
                     error = new FormatException( "Unexpected minus sign." );
                  }
                  else
                  {
                     isNegative = true;
                  }
               }
               else if ( c == ':' || idx == len - 1 )
               {
                  var timeStr = str.Substring( start, idx - start + ( c == ':' ? 0 : 1 ) );
                  switch ( curState )
                  {
                     case 0: // Hours
                        if ( !Int32.TryParse( timeStr, out hours ) )
                        {
                           error = new FormatException( "Malformed hours." );
                        }
                        break;
                     case 1: // Minutes
                        if ( !Int32.TryParse( timeStr, out minutes ) )
                        {
                           error = new FormatException( "Malformed minutes." );
                        }
                        break;
                     case 2: // Seconds
                        if ( !Decimal.TryParse( timeStr, System.Globalization.NumberStyles.Number, System.Globalization.CultureInfo.InvariantCulture, out seconds ) )
                        {
                           error = new FormatException( "Malformed seconds." );
                        }
                        break;
                  }

                  ++curState;
                  start = idx + 1;
               }
               seenOtherThanWhitespace = true;

            }
            ++idx;
         }

         if ( curState == 0 && timeIsMandatory )
         {
            error = new FormatException( "Missing time information." );
         }

         if ( isNegative )
         {
            minutes = -minutes;
            seconds = -seconds;
         }
      }

      #endregion

   }

   //public interface IPgSQLDate
   //{
   //   #region Properties

   //   Int32 DayOfYear { get; }

   //   Int32 Year { get; }

   //   Int32 Month { get; }

   //   Int32 Day { get; }

   //   DayOfWeek DayOfWeek { get; }

   //   Int32 DaysSinceEra { get; }

   //   Boolean IsLeapYear { get; }

   //   #endregion
   //}

   public struct PgSQLDate : IEquatable<PgSQLDate>, IComparable, IComparable<PgSQLDate>//, IPgSQLDate
   {
      #region Consts
      public const Int32 MAX_YEAR = 5874897; // As per PostgreSQL documentation
      public const Int32 MIN_YEAR = -4714; // As per PostgreSQL documentation

      private const Int32 DAYS_IN_YEAR = 365; //Common years
      private const Int32 DAYS_IN_4YEARS = 4 * DAYS_IN_YEAR + 1; //Leap year every 4 years.
      private const Int32 DAYS_IN_CENTURY = 25 * DAYS_IN_4YEARS - 1; //Except no leap year every 100.
      private const Int32 DAYS_IN_4CENTURIES = 4 * DAYS_IN_CENTURY + 1; //Except leap year every 400.

      internal const String INFINITY = "infinity";
      internal const String MINUS_INFINITY = "-" + INFINITY;



      #endregion

      #region Static

      // Cumulative days in non-leap years
      private static readonly Int32[] CommonYearDays = new Int32[] { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 };

      // Cumulative days in leap years
      private static readonly Int32[] LeapYearDays = new Int32[] { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 };

      // Amount of days in non-leap year months
      private static readonly Int32[] CommonYearMaxes = new Int32[] { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

      // Amount of days in leap year months
      private static readonly Int32[] LeapYearMaxes = new Int32[] { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

      private static Boolean IsLeap( Int32 year )
      {
         //Every 4 years is a leap year
         //Except every 100 years isn't a leap year.
         //Except every 400 years is.
         // Also: http://support.microsoft.com/kb/214019 (doesn't cover 0 and negative years)
         if ( year < 1 )
         {
            ++year;
         }
         return ( year % 4 == 0 ) && ( ( year % 100 != 0 ) || ( year % 400 == 0 ) );
      }

      private static Int32 DaysForYears( Int32 years )
      {
         //Number of years after 1CE (0 for 1CE, -1 for 1BCE, 1 for 2CE).
         if ( years >= 1 )
         {
            --years;
         }

         return years / 400 * DAYS_IN_4CENTURIES //Blocks of 400 years with their leap and common years
                + years % 400 / 100 * DAYS_IN_CENTURY //Remaining blocks of 100 years with their leap and common years
                + years % 100 / 4 * DAYS_IN_4YEARS //Remaining blocks of 4 years with their leap and common years
                + years % 4 * DAYS_IN_YEAR //Remaining years, all common
                + ( years < 0 ? -1 : 0 ); //And 1BCE is leap.
      }

      private static Int32 ComponentsToDays( Int32 year, Int32 month, Int32 day )
      {
         if ( year == 0 || year < MIN_YEAR || year > MAX_YEAR )
         {
            throw new ArgumentOutOfRangeException( "Year" );
         }
         else if ( month < 1 || month > 12 )
         {
            throw new ArgumentOutOfRangeException( "Month" );
         }
         else
         {
            var isLeap = IsLeap( year );
            if ( day < 1 || day > ( isLeap ? 366 : 365 ) )
            {
               throw new ArgumentOutOfRangeException( "Day" );
            }
            else
            {
               return DaysForYears( year ) + ( isLeap ? LeapYearDays : CommonYearDays )[month - 1] + day - 1;
            }
         }
      }

      public static readonly PgSQLDate Epoch = new PgSQLDate( 1970, 1, 1 );
      public static readonly PgSQLDate MaxValue = new PgSQLDate( MAX_YEAR, 12, 31 );
      public static readonly PgSQLDate MinValue = new PgSQLDate( MIN_YEAR, 11, 24 );
      public static readonly PgSQLDate Era = new PgSQLDate( 0 );
      public static readonly PgSQLDate Infinity = new PgSQLDate( DateTime.MaxValue );
      public static readonly PgSQLDate MinusInfinity = new PgSQLDate( DateTime.MinValue );

      public static PgSQLDate Now
      {
         get
         {
            return new PgSQLDate( DateTime.Now );
         }
      }

      public static PgSQLDate Today
      {
         get
         {
            return Now;
         }
      }

      public static PgSQLDate Yesterday
      {
         get
         {
            return Now.AddDays( -1 );
         }
      }

      public static PgSQLDate Tomorrow
      {
         get
         {
            return Now.AddDays( 1 );
         }
      }

      #endregion

      #region Fields

      private readonly Int32 _days;

      #endregion

      #region Constructors

      public PgSQLDate( Int32 daysSinceEra )
      {
         this._days = daysSinceEra;
      }

      public PgSQLDate( PgSQLDate other )
         : this( other._days )
      {
      }

      public PgSQLDate( DateTime datetime )
         : this( (Int32) ( datetime.Ticks / TimeSpan.TicksPerDay ) )
      {
      }

      public PgSQLDate( Int32 year, Int32 month, Int32 day )
         : this( ComponentsToDays( year, month, day ) )
      {
      }

      #endregion

      #region Properties

      public Int32 DayOfYear
      {
         get
         {
            return this._days - DaysForYears( this.Year ) + 1;
         }
      }

      public Int32 Year
      {
         get
         {
            var start = ( (Int32) Math.Round( this._days / 365.2425 ) ) - 1;
            while ( DaysForYears( ++start ) <= this._days ) ;
            return start - 1;
         }
      }

      public Int32 Month
      {
         get
         {
            var max = this.DayOfYear;
            var array = this.IsLeapYear ? LeapYearDays : CommonYearDays;
            var i = 1;
            while ( max > array[i] )
            {
               ++i;
            }
            return i;
         }
      }

      public Int32 Day
      {
         get
         {
            return this.DayOfYear - ( this.IsLeapYear ? LeapYearDays : CommonYearDays )[this.Month - 1];
         }
      }

      public DayOfWeek DayOfWeek
      {
         get
         {
            return (DayOfWeek) ( ( this._days + 1 ) % 7 );
         }
      }

      public Int32 DaysSinceEra
      {
         get
         {
            return this._days;
         }
      }

      public Boolean IsLeapYear
      {
         get
         {
            return IsLeap( this.Year );
         }
      }

      #endregion

      #region Arithmetics

      public PgSQLDate AddDays( Int32 days )
      {
         return new PgSQLDate( this._days + days );
      }

      public PgSQLDate AddMonths( Int32 months )
      {
         var newYear = this.Year;
         var newMonth = this.Month + months;

         while ( newMonth > 12 )
         {
            newMonth -= 12;
            ++newYear;
            if ( newYear == 0 )
            {
               ++newYear; // No 'zero'eth year.
            }
         };
         while ( newMonth < 1 )
         {
            newMonth += 12;
            --newYear;
            if ( newYear == 0 )
            {
               --newYear; // No 'zero'eth year.
            }
         };
         var maxDay = ( IsLeap( newYear ) ? LeapYearMaxes : CommonYearMaxes )[newMonth - 1];
         var newDay = this.Day > maxDay ? maxDay : this.Day;
         return new PgSQLDate( newYear, newMonth, newDay );
      }

      public PgSQLDate AddYears( Int32 years )
      {
         var newYear = this.Year + years;
         if ( newYear >= 0 && this._days < 0 ) // No 'zero'eth year.
         {
            ++newYear;
         }
         else if ( newYear <= 0 && this._days >= 0 ) // No 'zero'eth year.
         {
            --newYear;
         }
         return new PgSQLDate( newYear, Month, Day );
      }

      public PgSQLDate Add( PgSQLInterval interval, Int32 carriedOverflow = 0 )
      {
         return this.AddMonths( interval.Months ).AddDays( interval.Days + carriedOverflow );
      }

      #endregion

      #region Comparison

      public Boolean Equals( PgSQLDate other )
      {
         return this._days == other._days;
      }

      public override Boolean Equals( Object obj )
      {
         return obj != null && obj is PgSQLDate && this.Equals( (PgSQLDate) obj );
      }

      public override Int32 GetHashCode()
      {
         return this._days.GetHashCode();
      }

      Int32 IComparable.CompareTo( Object obj )
      {
         if ( obj == null )
         {
            // This is always 'greater' than null
            return 1;
         }
         else if ( obj is PgSQLDate )
         {
            return this.CompareTo( (PgSQLDate) obj );
         }
         else
         {
            throw new ArgumentException( "Given object must be of type " + this.GetType() + " or null." );
         }
      }

      public Int32 CompareTo( PgSQLDate other )
      {
         return this._days.CompareTo( other._days );
      }

      #endregion

      #region Casts

      public static explicit operator DateTime( PgSQLDate x )
      {
         try
         {
            return new DateTime( x._days * TimeSpan.TicksPerDay );
         }
         catch
         {
            throw new InvalidCastException( "The given PostgreSQL date " + x + " can not be represented by " + typeof( DateTime ) + "." );
         }
      }

      public static explicit operator PgSQLDate( DateTime x )
      {
         return new PgSQLDate( (Int32) ( x.Ticks / TimeSpan.TicksPerDay ) );
      }

      #endregion

      #region Operators

      public static Boolean operator ==( PgSQLDate x, PgSQLDate y )
      {
         return x.Equals( y );
      }

      public static Boolean operator !=( PgSQLDate x, PgSQLDate y )
      {
         return !( x == y );
      }

      public static Boolean operator <( PgSQLDate x, PgSQLDate y )
      {
         return x._days < y._days;
      }

      public static Boolean operator >( PgSQLDate x, PgSQLDate y )
      {
         return !( x._days <= y._days );
      }

      public static Boolean operator <=( PgSQLDate x, PgSQLDate y )
      {
         return x._days <= y._days;
      }

      public static Boolean operator >=( PgSQLDate x, PgSQLDate y )
      {
         return !( x._days > y._days );
      }

      public static PgSQLDate operator +( PgSQLDate date, PgSQLInterval interval )
      {
         return date.Add( interval );
      }

      public static PgSQLDate operator +( PgSQLInterval interval, PgSQLDate date )
      {
         return date.Add( interval );
      }

      public static PgSQLDate operator -( PgSQLDate date, PgSQLInterval interval )
      {
         return date.Add( -interval );
      }

      public static PgSQLInterval operator -( PgSQLDate dateX, PgSQLDate dateY )
      {
         return new PgSQLInterval( 0, dateX._days - dateY._days, 0 );
      }

      #endregion

      #region To and from string

      internal const Int32 INFINITY_CHAR_COUNT = 8;
      internal const Int32 MINUS_INFINITY_CHAR_COUNT = INFINITY_CHAR_COUNT + 1;
      private const Int32 MIN_NORMAL_CHAR_COUNT = YEAR_CHAR_COUNT + 1 + MONTH_CHAR_COUNT + 1 + DAY_CHAR_COUNT;
      private const Byte SEPARATOR = (Byte) '-';
      private const Int32 YEAR_CHAR_COUNT = 4;
      private const Int32 MONTH_CHAR_COUNT = 2;
      private const Int32 DAY_CHAR_COUNT = 2;
      private const Int32 BC_CHAR_COUNT = 3; // " BC"
      private const Byte BC_CHAR_1 = (Byte) ' ';
      private const Byte BC_CHAR_2 = (Byte) 'B';
      private const Byte BC_CHAR_3 = (Byte) 'C';

      public Int32 GetTextByteCount( IEncodingInfo encoding )
      {
         Int32 retVal;
         if ( this == Infinity )
         {
            retVal = INFINITY_CHAR_COUNT * encoding.BytesPerASCIICharacter;
         }
         else if ( this == MinusInfinity )
         {
            retVal = INFINITY_CHAR_COUNT * encoding.BytesPerASCIICharacter;
         }
         else
         {
            // yyyy-MM-dd
            retVal = MIN_NORMAL_CHAR_COUNT * encoding.BytesPerASCIICharacter;
            if ( this._days < 0 )
            {
               // " BC"
               retVal += BC_CHAR_COUNT * encoding.BytesPerASCIICharacter;
            }
         }
         return retVal;
      }

      public void WriteTextBytes( IEncodingInfo encoding, Byte[] array, ref Int32 offset )
      {
         if ( this == Infinity )
         {
            encoding.WriteString( array, ref offset, INFINITY );
         }
         else if ( this == MinusInfinity )
         {
            encoding.WriteString( array, ref offset, MINUS_INFINITY );
         }
         else
         {
            // Let's not allocate heap objects
            encoding
               .WriteIntegerTextual( array, ref offset, Math.Abs( this.Year ), YEAR_CHAR_COUNT )
               .WriteASCIIByte( array, ref offset, SEPARATOR ) // '-'
               .WriteIntegerTextual( array, ref offset, this.Month, MONTH_CHAR_COUNT )
               .WriteASCIIByte( array, ref offset, SEPARATOR ) // '-'
               .WriteIntegerTextual( array, ref offset, this.Day, DAY_CHAR_COUNT );
            if ( this._days < 0 )
            {
               // " BC"
               encoding
                  .WriteASCIIByte( array, ref offset, BC_CHAR_1 ) // ' '
                  .WriteASCIIByte( array, ref offset, BC_CHAR_2 ) // 'B'
                  .WriteASCIIByte( array, ref offset, BC_CHAR_3 ); // 'C'
            }
         }
      }

      public static PgSQLDate ParseBinaryText( IEncodingInfo encoding, Byte[] array, ref Int32 offset, Int32 count )
      {
         var increment = encoding.BytesPerASCIICharacter;
         switch ( increment * count )
         {
            case INFINITY_CHAR_COUNT:
               return Infinity;
            case MINUS_INFINITY_CHAR_COUNT:
               return MinusInfinity;
            default:
               var max = offset + count;
               var year = encoding.ParseInt32Textual( array, ref offset, (YEAR_CHAR_COUNT, true) );
               var month = encoding.EqualsOrThrow( array, ref offset, SEPARATOR ).ParseInt32Textual( array, ref offset, (MONTH_CHAR_COUNT, true) );
               var day = encoding.EqualsOrThrow( array, ref offset, SEPARATOR ).ParseInt32Textual( array, ref offset, (DAY_CHAR_COUNT, true) );
               if ( offset + 3 * encoding.BytesPerASCIICharacter < max )
               {
                  // " BC" may follow
                  max = offset;
                  if ( encoding.ReadASCIIByte( array, ref offset ) == BC_CHAR_1
                     && encoding.ReadASCIIByte( array, ref offset ) == BC_CHAR_2
                     && encoding.ReadASCIIByte( array, ref offset ) == BC_CHAR_3
                     )
                  {
                     year = -year;
                  }
                  else
                  {
                     // 'Reverse back'
                     offset = max;
                  }
               }
               return new PgSQLDate( year, month, day );
         }
      }

      public override String ToString()
      {
         // As per PostgreSQL documentation ISO 8601 format (same as in Npgsql)
         // Format of yyyy-MM-dd with " BC" for BCE and optional " AD" for CE which we omit here.
         return
             new StringBuilder( Math.Abs( this.Year ).ToString( "D4" ) ).Append( '-' ).Append( this.Month.ToString( "D2" ) ).Append( '-' ).Append(
                 this.Day.ToString( "D2" ) ).Append( this._days < 0 ? " BC" : "" ).ToString();
      }

      public static PgSQLDate Parse( String str )
      {
         PgSQLDate result; Exception error;
         TryParse( str, out result, out error );
         if ( error != null )
         {
            throw error;
         }
         return result;
      }

      public static Boolean TryParse( String str, out PgSQLDate result )
      {
         Exception error;
         return TryParse( str, out result, out error );
      }

      internal static Boolean TryParse( String str, out PgSQLDate result, out Exception error )
      {
         if ( str == null )
         {
            result = default( PgSQLDate );
            error = new ArgumentNullException( "String" );
         }
         else
         {
            str = str.Trim();
            error = null;
            if ( String.Equals( str, INFINITY, StringComparison.OrdinalIgnoreCase ) )
            {
               result = Infinity;
            }
            else if ( String.Equals( str, MINUS_INFINITY, StringComparison.OrdinalIgnoreCase ) )
            {
               result = MinusInfinity;
            }
            else
            {
               // ISO 8601 format assumed
               var start = 0;
               var idx = 0;
               var year = IntegerOrError( str, ref start, ref idx, ref error, "year", "month", '-', true );
               var month = IntegerOrError( str, ref start, ref idx, ref error, "month", "day", '-', true );
               var day = IntegerOrError( str, ref start, ref idx, ref error, "day", null, ' ', false );
               if ( error == null && start < str.Length && str.IndexOf( "BC", start, StringComparison.OrdinalIgnoreCase ) != -1 )
               {
                  year = -year;
               }

               result = error == null ?
                  new PgSQLDate( year, month, day ) :
                  default( PgSQLDate );
            }
         }
         return error == null;
      }

      private static Int32 IntegerOrError( String str, ref Int32 start, ref Int32 idx, ref Exception error, String thisDatePart, String nextDatePart, Char separator, Boolean separatorIsMandatory )
      {
         var result = 0;
         if ( error == null )
         {
            if ( start >= str.Length )
            {
               error = new FormatException( "Missing " + thisDatePart );
            }
            else
            {
               idx = str.IndexOf( separator, start );
               if ( idx == -1 && !separatorIsMandatory )
               {
                  idx = str.Length;
               }

               if ( idx == -1 )
               {
                  error = new FormatException( "Could not find " + thisDatePart + "-" + nextDatePart + " separator." );
               }
               else if ( !Int32.TryParse( str.Substring( start, idx - start ), out result ) )
               {
                  error = new FormatException( thisDatePart + " was malformed." );
               }
               else
               {
                  start = idx + 1;
               }
            }
         }
         return result;
      }

      #endregion

   }

   //public interface IPgSQLTime
   //{
   //   #region Properties

   //   Int64 Ticks { get; }

   //   Int32 Microseconds { get; }

   //   Int32 Milliseconds { get; }

   //   Int32 Seconds { get; }

   //   Int32 Minutes { get; }

   //   Int32 Hours { get; }

   //   #endregion
   //}

   public struct PgSQLTime : IEquatable<PgSQLTime>, IComparable, IComparable<PgSQLTime>//, IPgSQLTime
   {
      #region Static

      public static readonly PgSQLTime AllBalls = new PgSQLTime( 0 );

      public static PgSQLTime Now
      {
         get
         {
            return new PgSQLTime( DateTime.Now.TimeOfDay );
         }
      }

      #endregion

      #region Fields
      private readonly Int64 _ticks;
      #endregion

      #region Constructors

      public PgSQLTime( Int64 ticks )
      {
         if ( ticks == TimeSpan.TicksPerDay )
         {
            this._ticks = ticks;
         }
         else
         {
            ticks %= TimeSpan.TicksPerDay;
            this._ticks = ticks < 0 ? ticks + TimeSpan.TicksPerDay : ticks;
         }
      }

      public PgSQLTime( TimeSpan timeSpan )
         : this( timeSpan.Ticks )
      {
      }

      public PgSQLTime( DateTime dateTime )
         : this( dateTime.Ticks )
      {
      }

      public PgSQLTime( PgSQLInterval interval )
         : this( interval.Ticks )
      {
      }

      public PgSQLTime( PgSQLTime other )
         : this( other._ticks )
      {
      }

      public PgSQLTime( Int32 hours, Int32 minutes, Int32 seconds )
         : this( hours, minutes, seconds, 0 )
      {
      }

      public PgSQLTime( Int32 hours, Int32 minutes, Int32 seconds, Int32 microseconds )
         : this(
             hours * TimeSpan.TicksPerHour + minutes * TimeSpan.TicksPerMinute + seconds * TimeSpan.TicksPerSecond +
             microseconds * PgSQLInterval.TICKS_PER_MICROSECOND )
      {
      }

      public PgSQLTime( Int32 hours, Int32 minutes, Decimal seconds )
         : this( hours * TimeSpan.TicksPerHour + minutes * TimeSpan.TicksPerMinute + (Int64) ( seconds * TimeSpan.TicksPerSecond ) )
      {
      }

      #endregion

      #region Properties

      public Int64 Ticks
      {
         get
         {
            return this._ticks;
         }
      }

      public Int32 Microseconds
      {
         get
         {
            return PgSQLInterval.CalcMicroseconds( this._ticks );
         }
      }

      public Int32 Milliseconds
      {
         get
         {
            return PgSQLInterval.CalcMilliseconds( this._ticks );
         }
      }

      public Int32 Seconds
      {
         get
         {
            return PgSQLInterval.CalcSeconds( this._ticks );
         }
      }

      public Int32 Minutes
      {
         get
         {
            return PgSQLInterval.CalcMinutes( this._ticks );
         }
      }

      public Int32 Hours
      {
         get
         {
            return PgSQLInterval.CalcHours( this._ticks );
         }
      }

      #endregion

      #region Comparison

      public Boolean Equals( PgSQLTime other )
      {
         return this._ticks == other._ticks;
      }

      public override Boolean Equals( Object obj )
      {
         return obj != null && obj is PgSQLTime && this.Equals( (PgSQLTime) obj );
      }

      public override Int32 GetHashCode()
      {
         return this._ticks.GetHashCode();
      }

      Int32 IComparable.CompareTo( Object obj )
      {
         if ( obj == null )
         {
            // This is always 'greater' than null
            return 1;
         }
         else if ( obj is PgSQLTime )
         {
            return this.CompareTo( (PgSQLTime) obj );
         }
         else
         {
            throw new ArgumentException( "Given object must be of type " + this.GetType() + " or null." );
         }
      }

      public Int32 CompareTo( PgSQLTime other )
      {
         return this.Normalize()._ticks.CompareTo( other.Normalize()._ticks );
      }

      #endregion

      #region Normalization

      public PgSQLTime Normalize()
      {
         return new PgSQLTime( this._ticks % TimeSpan.TicksPerDay );
      }

      #endregion

      #region Arithmetics

      public PgSQLTime AddTicks( Int64 ticksAdded )
      {
         return new PgSQLTime( ( Ticks + ticksAdded ) % TimeSpan.TicksPerDay );
      }

      private PgSQLTime AddTicks( Int64 ticksAdded, out Int32 overflow )
      {
         var result = Ticks + ticksAdded;
         overflow = (Int32) ( result / TimeSpan.TicksPerDay );
         result %= TimeSpan.TicksPerDay;
         if ( result < 0 )
         {
            --overflow; //"carry the one"
         }
         return new PgSQLTime( result );
      }

      public PgSQLTime Add( PgSQLInterval interval )
      {
         return AddTicks( interval.Ticks );
      }

      internal PgSQLTime Add( PgSQLInterval interval, out Int32 overflow )
      {
         return AddTicks( interval.Ticks, out overflow );
      }

      public PgSQLTime Subtract( PgSQLInterval interval )
      {
         return AddTicks( -interval.Ticks );
      }

      public PgSQLInterval Subtract( PgSQLTime earlier )
      {
         return new PgSQLInterval( Ticks - earlier.Ticks );
      }

      #endregion

      #region Timezones

      public PgSQLTimeTZ AtTimeZone( PgSQLTimeZone timeZone )
      {
         return new PgSQLTimeTZ( this ).AtTimeZone( timeZone );
      }

      #endregion

      #region Casts

      public static explicit operator DateTime( PgSQLTime x )
      {
         return new DateTime( x._ticks, DateTimeKind.Unspecified );
      }

      public static explicit operator PgSQLTime( DateTime x )
      {
         return new PgSQLTime( x.Ticks );
      }

      public static explicit operator TimeSpan( PgSQLTime x )
      {
         return new TimeSpan( x._ticks );
      }

      public static explicit operator PgSQLTime( TimeSpan x )
      {
         return new PgSQLTime( x.Ticks );
      }

      public static explicit operator PgSQLInterval( PgSQLTime x )
      {
         return new PgSQLInterval( x._ticks );
      }

      public static explicit operator PgSQLTime( PgSQLInterval x )
      {
         return new PgSQLTime( x );
      }

      #endregion

      #region Operators

      public static Boolean operator ==( PgSQLTime x, PgSQLTime y )
      {
         return x.Equals( y );
      }

      public static Boolean operator !=( PgSQLTime x, PgSQLTime y )
      {
         return !( x == y );
      }

      public static Boolean operator <( PgSQLTime x, PgSQLTime y )
      {
         return x.Ticks < y.Ticks;
      }

      public static Boolean operator <=( PgSQLTime x, PgSQLTime y )
      {
         return x.Ticks <= y.Ticks;
      }

      public static Boolean operator >( PgSQLTime x, PgSQLTime y )
      {
         return !( x.Ticks <= y.Ticks );
      }

      public static Boolean operator >=( PgSQLTime x, PgSQLTime y )
      {
         return !( x.Ticks < y.Ticks );
      }

      public static PgSQLTime operator +( PgSQLTime time, PgSQLInterval interval )
      {
         return time.Add( interval );
      }

      public static PgSQLTime operator +( PgSQLInterval interval, PgSQLTime time )
      {
         return time + interval;
      }

      public static PgSQLTime operator -( PgSQLTime time, PgSQLInterval interval )
      {
         return time.Subtract( interval );
      }

      public static PgSQLInterval operator -( PgSQLTime later, PgSQLTime earlier )
      {
         return later.Subtract( earlier );
      }

      #endregion

      #region To and from string

      private const Byte SEPARATOR = (Byte) ':';
      private const Byte MICRO_SEPARATOR = (Byte) '.';
      private const Int32 HOUR_CHAR_COUNT = 2;
      private const Int32 MINUTE_CHAR_COUNT = 2;
      private const Int32 SECOND_CHAR_COUNT = 2;
      private const Int32 MICRO_PRECISION = 6;

      internal static Int32 GetTextByteCount( IEncodingInfo encoding, Int64 ticks )
      {
         var retVal = 8 * encoding.BytesPerASCIICharacter; // HH:mm:ss
         var microSeconds = Math.Abs( PgSQLInterval.CalcMicroseconds( ticks ) );
         if ( microSeconds > 0 )
         {
            // Need to append '.' and micro second count
            retVal += encoding.BytesPerASCIICharacter + encoding.GetTextualFractionIntegerSize( microSeconds, MICRO_PRECISION );
         }

         return retVal;
      }

      internal static void WriteTextBytes( IEncodingInfo encoding, Int64 ticks, Byte[] array, ref Int32 offset )
      {
         encoding
            .WriteIntegerTextual( array, ref offset, Math.Abs( (Int32) ( ticks / TimeSpan.TicksPerHour ) ), HOUR_CHAR_COUNT )
            .WriteASCIIByte( array, ref offset, SEPARATOR ) // ':'
            .WriteIntegerTextual( array, ref offset, Math.Abs( (Int32) ( ( ticks / TimeSpan.TicksPerMinute ) % PgSQLInterval.MINUTES_PER_HOUR ) ), MINUTE_CHAR_COUNT )
            .WriteASCIIByte( array, ref offset, SEPARATOR ) // ':'
            .WriteIntegerTextual( array, ref offset, Math.Abs( (Int32) ( ( ticks / TimeSpan.TicksPerSecond ) % PgSQLInterval.SECONDS_PER_MINUTE ) ), SECOND_CHAR_COUNT );

         var microSeconds = Math.Abs( PgSQLInterval.CalcMicroseconds( ticks ) );
         if ( microSeconds != 0 )
         {
            encoding
               .WriteASCIIByte( array, ref offset, MICRO_SEPARATOR ) // '.'
               .WriteFractionIntegerTextual( array, ref offset, microSeconds, MICRO_PRECISION );
         }
      }

      public Int32 GetTextByteCount( IEncodingInfo encoding )
      {
         return GetTextByteCount( encoding, this._ticks );
      }

      public void WriteTextBytes( IEncodingInfo encoding, Byte[] array, ref Int32 offset )
      {
         WriteTextBytes( encoding, this._ticks, array, ref offset );
      }

      public static PgSQLTime ParseBinaryText( IEncodingInfo encoding, Byte[] array, ref Int32 offset, Int32 count )
      {
         var max = offset + count;
         var hours = encoding.ParseInt32Textual( array, ref offset, (HOUR_CHAR_COUNT, true) );
         var minutes = encoding.EqualsOrThrow( array, ref offset, SEPARATOR ).ParseInt32Textual( array, ref offset, (MINUTE_CHAR_COUNT, true) );
         var seconds = encoding.EqualsOrThrow( array, ref offset, SEPARATOR ).ParseInt32Textual( array, ref offset, (SECOND_CHAR_COUNT, true) );
         var oldIdx = offset;
         if ( encoding.TryParseOptionalNumber( array, ref offset, MICRO_SEPARATOR, (MICRO_PRECISION, false), max, out Int32 micros ) )
         {
            // When calculating trailing zeroes, we must take the prefix (MICRO_SEPARATOR) into account 
            var trailingZeroesCount = MICRO_PRECISION - ( offset - oldIdx - encoding.BytesPerASCIICharacter );
            while ( trailingZeroesCount > 0 )
            {
               micros *= 10;
               --trailingZeroesCount;
            }
         }

         return new PgSQLTime( hours, minutes, seconds, micros );
      }

      public override String ToString()
      {
         var sb = new StringBuilder();
         PgSQLInterval.AppendTimeInformation( sb, this._ticks );
         return sb.ToString();
      }

      public static PgSQLTime Parse( String str )
      {
         PgSQLTime result; Exception error;
         TryParse( str, out result, out error );
         if ( error != null )
         {
            throw error;
         }
         return result;
      }

      public static Boolean TryParse( String str, out PgSQLTime result )
      {
         Exception error;
         return TryParse( str, out result, out error );
      }

      internal static Boolean TryParse( String str, out PgSQLTime result, out Exception error )
      {
         if ( str == null )
         {
            result = default( PgSQLTime );
            error = new ArgumentNullException( "String" );
         }
         else
         {
            error = null;
            Int32 hours, minutes; Decimal seconds; Boolean isNegative;
            PgSQLInterval.ParseTime( str, 0, out hours, out minutes, out seconds, out isNegative, ref error, true );
            if ( hours < 0 || hours > 24 || minutes < 0 || minutes > 59 || seconds < 0m || seconds >= 60m || ( hours == 24 && ( minutes != 0 || seconds != 0m ) ) )
            {
               error = new FormatException( "One of the hours, minutes, or seconds (" + hours + ":" + minutes + ":" + seconds + ") was out of range." );
            }

            result = error == null ?
               new PgSQLTime( hours, minutes, seconds ) :
               default( PgSQLTime );
         }
         return error == null;
      }

      #endregion

   }

   public struct PgSQLTimeZone : IEquatable<PgSQLTimeZone>, IComparable, IComparable<PgSQLTimeZone>
   {
      #region Consts

      private const Int32 MINUTES_PER_HOUR = (Int32) PgSQLInterval.MINUTES_PER_HOUR;
      private const Int32 SECONDS_PER_MINUTE = (Int32) PgSQLInterval.SECONDS_PER_MINUTE;

      #endregion

      #region Static

      public static readonly PgSQLTimeZone UTC = new PgSQLTimeZone( 0 );

      public static PgSQLTimeZone CurrentTimeZone
      {
         get
         {
            return new PgSQLTimeZone( TimeZoneInfo.Local.GetUtcOffset( DateTime.Now ) );
         }
      }

      public static PgSQLTimeZone GetSolarTimeZone( Decimal longitude )
      {
         return new PgSQLTimeZone( (Int64) ( longitude / 15m * TimeSpan.TicksPerHour ) );
      }

      public static PgSQLTimeZone GetLocalTimeZone( PgSQLDate date )
      {
         return new PgSQLTimeZone( TimeZoneInfo.Local.GetUtcOffset(
            date.Year >= 1902 && date.Year < 2038 ?
               (DateTime) date :
               new DateTime( 2000, date.Month, date.Day )
            ) );
      }

      #endregion

      #region Fields

      private readonly Int32 _totalSeconds;

      #endregion

      #region Constructors

      public PgSQLTimeZone( Int64 ticks )
         : this( (Int32) ( ticks / TimeSpan.TicksPerSecond ) )
      {
      }

      public PgSQLTimeZone( Int32 hours, Int32 minutes )
         : this( hours, minutes, 0 )
      {
      }

      public PgSQLTimeZone( Int32 hours, Int32 minutes, Int32 seconds )
         : this( hours * MINUTES_PER_HOUR * SECONDS_PER_MINUTE + minutes * SECONDS_PER_MINUTE + seconds )
      {
      }

      public PgSQLTimeZone( PgSQLTimeZone other )
         : this( other._totalSeconds )
      {
      }

      public PgSQLTimeZone( PgSQLInterval interval )
         : this( interval.Ticks )
      {
      }

      public PgSQLTimeZone( TimeSpan timeSpan )
         : this( timeSpan.Ticks )
      {
      }

      private PgSQLTimeZone( Int32 seconds )
      {
         this._totalSeconds = seconds;
      }

      #endregion

      #region Properties

      public Int32 Hours
      {
         get
         {
            return this._totalSeconds / MINUTES_PER_HOUR / SECONDS_PER_MINUTE;
         }
      }

      public Int32 Minutes
      {
         get
         {
            return ( this._totalSeconds / MINUTES_PER_HOUR ) % SECONDS_PER_MINUTE;
         }
      }

      public Int32 Seconds
      {
         get
         {
            return this._totalSeconds % SECONDS_PER_MINUTE;
         }
      }

      public Int32 TotalSeconds
      {
         get
         {
            return this._totalSeconds;
         }
      }

      #endregion

      #region Comparison

      public Boolean Equals( PgSQLTimeZone other )
      {
         return this._totalSeconds == other._totalSeconds;
      }

      public override Boolean Equals( Object obj )
      {
         return obj != null && obj is PgSQLTimeZone && this.Equals( (PgSQLTimeZone) obj );
      }

      public override Int32 GetHashCode()
      {
         return this._totalSeconds.GetHashCode();
      }

      Int32 IComparable.CompareTo( Object obj )
      {
         if ( obj == null )
         {
            // This is always 'greater' than null
            return 1;
         }
         else if ( obj is PgSQLTimeZone )
         {
            return this.CompareTo( (PgSQLTimeZone) obj );
         }
         else
         {
            throw new ArgumentException( "Given object must be of type " + this.GetType() + " or null." );
         }
      }

      public Int32 CompareTo( PgSQLTimeZone other )
      {
         // Note: +01:00 is less than -01:00, so we have to invert the result (accomplished by comparing other to this instead of this to other)
         return other._totalSeconds.CompareTo( this._totalSeconds );
      }

      #endregion

      #region Casts

      public static implicit operator PgSQLTimeZone( PgSQLInterval interval )
      {
         return new PgSQLTimeZone( interval );
      }

      public static implicit operator PgSQLInterval( PgSQLTimeZone timeZone )
      {
         return new PgSQLInterval( timeZone._totalSeconds * TimeSpan.TicksPerSecond );
      }

      public static implicit operator PgSQLTimeZone( TimeSpan interval )
      {
         return new PgSQLTimeZone( (PgSQLInterval) interval );
      }

      public static implicit operator TimeSpan( PgSQLTimeZone timeZone )
      {
         return new TimeSpan( timeZone._totalSeconds * TimeSpan.TicksPerSecond );
      }

      #endregion

      #region Operators

      public static Boolean operator ==( PgSQLTimeZone x, PgSQLTimeZone y )
      {
         return x.Equals( y );
      }

      public static Boolean operator !=( PgSQLTimeZone x, PgSQLTimeZone y )
      {
         return !( x == y );
      }

      public static Boolean operator <( PgSQLTimeZone x, PgSQLTimeZone y )
      {
         return x._totalSeconds < y._totalSeconds;
      }

      public static Boolean operator <=( PgSQLTimeZone x, PgSQLTimeZone y )
      {
         return x._totalSeconds <= y._totalSeconds;
      }

      public static Boolean operator >( PgSQLTimeZone x, PgSQLTimeZone y )
      {
         return !( x <= y );
      }

      public static Boolean operator >=( PgSQLTimeZone x, PgSQLTimeZone y )
      {
         return !( x < y );
      }

      public static PgSQLTimeZone operator -( PgSQLTimeZone tz )
      {
         return new PgSQLTimeZone( -tz._totalSeconds );
      }

      public static PgSQLTimeZone operator +( PgSQLTimeZone tz )
      {
         return tz;
      }

      #endregion

      #region To and from string

      private const Byte PREFIX_POS = (Byte) '+';
      private const Byte PREFIX_NEG = (Byte) '-';
      private const Byte SEPARATOR = (Byte) ':';
      private const Int32 HOURS_CHAR_COUNT = 2;
      private const Int32 MINUTES_CHAR_COUNT = 2;
      private const Int32 SECONDS_CHAR_COUNT = 2;

      public Int32 GetTextByteCount( IEncodingInfo encoding )
      {
         var retVal = 3 * encoding.BytesPerASCIICharacter; // +/-, and always 2 digits for hours
         var mins = this.Minutes;
         var secs = this.Seconds;
         if ( mins != 0 || secs != 0 )
         {
            retVal += 3 * encoding.BytesPerASCIICharacter; // For minutes, always
            if ( secs != 0 )
            {
               retVal += 3 * encoding.BytesPerASCIICharacter; // For seconds
            }
         }

         return retVal;
      }

      public void WriteTextBytes( IEncodingInfo encoding, Byte[] array, ref Int32 offset )
      {
         var hours = this.Hours;
         encoding.WriteASCIIByte( array, ref offset, hours > 0 ? PREFIX_POS : PREFIX_NEG ); // +/-
         hours = Math.Abs( hours );
         encoding.WriteIntegerTextual( array, ref offset, hours, HOURS_CHAR_COUNT );
         var mins = this.Minutes;
         var secs = this.Seconds;
         if ( mins != 0 || secs != 0 )
         {
            encoding
               .WriteASCIIByte( array, ref offset, SEPARATOR ) // ':'
               .WriteIntegerTextual( array, ref offset, Math.Abs( mins ), MINUTES_CHAR_COUNT );
            if ( secs != 0 )
            {
               encoding
                  .WriteASCIIByte( array, ref offset, SEPARATOR ) // ':'
                  .WriteIntegerTextual( array, ref offset, Math.Abs( secs ), SECONDS_CHAR_COUNT );
            }
         }
      }

      internal static PgSQLTimeZone ParseBinaryText( IEncodingInfo encoding, Byte[] array, ref Int32 offset, Int32 count )
      {
         var max = offset + count;
         var prefix = encoding.ReadASCIIByte( array, ref offset );
         if ( prefix != PREFIX_POS && prefix != PREFIX_NEG )
         {
            throw new FormatException( $"Expected timezone string to start with either '{PREFIX_POS}' or '{PREFIX_NEG}' characters." );
         }
         var hours = encoding.ParseInt32Textual( array, ref offset, (HOURS_CHAR_COUNT, true) );
         encoding.TryParseOptionalNumber( array, ref offset, SEPARATOR, (MINUTES_CHAR_COUNT, true), max, out Int32 minutes );
         encoding.TryParseOptionalNumber( array, ref offset, SEPARATOR, (SECONDS_CHAR_COUNT, true), max, out Int32 seconds );
         return new PgSQLTimeZone( hours, minutes, seconds );
      }

      public override String ToString()
      {
         var sb = new StringBuilder( this.Hours.ToString( "+0#;-0#" ) );
         if ( this.Minutes != 0 || this.Seconds != 0 )
         {
            sb.Append( ':' ).Append( Math.Abs( this.Minutes ).ToString( "D2" ) );
            if ( this.Seconds != 0 )
            {
               sb.Append( ':' ).Append( Math.Abs( this.Seconds ).ToString( "D2" ) );
            }
         }
         return sb.ToString();
      }

      public static PgSQLTimeZone Parse( String str )
      {
         PgSQLTimeZone result; Exception error;
         TryParse( str, out result, out error );
         if ( error != null )
         {
            throw error;
         }
         return result;
      }

      public static Boolean TryParse( String str, out PgSQLTimeZone result )
      {
         Exception error;
         return TryParse( str, out result, out error );
      }

      internal static Boolean TryParse( String str, out PgSQLTimeZone result, out Exception error )
      {
         if ( str == null )
         {
            result = default( PgSQLTimeZone );
            error = new ArgumentNullException( "String" );
         }
         else
         {
            error = null;
            var totalSeconds = 0;
            if ( str.Length <= 1 )
            {
               error = new FormatException( "Too short string." );
            }
            else
            {

               if ( error == null )
               {
                  Int32 hours, minutes; Decimal seconds; Boolean isNegative;
                  PgSQLInterval.ParseTime( str, 0, out hours, out minutes, out seconds, out isNegative, ref error, true );

                  if ( error == null )
                  {
                     seconds = Decimal.Truncate( seconds );
                     if ( seconds >= new Decimal( Int32.MinValue ) && seconds <= new Decimal( Int32.MaxValue ) )
                     {
                        totalSeconds = hours * MINUTES_PER_HOUR * SECONDS_PER_MINUTE + minutes * SECONDS_PER_MINUTE + (Int32) seconds;
                     }
                     else
                     {
                        error = new FormatException( "Seconds (" + seconds + ") are out of range for Int32." );
                     }
                  }
               }
            }

            result = error == null ?
               new PgSQLTimeZone( totalSeconds ) :
               default( PgSQLTimeZone );
         }
         return error == null;
      }

      #endregion
   }

   //public interface IPgSQLTimeTZ : IPgSQLTime
   //{
   //   #region Properties

   //   PgSQLTime LocalTime { get; }

   //   PgSQLTimeZone TimeZone { get; }

   //   PgSQLTime UTCTime { get; }

   //   #endregion
   //}

   public struct PgSQLTimeTZ : IEquatable<PgSQLTimeTZ>, IComparable, IComparable<PgSQLTimeTZ>//, IPgSQLTimeTZ
   {
      #region Static

      public static readonly PgSQLTimeTZ AllBalls = new PgSQLTimeTZ( PgSQLTime.AllBalls, PgSQLTimeZone.UTC );

      public static PgSQLTimeTZ Now
      {
         get
         {
            return new PgSQLTimeTZ( PgSQLTime.Now );
         }
      }

      public static PgSQLTimeTZ GetLocalMidnightFor( PgSQLDate date )
      {
         return new PgSQLTimeTZ( PgSQLTime.AllBalls, PgSQLTimeZone.GetLocalTimeZone( date ) );
      }

      #endregion

      #region Fields

      private readonly PgSQLTime _localTime;
      private readonly PgSQLTimeZone _timeZone;

      #endregion

      #region Constructors

      public PgSQLTimeTZ( PgSQLTime localTime, PgSQLTimeZone timeZone )
      {
         _localTime = localTime;
         _timeZone = timeZone;
      }

      public PgSQLTimeTZ( PgSQLTime localTime )
         : this( localTime, PgSQLTimeZone.CurrentTimeZone )
      {
      }

      public PgSQLTimeTZ( Int64 ticks )
         : this( new PgSQLTime( ticks ) )
      {
      }

      public PgSQLTimeTZ( TimeSpan time )
         : this( new PgSQLTime( time ) )
      {
      }

      public PgSQLTimeTZ( PgSQLInterval time )
         : this( new PgSQLTime( time ) )
      {
      }

      public PgSQLTimeTZ( PgSQLTimeTZ copyFrom )
         : this( copyFrom._localTime, copyFrom._timeZone )
      {
      }

      public PgSQLTimeTZ( Int32 hours, Int32 minutes, Int32 seconds )
         : this( new PgSQLTime( hours, minutes, seconds ) )
      {
      }

      public PgSQLTimeTZ( Int32 hours, Int32 minutes, Int32 seconds, Int32 microseconds )
         : this( new PgSQLTime( hours, minutes, seconds, microseconds ) )
      {
      }

      public PgSQLTimeTZ( Int32 hours, Int32 minutes, Decimal seconds )
         : this( new PgSQLTime( hours, minutes, seconds ) )
      {
      }

      public PgSQLTimeTZ( long ticks, PgSQLTimeZone timeZone )
         : this( new PgSQLTime( ticks ), timeZone )
      {
      }

      public PgSQLTimeTZ( TimeSpan time, PgSQLTimeZone timeZone )
         : this( new PgSQLTime( time ), timeZone )
      {
      }

      public PgSQLTimeTZ( PgSQLInterval time, PgSQLTimeZone timeZone )
         : this( new PgSQLTime( time ), timeZone )
      {
      }

      public PgSQLTimeTZ( Int32 hours, Int32 minutes, Int32 seconds, PgSQLTimeZone timeZone )
         : this( new PgSQLTime( hours, minutes, seconds ), timeZone )
      {
      }

      public PgSQLTimeTZ( Int32 hours, Int32 minutes, Int32 seconds, Int32 microseconds, PgSQLTimeZone timeZone )
         : this( new PgSQLTime( hours, minutes, seconds, microseconds ), timeZone )
      {
      }

      public PgSQLTimeTZ( Int32 hours, Int32 minutes, Decimal seconds, PgSQLTimeZone timeZone )
         : this( new PgSQLTime( hours, minutes, seconds ), timeZone )
      {
      }

      #endregion

      #region Properties

      public PgSQLTime LocalTime
      {
         get
         {
            return this._localTime;
         }
      }

      public PgSQLTimeZone TimeZone
      {
         get
         {
            return this._timeZone;
         }
      }

      public PgSQLTime UTCTime
      {
         get
         {
            return this.AtTimeZone( PgSQLTimeZone.UTC ).LocalTime;
         }
      }

      public Int32 Microseconds
      {
         get
         {
            return this._localTime.Microseconds;
         }
      }

      public Int32 Milliseconds
      {
         get
         {
            return this._localTime.Milliseconds;
         }
      }

      public Int32 Seconds
      {
         get
         {
            return this._localTime.Seconds;
         }
      }

      public Int32 Minutes
      {
         get
         {
            return this._localTime.Minutes;
         }
      }

      public Int32 Hours
      {
         get
         {
            return this._localTime.Hours;
         }
      }

      public Int64 Ticks
      {
         get
         {
            return this._localTime.Ticks;
         }
      }

      #endregion

      #region Comparison

      public Boolean Equals( PgSQLTimeTZ other )
      {
         return this._localTime.Equals( other._localTime ) && this._timeZone.Equals( other._timeZone );
      }

      public override Boolean Equals( Object obj )
      {
         return obj != null && obj is PgSQLTimeTZ && this.Equals( (PgSQLTimeTZ) obj );
      }

      public override Int32 GetHashCode()
      {
         // Like in point
         unchecked
         {
            return ( 17 * 23 + this._localTime.GetHashCode() ) * 23 + this._timeZone.GetHashCode();
         }
      }

      Int32 IComparable.CompareTo( Object obj )
      {
         if ( obj == null )
         {
            // This is always 'greater' than null
            return 1;
         }
         else if ( obj is PgSQLTimeTZ )
         {
            return this.CompareTo( (PgSQLTimeTZ) obj );
         }
         else
         {
            throw new ArgumentException( "Given object must be of type " + this.GetType() + " or null." );
         }
      }

      public Int32 CompareTo( PgSQLTimeTZ other )
      {
         var utcCompare = this.UTCTime.CompareTo( other.UTCTime );
         return utcCompare == 0 ? this._timeZone.CompareTo( other._timeZone ) : utcCompare;
      }

      #endregion

      #region Arithmetics

      public PgSQLTimeTZ Normalize()
      {
         return new PgSQLTimeTZ( this._localTime.Normalize(), this._timeZone );
      }

      public PgSQLTimeTZ AtTimeZone( PgSQLTimeZone timeZone )
      {
         return new PgSQLTimeTZ( this._localTime - this._timeZone + timeZone, timeZone );
      }

      public PgSQLTimeTZ AtTimeZone( PgSQLTimeZone timeZone, out Int32 overflow )
      {
         return new PgSQLTimeTZ( this._localTime.Add( timeZone - (PgSQLInterval) ( _timeZone ), out overflow ), timeZone );
      }

      public PgSQLTimeTZ Add( PgSQLInterval interval )
      {
         return new PgSQLTimeTZ( _localTime.Add( interval ), _timeZone );
      }

      internal PgSQLTimeTZ Add( PgSQLInterval interval, out Int32 overflow )
      {
         return new PgSQLTimeTZ( _localTime.Add( interval, out overflow ), _timeZone );
      }

      public PgSQLTimeTZ Subtract( PgSQLInterval interval )
      {
         return new PgSQLTimeTZ( _localTime.Subtract( interval ), _timeZone );
      }

      public PgSQLInterval Subtract( PgSQLTimeTZ earlier )
      {
         return _localTime.Subtract( earlier.AtTimeZone( _timeZone )._localTime );
      }

      #endregion

      #region Casts

      public static explicit operator DateTime( PgSQLTimeTZ x )
      {
         return new DateTime( x.AtTimeZone( PgSQLTimeZone.CurrentTimeZone ).Ticks, DateTimeKind.Local );
      }

      public static explicit operator PgSQLTimeTZ( DateTime x )
      {
         return new PgSQLTimeTZ( new PgSQLTime( x ) );
      }

      public static explicit operator TimeSpan( PgSQLTimeTZ x )
      {
         return (TimeSpan) x.LocalTime;
      }

      public static explicit operator PgSQLTimeTZ( TimeSpan x )
      {
         return new PgSQLTimeTZ( (PgSQLTime) x );
      }

      #endregion

      #region Operators

      public static Boolean operator ==( PgSQLTimeTZ x, PgSQLTimeTZ y )
      {
         return x.Equals( y );
      }

      public static Boolean operator !=( PgSQLTimeTZ x, PgSQLTimeTZ y )
      {
         return !( x == y );
      }

      public static Boolean operator <( PgSQLTimeTZ x, PgSQLTimeTZ y )
      {
         return x.CompareTo( y ) < 0;
      }

      public static Boolean operator <=( PgSQLTimeTZ x, PgSQLTimeTZ y )
      {
         return x.CompareTo( y ) <= 0;
      }

      public static Boolean operator >( PgSQLTimeTZ x, PgSQLTimeTZ y )
      {
         return !( x <= y );
      }

      public static Boolean operator >=( PgSQLTimeTZ x, PgSQLTimeTZ y )
      {
         return !( x < y );
      }

      public static PgSQLTimeTZ operator +( PgSQLTimeTZ time, PgSQLInterval interval )
      {
         return time.Add( interval );
      }

      public static PgSQLTimeTZ operator +( PgSQLInterval interval, PgSQLTimeTZ time )
      {
         return time + interval;
      }

      public static PgSQLTimeTZ operator -( PgSQLTimeTZ time, PgSQLInterval interval )
      {
         return time.Subtract( interval );
      }

      public static PgSQLInterval operator -( PgSQLTimeTZ later, PgSQLTimeTZ earlier )
      {
         return later.Subtract( earlier );
      }

      #endregion

      #region To and from string

      public Int32 GetTextByteCount( IEncodingInfo encoding )
      {
         return this._localTime.GetTextByteCount( encoding ) + this._timeZone.GetTextByteCount( encoding );
      }

      public void WriteTextBytes( IEncodingInfo encoding, Byte[] array, ref Int32 offset )
      {
         this._localTime.WriteTextBytes( encoding, array, ref offset );
         this._timeZone.WriteTextBytes( encoding, array, ref offset );
      }

      public static PgSQLTimeTZ ParseBinaryText( IEncodingInfo encoding, Byte[] array, ref Int32 offset, Int32 count )
      {
         var oldIdx = offset;
         var time = PgSQLTime.ParseBinaryText( encoding, array, ref offset, count );
         count -= offset - oldIdx;
         return new PgSQLTimeTZ(
            time,
            PgSQLTimeZone.ParseBinaryText( encoding, array, ref offset, count )
            );
      }


      public override String ToString()
      {
         return this._localTime.ToString() + this._timeZone.ToString();
      }

      public static PgSQLTimeTZ Parse( String str )
      {
         PgSQLTimeTZ result; Exception error;
         TryParse( str, out result, out error );
         if ( error != null )
         {
            throw error;
         }
         return result;
      }

      public static Boolean TryParse( String str, out PgSQLTimeTZ result )
      {
         Exception error;
         return TryParse( str, out result, out error );
      }

      internal static Boolean TryParse( String str, out PgSQLTimeTZ result, out Exception error )
      {
         if ( str == null )
         {
            result = default( PgSQLTimeTZ );
            error = new ArgumentNullException( "String" );
         }
         else
         {
            error = null;
            //Search for timezone offset + or -
            var idx = Math.Max( str.IndexOf( '+' ), str.IndexOf( '-' ) );
            if ( idx < 0 )
            {
               error = new FormatException( "Missing time zone information." );
            }

            PgSQLTime time; PgSQLTimeZone tz;
            result = error == null && PgSQLTime.TryParse( str.Substring( 0, idx ), out time, out error ) && PgSQLTimeZone.TryParse( str.Substring( idx ), out tz, out error ) ?
               new PgSQLTimeTZ( time, tz ) :
               default( PgSQLTimeTZ );
         }
         return error == null;
      }

      #endregion

   }

   //public interface IPgSQLTimestamp
   //{
   //   #region Properties

   //   Boolean IsFinite { get; }

   //   Boolean IsInfinity { get; }

   //   Boolean IsMinusInfinity { get; }

   //   PgSQLDate Date { get; }

   //   #endregion
   //}

   public struct PgSQLTimestamp : IEquatable<PgSQLTimestamp>, IComparable, IComparable<PgSQLTimestamp>//, IPgSQLDate, IPgSQLTime, IPgSQLTimestamp
   {
      #region Inner types

      internal enum TSKind : byte
      {
         Normal,
         Infinity,
         MinusInfinity,
      }

      #endregion

      #region Static

      public static readonly PgSQLTimestamp Epoch = new PgSQLTimestamp( PgSQLDate.Epoch );
      public static readonly PgSQLTimestamp Era = new PgSQLTimestamp( PgSQLDate.Era );
      public static readonly PgSQLTimestamp Infinity = new PgSQLTimestamp( TSKind.Infinity );
      public static readonly PgSQLTimestamp MinusInfinity = new PgSQLTimestamp( TSKind.MinusInfinity );

      public static PgSQLTimestamp Now
      {
         get
         {
            return new PgSQLTimestamp( PgSQLDate.Now, PgSQLTime.Now );
         }
      }

      public static PgSQLTimestamp Today
      {
         get
         {
            return new PgSQLTimestamp( PgSQLDate.Now );
         }
      }

      public static PgSQLTimestamp Yesterday
      {
         get
         {
            return new PgSQLTimestamp( PgSQLDate.Yesterday );
         }
      }

      public static PgSQLTimestamp Tomorrow
      {
         get
         {
            return new PgSQLTimestamp( PgSQLDate.Tomorrow );
         }
      }

      #endregion

      #region Fields

      private readonly PgSQLDate _date;
      private readonly PgSQLTime _time;
      private readonly TSKind _kind;

      #endregion

      #region Constructors

      private PgSQLTimestamp( TSKind kind )
      {
         if ( kind != TSKind.Infinity && kind != TSKind.MinusInfinity )
         {
            throw new InvalidOperationException( "This constructor may only be used to create infinity or minus infinity timestamps." );
         }
         this._kind = kind;
         this._date = PgSQLDate.Era;
         this._time = PgSQLTime.AllBalls;
      }

      public PgSQLTimestamp( PgSQLDate date, PgSQLTime time )
      {
         this._kind = TSKind.Normal;
         this._date = date;
         this._time = time;
      }

      public PgSQLTimestamp( PgSQLDate date )
         : this( date, PgSQLTime.AllBalls )
      {
      }

      public PgSQLTimestamp( Int32 year, Int32 month, Int32 day, Int32 hours, Int32 minutes, Int32 seconds )
         : this( new PgSQLDate( year, month, day ), new PgSQLTime( hours, minutes, seconds ) )
      {
      }

      public PgSQLTimestamp( Int32 year, Int32 month, Int32 day, Int32 hours, Int32 minutes, Decimal seconds )
         : this( new PgSQLDate( year, month, day ), new PgSQLTime( hours, minutes, seconds ) )
      {
      }

      #endregion

      #region Properties

      public Boolean IsFinite
      {
         get
         {
            return this._kind == TSKind.Normal;
         }
      }

      public Boolean IsInfinity
      {
         get
         {
            return this._kind == TSKind.Infinity;
         }
      }

      public Boolean IsMinusInfinity
      {
         get
         {
            return this._kind == TSKind.MinusInfinity;
         }
      }

      public PgSQLDate Date
      {
         get
         {
            return this._date;
         }
      }

      public PgSQLTime Time
      {
         get
         {
            return this._time;
         }
      }

      public Int32 DayOfYear
      {
         get
         {
            return this._date.DayOfYear;
         }
      }

      public Int32 Year
      {
         get
         {
            return this._date.Year;
         }
      }

      public Int32 Month
      {
         get
         {
            return this._date.Month;
         }
      }

      public Int32 Day
      {
         get
         {
            return this._date.Day;
         }
      }

      public DayOfWeek DayOfWeek
      {
         get
         {
            return this._date.DayOfWeek;
         }
      }

      public Int32 DaysSinceEra
      {
         get
         {
            return this._date.DaysSinceEra;
         }
      }

      public Boolean IsLeapYear
      {
         get
         {
            return this._date.IsLeapYear;
         }
      }

      public Int64 Ticks
      {
         get
         {
            return this._time.Ticks;
         }
      }

      public Int32 Microseconds
      {
         get
         {
            return this._time.Microseconds;
         }
      }

      public Int32 Milliseconds
      {
         get
         {
            return this._time.Milliseconds;
         }
      }

      public Int32 Seconds
      {
         get
         {
            return this._time.Seconds;
         }
      }

      public Int32 Minutes
      {
         get
         {
            return this._time.Minutes;
         }
      }

      public Int32 Hours
      {
         get
         {
            return this._time.Hours;
         }
      }

      #endregion

      #region Arithmetics

      public PgSQLTimestamp AddDays( Int32 days )
      {
         switch ( this._kind )
         {
            case TSKind.Infinity:
            case TSKind.MinusInfinity:
               return this;
            default:
               return new PgSQLTimestamp( this._date.AddDays( days ), this._time );
         }
      }

      public PgSQLTimestamp AddYears( Int32 years )
      {
         switch ( this._kind )
         {
            case TSKind.Infinity:
            case TSKind.MinusInfinity:
               return this;
            default:
               return new PgSQLTimestamp( this._date.AddYears( years ), this._time );
         }
      }

      public PgSQLTimestamp AddMonths( Int32 months )
      {
         switch ( this._kind )
         {
            case TSKind.Infinity:
            case TSKind.MinusInfinity:
               return this;
            default:
               return new PgSQLTimestamp( this._date.AddMonths( months ), this._time );
         }
      }

      public PgSQLTimestamp Add( PgSQLInterval interval )
      {
         switch ( this._kind )
         {
            case TSKind.Infinity:
            case TSKind.MinusInfinity:
               return this;
            default:
               Int32 overflow;
               var time = this._time.Add( interval, out overflow );
               return new PgSQLTimestamp( this._date.Add( interval, overflow ), time );
         }
      }

      public PgSQLTimestamp Subtract( PgSQLInterval interval )
      {
         return Add( -interval );
      }

      public PgSQLInterval Subtract( PgSQLTimestamp timestamp )
      {
         switch ( this._kind )
         {
            case TSKind.Infinity:
            case TSKind.MinusInfinity:
               throw new ArgumentOutOfRangeException( "this", "You cannot subtract infinity timestamps" );
         }
         switch ( timestamp._kind )
         {
            case TSKind.Infinity:
            case TSKind.MinusInfinity:
               throw new ArgumentOutOfRangeException( "timestamp", "You cannot subtract infinity timestamps" );
         }

         return new PgSQLInterval( 0, this._date.DaysSinceEra - timestamp._date.DaysSinceEra, this._time.Ticks - timestamp._time.Ticks );
      }

      #endregion

      #region Normalization

      public PgSQLTimestamp Normalize()
      {
         return this.Add( PgSQLInterval.Zero );
      }

      #endregion

      #region Time zone

      public PgSQLTimestampTZ AtTimeZone( PgSQLTimeZone timeZoneFrom, PgSQLTimeZone timeZoneTo )
      {
         Int32 overflow;
         var adjusted = new PgSQLTimeTZ( _time, timeZoneFrom ).AtTimeZone( timeZoneTo, out overflow );
         return new PgSQLTimestampTZ( _date.AddDays( overflow ), adjusted );
      }

      public PgSQLTimestampTZ AtTimeZone( PgSQLTimeZone timeZone )
      {
         return AtTimeZone( timeZone, PgSQLTimeZone.GetLocalTimeZone( _date ) );
      }

      #endregion

      #region Comparison

      public Boolean Equals( PgSQLTimestamp other )
      {
         switch ( this._kind )
         {
            case TSKind.Infinity:
               return other._kind == TSKind.Infinity;
            case TSKind.MinusInfinity:
               return other._kind == TSKind.MinusInfinity;
            default:
               return other._kind == TSKind.Normal && this._date.Equals( other._date ) && this._time.Equals( other._time );
         }
      }

      public override Boolean Equals( Object obj )
      {
         return obj != null && obj is PgSQLTimestamp && this.Equals( (PgSQLTimestamp) obj );
      }

      public override Int32 GetHashCode()
      {
         switch ( this._kind )
         {
            case TSKind.Infinity:
               return Int32.MaxValue;
            case TSKind.MinusInfinity:
               return Int32.MinValue;
            default:
               // Like in point
               unchecked
               {
                  return ( 17 * 23 + this._date.GetHashCode() ) * 23 + this._time.GetHashCode();
               }
         }
      }

      Int32 IComparable.CompareTo( Object obj )
      {
         if ( obj == null )
         {
            // This is always 'greater' than null
            return 1;
         }
         else if ( obj is PgSQLTimestamp )
         {
            return this.CompareTo( (PgSQLTimestamp) obj );
         }
         else
         {
            throw new ArgumentException( "Given object must be of type " + this.GetType() + " or null." );
         }
      }

      public Int32 CompareTo( PgSQLTimestamp other )
      {
         switch ( this._kind )
         {
            case TSKind.Infinity:
               return other._kind == TSKind.Infinity ? 0 : 1;
            case TSKind.MinusInfinity:
               return other._kind == TSKind.MinusInfinity ? 0 : -1;
            default:
               var dateCompare = this._date.CompareTo( other._date );
               return dateCompare == 0 ? this._time.CompareTo( other._time ) : dateCompare;
         }
      }

      #endregion

      #region Casts and conversions

      public static explicit operator PgSQLTimestamp( DateTime x )
      {
         return x == DateTime.MaxValue ?
            Infinity : ( x == DateTime.MinValue ? MinusInfinity :
            new PgSQLTimestamp( new PgSQLDate( x ), new PgSQLTime( x.TimeOfDay ) ) );
      }

      public static explicit operator DateTime( PgSQLTimestamp x )
      {
         return x.ToDateTime( DateTimeKind.Unspecified );
      }

      public DateTime ToDateTime( DateTimeKind dtKind )
      {
         switch ( this._kind )
         {
            case TSKind.Infinity:
               return DateTime.MaxValue;
            case TSKind.MinusInfinity:
               return DateTime.MinValue;
            default:
               try
               {
                  return new DateTime( this._date.DaysSinceEra * TimeSpan.TicksPerDay + this._time.Ticks, dtKind );
               }
               catch ( Exception exc )
               {
                  throw new InvalidCastException( "", exc );
               }
         }
      }

      #endregion

      #region Operators

      public static Boolean operator ==( PgSQLTimestamp x, PgSQLTimestamp y )
      {
         return x.Equals( y );
      }

      public static Boolean operator !=( PgSQLTimestamp x, PgSQLTimestamp y )
      {
         return !( x == y );
      }

      public static Boolean operator <( PgSQLTimestamp x, PgSQLTimestamp y )
      {
         return x.CompareTo( y ) < 0;
      }

      public static Boolean operator <=( PgSQLTimestamp x, PgSQLTimestamp y )
      {
         return x.CompareTo( y ) <= 0;
      }

      public static Boolean operator >( PgSQLTimestamp x, PgSQLTimestamp y )
      {
         return !( x <= y );
      }

      public static Boolean operator >=( PgSQLTimestamp x, PgSQLTimestamp y )
      {
         return !( x < y );
      }

      public static PgSQLTimestamp operator +( PgSQLTimestamp timestamp, PgSQLInterval interval )
      {
         return timestamp.Add( interval );
      }

      public static PgSQLTimestamp operator +( PgSQLInterval interval, PgSQLTimestamp timestamp )
      {
         return timestamp.Add( interval );
      }

      public static PgSQLTimestamp operator -( PgSQLTimestamp timestamp, PgSQLInterval interval )
      {
         return timestamp.Subtract( interval );
      }

      public static PgSQLInterval operator -( PgSQLTimestamp x, PgSQLTimestamp y )
      {
         return x.Subtract( y );
      }

      #endregion

      #region To and from string

      private const Byte SEPARATOR = (Byte) ' ';

      public Int32 GetTextByteCount( IEncodingInfo encoding )
      {
         switch ( this._kind )
         {
            case TSKind.Infinity:
               return encoding.Encoding.GetByteCount( PgSQLDate.INFINITY );
            case TSKind.MinusInfinity:
               return encoding.Encoding.GetByteCount( PgSQLDate.MINUS_INFINITY );
            default:
               return encoding.BytesPerASCIICharacter + this._date.GetTextByteCount( encoding ) + this._time.GetTextByteCount( encoding );
         }
      }

      public void WriteTextBytes( IEncodingInfo encoding, Byte[] array, ref Int32 offset )
      {
         switch ( this._kind )
         {
            case TSKind.Infinity:
               encoding.Encoding.GetBytes( PgSQLDate.INFINITY, 0, PgSQLDate.INFINITY.Length, array, offset );
               break;
            case TSKind.MinusInfinity:
               encoding.Encoding.GetBytes( PgSQLDate.MINUS_INFINITY, 0, PgSQLDate.MINUS_INFINITY.Length, array, offset );
               break;
            default:
               this._date.WriteTextBytes( encoding, array, ref offset );
               encoding.WriteASCIIByte( array, ref offset, SEPARATOR ); // ' '
               this._time.WriteTextBytes( encoding, array, ref offset );
               break;
         }
      }

      public static PgSQLTimestamp ParseBinaryText( IEncodingInfo encoding, Byte[] array, ref Int32 offset, Int32 count )
      {
         switch ( count )
         {
            case PgSQLDate.INFINITY_CHAR_COUNT:
               return Infinity;
            case PgSQLDate.MINUS_INFINITY_CHAR_COUNT:
               return MinusInfinity;
            default:
               var oldIdx = offset;
               var date = PgSQLDate.ParseBinaryText( encoding, array, ref offset, count );
               encoding.EqualsOrThrow( array, ref offset, SEPARATOR );
               count -= offset - oldIdx;
               return new PgSQLTimestamp(
                  date,
                  PgSQLTime.ParseBinaryText( encoding, array, ref offset, count )
                  );
         }
      }

      public override String ToString()
      {
         switch ( this._kind )
         {
            case TSKind.Infinity:
               return PgSQLDate.INFINITY;
            case TSKind.MinusInfinity:
               return PgSQLDate.MINUS_INFINITY;
            default:
               return this._date.ToString() + " " + this._time.ToString();
         }
      }

      public static PgSQLTimestamp Parse( String str )
      {
         PgSQLTimestamp result; Exception error;
         TryParse( str, out result, out error );
         if ( error != null )
         {
            throw error;
         }
         return result;
      }

      public static Boolean TryParse( String str, out PgSQLTimestamp result )
      {
         Exception error;
         return TryParse( str, out result, out error );
      }

      private static Boolean TryParse( String str, out PgSQLTimestamp result, out Exception error )
      {
         if ( str == null )
         {
            result = default( PgSQLTimestamp );
            error = new ArgumentNullException( "String" );
         }
         else
         {
            str = str.Trim();
            error = null;
            if ( String.Equals( str, PgSQLDate.INFINITY, StringComparison.OrdinalIgnoreCase ) )
            {
               result = Infinity;
            }
            else if ( String.Equals( str, PgSQLDate.MINUS_INFINITY, StringComparison.OrdinalIgnoreCase ) )
            {
               result = MinusInfinity;
            }
            else
            {
               var idx = str.LastIndexOf( ' ' );
               if ( idx == -1 )
               {
                  error = new FormatException( "Failed to distinguish date and time in timestamp." );
               }

               PgSQLDate date; PgSQLTime time;
               result = error == null && PgSQLDate.TryParse( str.Substring( 0, idx ), out date, out error ) && PgSQLTime.TryParse( str.Substring( idx + 1 ), out time, out error ) ?
                  new PgSQLTimestamp( date, time ) :
                  default( PgSQLTimestamp );
            }
         }
         return error == null;
      }

      #endregion

   }

   public struct PgSQLTimestampTZ : IEquatable<PgSQLTimestampTZ>, IComparable, IComparable<PgSQLTimestampTZ>//, IPgSQLDate, IPgSQLTimeTZ, IPgSQLTimestamp
   {
      #region Static

      public static readonly PgSQLTimestampTZ Epoch = new PgSQLTimestampTZ( PgSQLDate.Epoch, PgSQLTimeTZ.AllBalls );

      public static readonly PgSQLTimestampTZ Era = new PgSQLTimestampTZ( PgSQLDate.Era, PgSQLTimeTZ.AllBalls );

      public static readonly PgSQLTimestampTZ MinusInfinity = new PgSQLTimestampTZ( PgSQLTimestamp.TSKind.MinusInfinity );

      public static readonly PgSQLTimestampTZ Infinity = new PgSQLTimestampTZ( PgSQLTimestamp.TSKind.Infinity );

      public static PgSQLTimestampTZ Now
      {
         get
         {
            return new PgSQLTimestampTZ( PgSQLDate.Now, PgSQLTimeTZ.Now );
         }
      }

      public static PgSQLTimestampTZ Today
      {
         get
         {
            return new PgSQLTimestampTZ( PgSQLDate.Now );
         }
      }

      public static PgSQLTimestampTZ Yesterday
      {
         get
         {
            return new PgSQLTimestampTZ( PgSQLDate.Yesterday );
         }
      }

      public static PgSQLTimestampTZ Tomorrow
      {
         get
         {
            return new PgSQLTimestampTZ( PgSQLDate.Tomorrow );
         }
      }

      #endregion

      #region Fields

      private readonly PgSQLDate _date;
      private readonly PgSQLTimeTZ _time;
      private readonly PgSQLTimestamp.TSKind _kind;

      #endregion

      #region Constructors

      private PgSQLTimestampTZ( PgSQLTimestamp.TSKind kind )
      {
         if ( kind != PgSQLTimestamp.TSKind.Infinity && kind != PgSQLTimestamp.TSKind.MinusInfinity )
         {
            throw new InvalidOperationException( "This constructor may only be used to create infinity or minus infinity timestamps." );
         }
         this._kind = kind;
         this._date = PgSQLDate.Era;
         this._time = PgSQLTimeTZ.AllBalls;
      }

      public PgSQLTimestampTZ( PgSQLDate date, PgSQLTimeTZ time )
      {
         this._kind = PgSQLTimestamp.TSKind.Normal;
         this._date = date;
         this._time = time;
      }

      public PgSQLTimestampTZ( PgSQLDate date )
         : this( date, PgSQLTimeTZ.AllBalls )
      {
      }

      public PgSQLTimestampTZ( Int32 year, Int32 month, Int32 day, Int32 hours, Int32 minutes, Int32 seconds, PgSQLTimeZone? timeZone = null )
         : this( new PgSQLDate( year, month, day ), new PgSQLTimeTZ( hours, minutes, seconds, timeZone.HasValue ? timeZone.Value : PgSQLTimeZone.GetLocalTimeZone( new PgSQLDate( year, month, day ) ) ) )
      {
      }

      public PgSQLTimestampTZ( Int32 year, Int32 month, Int32 day, Int32 hours, Int32 minutes, Decimal seconds, PgSQLTimeZone? timeZone = null )
         : this( new PgSQLDate( year, month, day ), new PgSQLTimeTZ( hours, minutes, seconds, timeZone.HasValue ? timeZone.Value : PgSQLTimeZone.GetLocalTimeZone( new PgSQLDate( year, month, day ) ) ) )
      {
      }

      #endregion

      #region Properties

      public Int32 DayOfYear
      {
         get
         {
            return this._date.DayOfYear;
         }
      }

      public Int32 Year
      {
         get
         {
            return this._date.Year;
         }
      }

      public Int32 Month
      {
         get
         {
            return this._date.Month;
         }
      }

      public Int32 Day
      {
         get
         {
            return this._date.Day;
         }
      }

      public DayOfWeek DayOfWeek
      {
         get
         {
            return this._date.DayOfWeek;
         }
      }

      public Int32 DaysSinceEra
      {
         get
         {
            return this._date.DaysSinceEra;
         }
      }

      public Boolean IsLeapYear
      {
         get
         {
            return this._date.IsLeapYear;
         }
      }

      public PgSQLTime LocalTime
      {
         get
         {
            return this._time.LocalTime;
         }
      }

      public PgSQLTimeZone TimeZone
      {
         get
         {
            return this._time.TimeZone;
         }
      }

      public PgSQLTime UTCTime
      {
         get
         {
            return this._time.UTCTime;
         }
      }

      public Int64 Ticks
      {
         get
         {
            return this._time.Ticks;
         }
      }

      public Int32 Microseconds
      {
         get
         {
            return this._time.Microseconds;
         }
      }

      public Int32 Milliseconds
      {
         get
         {
            return this._time.Milliseconds;
         }
      }

      public Int32 Seconds
      {
         get
         {
            return this._time.Seconds;
         }
      }

      public Int32 Minutes
      {
         get
         {
            return this._time.Minutes;
         }
      }

      public Int32 Hours
      {
         get
         {
            return this._time.Hours;
         }
      }

      public Boolean IsFinite
      {
         get
         {
            return this._kind == PgSQLTimestamp.TSKind.Normal;
         }
      }

      public Boolean IsInfinity
      {
         get
         {
            return this._kind == PgSQLTimestamp.TSKind.Infinity;
         }
      }

      public Boolean IsMinusInfinity
      {
         get
         {
            return this._kind == PgSQLTimestamp.TSKind.MinusInfinity;
         }
      }

      public PgSQLDate Date
      {
         get
         {
            return this._date;
         }
      }

      public PgSQLTimeTZ Time
      {
         get
         {
            return this._time;
         }
      }

      #endregion

      #region Comparison

      public Boolean Equals( PgSQLTimestampTZ other )
      {
         switch ( this._kind )
         {
            case PgSQLTimestamp.TSKind.Infinity:
               return other._kind == PgSQLTimestamp.TSKind.Infinity;
            case PgSQLTimestamp.TSKind.MinusInfinity:
               return other._kind == PgSQLTimestamp.TSKind.MinusInfinity;
            default:
               return other._kind == PgSQLTimestamp.TSKind.Normal && this._date.Equals( other._date ) && this._time.Equals( other._time );
         }
      }

      public override Boolean Equals( Object obj )
      {
         return obj != null && obj is PgSQLTimestampTZ && this.Equals( (PgSQLTimestampTZ) obj );
      }

      public override Int32 GetHashCode()
      {
         switch ( this._kind )
         {
            case PgSQLTimestamp.TSKind.Infinity:
               return Int32.MaxValue;
            case PgSQLTimestamp.TSKind.MinusInfinity:
               return Int32.MinValue;
            default:
               // Like in point
               unchecked
               {
                  return ( 17 * 23 + this._date.GetHashCode() ) * 23 + this._time.GetHashCode();
               }
         }
      }

      Int32 IComparable.CompareTo( Object obj )
      {
         if ( obj == null )
         {
            // This is always 'greater' than null
            return 1;
         }
         else if ( obj is PgSQLTimestampTZ )
         {
            return this.CompareTo( (PgSQLTimestampTZ) obj );
         }
         else
         {
            throw new ArgumentException( "Given object must be of type " + this.GetType() + " or null." );
         }
      }

      public Int32 CompareTo( PgSQLTimestampTZ other )
      {
         switch ( this._kind )
         {
            case PgSQLTimestamp.TSKind.Infinity:
               return other._kind == PgSQLTimestamp.TSKind.Infinity ? 0 : 1;
            case PgSQLTimestamp.TSKind.MinusInfinity:
               return other._kind == PgSQLTimestamp.TSKind.MinusInfinity ? 0 : -1;
            default:
               var dateCompare = this._date.CompareTo( other._date );
               return dateCompare == 0 ? this._time.CompareTo( other._time ) : dateCompare;
         }
      }

      #endregion

      #region Arithmetics

      public PgSQLTimestampTZ AddDays( Int32 days )
      {
         switch ( this._kind )
         {
            case PgSQLTimestamp.TSKind.Infinity:
            case PgSQLTimestamp.TSKind.MinusInfinity:
               return this;
            default:
               return new PgSQLTimestampTZ( this._date.AddDays( days ), this._time );
         }
      }

      public PgSQLTimestampTZ AddYears( Int32 years )
      {
         switch ( this._kind )
         {
            case PgSQLTimestamp.TSKind.Infinity:
            case PgSQLTimestamp.TSKind.MinusInfinity:
               return this;
            default:
               return new PgSQLTimestampTZ( this._date.AddYears( years ), this._time );
         }
      }

      public PgSQLTimestampTZ AddMonths( Int32 months )
      {
         switch ( this._kind )
         {
            case PgSQLTimestamp.TSKind.Infinity:
            case PgSQLTimestamp.TSKind.MinusInfinity:
               return this;
            default:
               return new PgSQLTimestampTZ( this._date.AddMonths( months ), this._time );
         }
      }

      public PgSQLTimestampTZ Add( PgSQLInterval interval )
      {
         switch ( this._kind )
         {
            case PgSQLTimestamp.TSKind.Infinity:
            case PgSQLTimestamp.TSKind.MinusInfinity:
               return this;
            default:
               int overflow;
               var time = this._time.Add( interval, out overflow );
               return new PgSQLTimestampTZ( this._date.Add( interval, overflow ), time );
         }
      }

      public PgSQLTimestampTZ Subtract( PgSQLInterval interval )
      {
         return Add( -interval );
      }

      public PgSQLInterval Subtract( PgSQLTimestampTZ timestamp )
      {
         switch ( this._kind )
         {
            case PgSQLTimestamp.TSKind.Infinity:
            case PgSQLTimestamp.TSKind.MinusInfinity:
               throw new ArgumentOutOfRangeException( "this", "You cannot subtract infinity timestamps" );
         }
         switch ( timestamp._kind )
         {
            case PgSQLTimestamp.TSKind.Infinity:
            case PgSQLTimestamp.TSKind.MinusInfinity:
               throw new ArgumentOutOfRangeException( "timestamp", "You cannot subtract infinity timestamps" );
         }
         return new PgSQLInterval( 0, this._date.DaysSinceEra - timestamp._date.DaysSinceEra, ( this._time - timestamp._time ).Ticks );
      }

      #endregion

      #region Normalization

      public PgSQLTimestampTZ Normalize()
      {
         return this.Add( PgSQLInterval.Zero );
      }

      #endregion

      #region Time zone

      public PgSQLTimestamp AtTimeZone( PgSQLTimeZone timeZone )
      {
         Int32 overflow;
         var adjusted = this._time.AtTimeZone( timeZone, out overflow );
         return new PgSQLTimestamp( _date.AddDays( overflow ), adjusted.LocalTime );
      }

      #endregion

      #region Casts

      public static explicit operator PgSQLTimestampTZ( DateTime x )
      {
         return x == DateTime.MaxValue ?
            Infinity : ( x == DateTime.MinValue ? MinusInfinity :
            new PgSQLTimestampTZ( new PgSQLDate( x ), new PgSQLTimeTZ( x.TimeOfDay, x.Kind == DateTimeKind.Utc ? PgSQLTimeZone.UTC : PgSQLTimeZone.GetLocalTimeZone( new PgSQLDate( x ) ) ) ) );
      }

      public static explicit operator DateTime( PgSQLTimestampTZ x )
      {
         switch ( x._kind )
         {
            case PgSQLTimestamp.TSKind.Infinity:
               return DateTime.MaxValue;
            case PgSQLTimestamp.TSKind.MinusInfinity:
               return DateTime.MinValue;
            default:
               var utc = x.AtTimeZone( PgSQLTimeZone.UTC );
               try
               {
                  return new DateTime( utc.Date.DaysSinceEra * TimeSpan.TicksPerDay + utc.Time.Ticks, DateTimeKind.Utc );
               }
               catch ( Exception exc )
               {
                  throw new InvalidCastException( "", exc );
               }

         }
      }

      public static explicit operator PgSQLTimestampTZ( DateTimeOffset x )
      {
         return x == DateTimeOffset.MaxValue ?
            Infinity : ( x == DateTimeOffset.MinValue ? MinusInfinity :
            new PgSQLTimestampTZ( new PgSQLDate( x.Year, x.Month, x.Day ), new PgSQLTimeTZ( x.TimeOfDay, new PgSQLTimeZone( x.Offset ) ) ) );
      }

      public static explicit operator DateTimeOffset( PgSQLTimestampTZ x )
      {
         switch ( x._kind )
         {
            case PgSQLTimestamp.TSKind.Infinity:
               return DateTimeOffset.MaxValue;
            case PgSQLTimestamp.TSKind.MinusInfinity:
               return DateTimeOffset.MinValue;
            default:
               try
               {
                  return new DateTimeOffset( x._date.DaysSinceEra * TimeSpan.TicksPerDay + x._time.Ticks, x.TimeZone );
               }
               catch ( Exception exc )
               {
                  throw new InvalidCastException( "", exc );
               }

         }
      }

      #endregion

      #region Operators

      public static Boolean operator ==( PgSQLTimestampTZ x, PgSQLTimestampTZ y )
      {
         return x.Equals( y );
      }

      public static Boolean operator !=( PgSQLTimestampTZ x, PgSQLTimestampTZ y )
      {
         return !( x == y );
      }

      public static Boolean operator <( PgSQLTimestampTZ x, PgSQLTimestampTZ y )
      {
         return x.CompareTo( y ) < 0;
      }

      public static Boolean operator <=( PgSQLTimestampTZ x, PgSQLTimestampTZ y )
      {
         return x.CompareTo( y ) <= 0;
      }

      public static Boolean operator >( PgSQLTimestampTZ x, PgSQLTimestampTZ y )
      {
         return !( x <= y );
      }

      public static Boolean operator >=( PgSQLTimestampTZ x, PgSQLTimestampTZ y )
      {
         return !( x < y );
      }

      public static PgSQLTimestampTZ operator +( PgSQLTimestampTZ timestamp, PgSQLInterval interval )
      {
         return timestamp.Add( interval );
      }

      public static PgSQLTimestampTZ operator +( PgSQLInterval interval, PgSQLTimestampTZ timestamp )
      {
         return timestamp.Add( interval );
      }

      public static PgSQLTimestampTZ operator -( PgSQLTimestampTZ timestamp, PgSQLInterval interval )
      {
         return timestamp.Subtract( interval );
      }

      public static PgSQLInterval operator -( PgSQLTimestampTZ x, PgSQLTimestampTZ y )
      {
         return x.Subtract( y );
      }

      #endregion

      #region To and from string

      public Int32 GetTextByteCount( IEncodingInfo encoding )
      {
         switch ( this._kind )
         {
            case PgSQLTimestamp.TSKind.Infinity:
               return encoding.Encoding.GetByteCount( PgSQLDate.INFINITY );
            case PgSQLTimestamp.TSKind.MinusInfinity:
               return encoding.Encoding.GetByteCount( PgSQLDate.MINUS_INFINITY );
            default:
               return encoding.BytesPerASCIICharacter + this._date.GetTextByteCount( encoding ) + this._time.GetTextByteCount( encoding );
         }
      }

      public void WriteTextBytes( IEncodingInfo encoding, Byte[] array, ref Int32 offset )
      {
         switch ( this._kind )
         {
            case PgSQLTimestamp.TSKind.Infinity:
               encoding.Encoding.GetBytes( PgSQLDate.INFINITY, 0, PgSQLDate.INFINITY.Length, array, offset );
               break;
            case PgSQLTimestamp.TSKind.MinusInfinity:
               encoding.Encoding.GetBytes( PgSQLDate.MINUS_INFINITY, 0, PgSQLDate.MINUS_INFINITY.Length, array, offset );
               break;
            default:
               this._date.WriteTextBytes( encoding, array, ref offset );
               encoding.WriteASCIIByte( array, ref offset, 0x020 ); // ' '
               this._time.WriteTextBytes( encoding, array, ref offset );
               break;
         }
      }

      public static PgSQLTimestampTZ ParseBinaryText( IEncodingInfo encoding, Byte[] array, ref Int32 offset, Int32 count )
      {
         var oldIdx = offset;
         var ts = PgSQLTimestamp.ParseBinaryText( encoding, array, ref offset, count );
         if ( ts.IsInfinity )
         {
            return Infinity;
         }
         else if ( ts.IsMinusInfinity )
         {
            return MinusInfinity;
         }
         else
         {
            count -= offset - oldIdx;
            if ( count <= 0 )
            {
               throw new FormatException( "No room for time zone information" );
            }
            return new PgSQLTimestampTZ( ts.Date, new PgSQLTimeTZ( ts.Time, PgSQLTimeZone.ParseBinaryText( encoding, array, ref offset, count ) ) );
         }
      }

      public override String ToString()
      {
         switch ( this._kind )
         {
            case PgSQLTimestamp.TSKind.Infinity:
               return PgSQLDate.INFINITY;
            case PgSQLTimestamp.TSKind.MinusInfinity:
               return PgSQLDate.MINUS_INFINITY;
            default:
               return this._date.ToString() + " " + this._time.ToString();
         }
      }

      public static PgSQLTimestampTZ Parse( String str )
      {
         TryParse( str, out PgSQLTimestampTZ result, out Exception error );
         if ( error != null )
         {
            throw error;
         }
         return result;
      }

      public static Boolean TryParse( String str, out PgSQLTimestampTZ result )
      {
         Exception error;
         return TryParse( str, out result, out error );
      }

      private static Boolean TryParse( String str, out PgSQLTimestampTZ result, out Exception error )
      {
         if ( str == null )
         {
            result = default( PgSQLTimestampTZ );
            error = new ArgumentNullException( "String" );
         }
         else
         {
            str = str.Trim();
            error = null;
            if ( String.Equals( str, PgSQLDate.INFINITY, StringComparison.OrdinalIgnoreCase ) )
            {
               result = Infinity;
            }
            else if ( String.Equals( str, PgSQLDate.MINUS_INFINITY, StringComparison.OrdinalIgnoreCase ) )
            {
               result = MinusInfinity;
            }
            else
            {
               var idx = str.LastIndexOf( ' ' );
               if ( idx == -1 )
               {
                  error = new FormatException( "Failed to distinguish date and time in timestamp." );
               }

               PgSQLDate date; PgSQLTimeTZ time;
               result = error == null && PgSQLDate.TryParse( str.Substring( 0, idx ), out date, out error ) && PgSQLTimeTZ.TryParse( str.Substring( idx + 1 ), out time, out error ) ?
                  new PgSQLTimestampTZ( date, time ) :
                  default( PgSQLTimestampTZ );
            }
         }
         return error == null;
      }

      #endregion

   }


}

#pragma warning restore 1591

public static partial class E_CBAM
{


   internal static IEncodingInfo EqualsOrThrow( this IEncodingInfo encoding, Byte[] array, ref Int32 offset, Byte b )
   {
      if ( array[offset] != b )
      {
         throw new FormatException( "Missing required " + (Char) b + "." );
      }
      offset += encoding.BytesPerASCIICharacter;
      return encoding;
   }

   internal static Boolean TryParseOptionalNumber(
      this IEncodingInfo encoding,
      Byte[] array,
      ref Int32 offset,
      Byte prefix,
      (Int32 CharCount, Boolean CharCountExactMatch) charCount,
      Int32 maxOffset, // Exclusive
      out Int32 parsedNumber
      )
   {
      var oldIdx = offset;
      var retVal = offset < maxOffset && encoding.ReadASCIIByte( array, ref offset ) == prefix;
      if ( retVal )
      {
         parsedNumber = encoding.ParseInt32Textual( array, ref offset, charCount );
      }
      else
      {
         // 'Reverse back'
         offset = oldIdx;
         parsedNumber = 0;
      }

      return retVal;
   }

}