PostgreSql: Apply connection timezone to datetimeoffset values on reading

Author: alex-kulakov

Orm/Xtensive.Orm.PostgreSql/Sql.Drivers.PostgreSql/DriverFactory.cs

@@ -13,6 +13,7 @@
 using Xtensive.Orm;
 using Xtensive.Sql.Info;
 using Xtensive.Sql.Drivers.PostgreSql.Resources;
+using System.Collections.Generic;
 
 namespace Xtensive.Sql.Drivers.PostgreSql
 {
@@ -66,8 +67,9 @@ protected override SqlDriver CreateDriver(string connectionString, SqlDriverConf
       else
         OpenConnectionFast(connection, configuration, false).GetAwaiter().GetResult();
       var version = GetVersion(configuration, connection);
+      var serverTimezones = GetServerTimeZones(connection, false).GetAwaiter().GetResult();
       var defaultSchema = GetDefaultSchema(connection);
-      return CreateDriverInstance(connectionString, version, defaultSchema);
+      return CreateDriverInstance(connectionString, version, defaultSchema, serverTimezones, connection.Timezone);
     }
 
     /// <inheritdoc/>
@@ -85,8 +87,9 @@ protected override async Task<SqlDriver> CreateDriverAsync(
         else
           await OpenConnectionFast(connection, configuration, true, token).ConfigureAwait(false);
         var version = GetVersion(configuration, connection);
+        var serverTimezones = await GetServerTimeZones(connection, true, token).ConfigureAwait(false);
         var defaultSchema = await GetDefaultSchemaAsync(connection, token: token).ConfigureAwait(false);
-        return CreateDriverInstance(connectionString, version, defaultSchema);
+        return CreateDriverInstance(connectionString, version, defaultSchema, serverTimezones, connection.Timezone);
       }
     }
 
@@ -99,7 +102,8 @@ private static Version GetVersion(SqlDriverConfiguration configuration, NpgsqlCo
     }
 
     private static SqlDriver CreateDriverInstance(
-      string connectionString, Version version, DefaultSchemaInfo defaultSchema)
+      string connectionString, Version version, DefaultSchemaInfo defaultSchema,
+      Dictionary<string, TimeSpan> timezones, string defaultTimeZone)
     {
       var coreServerInfo = new CoreServerInfo {
         ServerVersion = version,
@@ -111,7 +115,9 @@ private static SqlDriver CreateDriverInstance(
 
       var pgsqlServerInfo = new PostgreServerInfo() {
         InfinityAliasForDatesEnabled = InfinityAliasForDatesEnabled,
-        LegacyTimestampBehavior = LegacyTimestamptBehaviorEnabled
+        LegacyTimestampBehavior = LegacyTimestamptBehaviorEnabled,
+        ServerTimeZones = timezones,
+        DefaultTimeZone = defaultTimeZone
       };
 
       if (version.Major < 8 || (version.Major == 8 && version.Minor < 3)) {
@@ -198,6 +204,45 @@ await SqlHelper.NotifyConnectionInitializingAsync(accessors,
       }
     }
 
+    private static async ValueTask<Dictionary<string, TimeSpan>> GetServerTimeZones(NpgsqlConnection connection, bool isAsync, CancellationToken token = default)
+    {
+      var resultZones = new Dictionary<string, TimeSpan>();
+
+      var command = connection.CreateCommand();
+      command.CommandText = "SELECT \"name\", \"abbrev\", \"utc_offset\", \"is_dst\" FROM pg_timezone_names";
+      if (isAsync) {
+        await using(command)
+        await using(var reader = await command.ExecuteReaderAsync()) {
+          while(await reader.ReadAsync()) {
+            ReadTimezoneRow(reader, resultZones);
+          }
+        }
+      }
+      else {
+        using (command)
+        using (var reader = command.ExecuteReader()) {
+          while (reader.Read()) {
+            ReadTimezoneRow(reader, resultZones);
+          }
+        }
+      }
+      return resultZones;
+
+
+      static void ReadTimezoneRow(NpgsqlDataReader reader, Dictionary<string, TimeSpan> zones)
+      {
+        var name = reader.GetString(0);
+        var abbrev = reader.GetString(1);
+        var utcOffset = PostgreSqlHelper.ResurrectTimeSpanFromNpgsqlInterval(reader.GetFieldValue<NpgsqlTypes.NpgsqlInterval>(2));
+
+        _ = zones.TryAdd(name, utcOffset);
+        //flatten results for search convinience
+        if (!string.IsNullOrEmpty(abbrev)) {
+          _ = zones.TryAdd(abbrev, utcOffset);
+        }
+      }
+    }
+
     private static bool SetOrGetExistingDisableInfinityAliasForDatesSwitch(bool valueToSet) =>
       GetSwitchValueOrSet(Orm.PostgreSql.WellKnown.DateTimeToInfinityConversionSwitchName, valueToSet);
 

Orm/Xtensive.Orm.PostgreSql/Sql.Drivers.PostgreSql/PostgreServerInfo.cs

@@ -2,6 +2,9 @@
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 
+using System;
+using System.Collections.Generic;
+
 namespace Xtensive.Sql.Drivers.PostgreSql
 {
   /// <summary>
@@ -22,5 +25,15 @@ internal sealed class PostgreServerInfo
     /// The setting has effect on parameter binding and also value reading from DbDataReader.
     /// </summary>
     public bool LegacyTimestampBehavior { get; init; }
+
+    /// <summary>
+    /// Contains server timezone names and their base Utc offset (including abbreviations).
+    /// </summary>
+    public IReadOnlyDictionary<string, TimeSpan> ServerTimeZones { get; init; }
+
+    /// <summary>
+    /// Gets time zone of connection after connection initialization script was executed.
+    /// </summary>
+    public string DefaultTimeZone { get; init; }
   }
 }

Orm/Xtensive.Orm.PostgreSql/Sql.Drivers.PostgreSql/PostgreSqlHelper.cs

@@ -0,0 +1,71 @@
+// Copyright (C) 2025 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using Npgsql;
+using NpgsqlTypes;
+using Xtensive.Orm.PostgreSql;
+
+namespace Xtensive.Sql.Drivers.PostgreSql
+{
+  internal static class PostgreSqlHelper
+  {
+    internal static NpgsqlInterval CreateNativeIntervalFromTimeSpan(in TimeSpan timeSpan)
+    {
+      // Previous Npgsql versions used days and time, no months.
+      // Thought we can write everything as time, we keep days and time format
+
+      var ticks = timeSpan.Ticks;
+
+      var days = timeSpan.Days;
+      var timeTicks = ticks - (days * TimeSpan.TicksPerDay);
+#if NET7_0_OR_GREATER
+      var microseconds = timeTicks / TimeSpan.TicksPerMicrosecond;
+#else
+      var microseconds = timeTicks / 10L; // same as TimeSpan.TicksPerMicrosecond available in .NET7+
+#endif
+      // no months!
+      return new NpgsqlInterval(0, days, microseconds);
+    }
+
+    internal static TimeSpan ResurrectTimeSpanFromNpgsqlInterval(in NpgsqlInterval npgsqlInterval)
+    {
+      // We don't write "Months" part of NpgsqlInterval to database
+      // because days in months is variable measure in PostgreSQL.
+      // We better use exact number of days.
+      // But if for some reason, there is Months value > 0 we treat it like each month has 30 days,
+      // it seems that Npgsql did the same assumption internally.
+
+      var days = (npgsqlInterval.Months != 0)
+        ? npgsqlInterval.Months * WellKnown.IntervalDaysInMonth + npgsqlInterval.Days
+        : npgsqlInterval.Days;
+
+      var ticksOfDays = days * TimeSpan.TicksPerDay;
+#if NET7_0_OR_GREATER
+      var overallTicks = ticksOfDays + (npgsqlInterval.Time * TimeSpan.TicksPerMicrosecond);
+#else
+      var overallTicks = ticksOfDays + (npgsqlInterval.Time * 10); //same as TimeSpan.TicksPerMicrosecond available in .NET7+
+#endif
+      return TimeSpan.FromTicks(overallTicks);
+    }
+
+    /// <summary>
+    /// Checks if timezone is declared in POSIX format (example  &lt;+07&gt;-07 )
+    /// and returns number between '&lt;' and '&gt;' as timezone.
+    /// </summary>
+    /// <param name="timezone">Timezone in possible POSIX format</param>
+    /// <returns>Timezone shift declared in oritinal POSIX format as timezone or original value.</returns>
+    internal static string TryGetZoneFromPosix(string timezone)
+    {
+      if (timezone.StartsWith('<')) {
+        // if POSIX format 
+        var closing = timezone.IndexOf('>');
+        var result =  timezone.Substring(1, closing - 1);
+        return result;
+      }
+      return timezone;
+    }
+  }
+}

Orm/Xtensive.Orm.PostgreSql/Sql.Drivers.PostgreSql/v8_0/TypeMapper.cs

@@ -5,6 +5,7 @@
 // Created:    2009.06.23
 
 using System;
+using System.Collections.Generic;
 using System.Data;
 using System.Data.Common;
 using System.Security;
@@ -22,6 +23,7 @@ internal class TypeMapper : Sql.TypeMapper
     private const long DateTimeMaxValueAdjustedTicks = 3155378975999999990; 
 
     protected readonly bool legacyTimestampBehaviorEnabled;
+    protected readonly TimeSpan? defaultTimeZone;
 
     public override bool IsParameterCastRequired(Type type)
     {
@@ -122,7 +124,7 @@ public override void BindTimeSpan(DbParameter parameter, object value)
       nativeParameter.NpgsqlValue = value is null
         ? DBNull.Value
         : value is TimeSpan timeSpanValue
-          ? (object) CreateNativeIntervalFromTimeSpan(timeSpanValue)
+          ? (object) PostgreSqlHelper.CreateNativeIntervalFromTimeSpan(timeSpanValue)
           : throw ValueNotOfTypeError(nameof(WellKnownTypes.TimeSpanType));
     }
 
@@ -229,7 +231,7 @@ public override object ReadTimeSpan(DbDataReader reader, int index)
 
       // support for full-range of Timespans required us to use raw type
       // and construct timespan from its' values.
-      return ResurrectTimeSpanFromNpgsqlInterval(nativeInterval);
+      return PostgreSqlHelper.ResurrectTimeSpanFromNpgsqlInterval(nativeInterval);
     }
 
     [SecuritySafeCritical]
@@ -272,59 +274,19 @@ public override object ReadDateTimeOffset(DbDataReader reader, int index)
         return value;
       }
       else {
-        // Probably the "mastermind" who made parameter conversion before setting value to parameter be required
-        // also forgot about PostgreSQL's built-in "SET TIME ZONE" feature for session, which affects values of TimeStampTz
-        // Now applications have to use either local/utc timezone everywhere OR somehow "remember" what they've set in SET TIME ZONE
-        // for being able to get values in the timezone they've set. (facapalm)
-        //
-        // BTW, Npgsql has no API that would provide us current connection timezone so we could apply it to values,
-        // there is internal setting in NpgsqlConnection but it is null no matter what is set by
-        // 'SET TIME ZONE' statement :-)
-        //
-        // We'll use local time, that's it! SET TIME ZONE will not work!
-        return value.ToLocalTime();
+        // Here we try to apply connection timezone.
+        // To not get it from internal connection of DbDataReader
+        // we assume that time zone switch happens (if happens)
+        // in DomainConfiguration.ConnectionInitializationSql and
+        // we cache time zone of native connection after the script
+        // has been executed.
+
+        return (defaultTimeZone.HasValue)
+          ? value.ToOffset(defaultTimeZone.Value)
+          : value.ToLocalTime();
       }
     }
 
-    protected internal static NpgsqlInterval CreateNativeIntervalFromTimeSpan(in TimeSpan timeSpan)
-    {
-      // Previous Npgsql versions used days and time, no months.
-      // Thought we can write everything as time, we keep days and time format
-
-      var ticks = timeSpan.Ticks;
-
-      var days = timeSpan.Days;
-      var timeTicks = ticks - (days * TimeSpan.TicksPerDay);
-#if NET7_0_OR_GREATER
-      var microseconds = timeTicks / TimeSpan.TicksPerMicrosecond;
-#else
-      var microseconds = timeTicks / 10L; // same as TimeSpan.TicksPerMicrosecond available in .NET7+
-#endif
-      // no months!
-      return new NpgsqlInterval(0, days, microseconds);
-    }
-
-    protected internal static TimeSpan ResurrectTimeSpanFromNpgsqlInterval(in NpgsqlInterval npgsqlInterval)
-    {
-      // We don't write "Months" part of NpgsqlInterval to database
-      // because days in months is variable measure in PostgreSQL.
-      // We better use exact number of days.
-      // But if for some reason, there is Months value > 0 we treat it like each month has 30 days,
-      // it seems that Npgsql did the same assumption internally.
-
-      var days = (npgsqlInterval.Months != 0)
-        ? npgsqlInterval.Months * WellKnown.IntervalDaysInMonth + npgsqlInterval.Days
-        : npgsqlInterval.Days;
-
-      var ticksOfDays = days * TimeSpan.TicksPerDay;
-#if NET7_0_OR_GREATER
-      var overallTicks = ticksOfDays + (npgsqlInterval.Time * TimeSpan.TicksPerMicrosecond);
-#else
-      var overallTicks = ticksOfDays + (npgsqlInterval.Time * 10); //same as TimeSpan.TicksPerMicrosecond available in .NET7+
-#endif
-      return TimeSpan.FromTicks(overallTicks);
-    }
-
     internal protected ArgumentException ValueNotOfTypeError(string typeName)
     {
       return new ArgumentException($"Value is not of '{typeName}' type.");
@@ -335,7 +297,13 @@ internal protected ArgumentException ValueNotOfTypeError(string typeName)
     public TypeMapper(PostgreSql.Driver driver)
       : base(driver)
     {
-      legacyTimestampBehaviorEnabled = driver.PostgreServerInfo.LegacyTimestampBehavior;
+      var postgreServerInfo = driver.PostgreServerInfo;
+      legacyTimestampBehaviorEnabled = postgreServerInfo.LegacyTimestampBehavior;
+      defaultTimeZone = postgreServerInfo.ServerTimeZones.TryGetValue(
+          PostgreSqlHelper.TryGetZoneFromPosix(postgreServerInfo.DefaultTimeZone), out var offset)
+        ? offset
+        : null;
+      ;
     }
   }
 }