PostgreSql: TimeOnly construction with hours overflow check

Author: alex-kulakov

Orm/Xtensive.Orm.PostgreSql/Sql.Drivers.PostgreSql/v10_0/Compiler.cs

@@ -20,10 +20,24 @@ internal class Compiler : v9_1.Compiler
     protected override SqlExpression ConstructTime(IReadOnlyList<SqlExpression> arguments)
     {
       if (arguments.Count == 4) {
-        return MakeTime(arguments[0], arguments[1], arguments[2], arguments[3]);
+        return MakeTime(arguments[0], arguments[1], arguments[2], arguments[3], true);
+      }
+      else if (arguments.Count == 1) {
+        var ticks = arguments[0];
+        if (SqlHelper.IsTimeSpanTicks(ticks, out var sourceInterval)) {
+          // try to optimize and reduce calculations when TimeSpan.Ticks where used for TimeOnly(ticks) ctor
+          return SqlDml.Cast(SqlDml.Cast(sourceInterval, SqlType.VarChar), SqlType.Time);
+        }
+        else {
+          var hour = SqlDml.Cast(ticks / 36000000000, SqlType.Int32);
+          var minute = SqlDml.Cast((ticks / 600000000) % 60, SqlType.Int32);
+          var second = SqlDml.Cast((ticks / 10000000) % 60, SqlType.Int32);
+          var microsecond = SqlDml.Cast((ticks % 10000000) / 10, SqlType.Int32);
+          return MakeTime(hour, minute, second, microsecond, false);
+        }
       }
       else {
-        return base.ConstructTime(arguments);
+        throw new InvalidOperationException("Unsupported count of parameters");
       }
     }
 #endif
@@ -36,8 +50,10 @@ protected static SqlUserFunctionCall MakeDate(SqlExpression year, SqlExpression
       SqlDml.FunctionCall("MAKE_DATE", year, month, day);
 
     protected static SqlUserFunctionCall MakeTime(
-       SqlExpression hours, SqlExpression minutes, SqlExpression seconds, SqlExpression milliseconds) =>
-     SqlDml.FunctionCall("MAKE_TIME", hours, minutes, seconds + (SqlDml.Cast(milliseconds, SqlType.Double) / 1000));
+       SqlExpression hours, SqlExpression minutes, SqlExpression seconds, SqlExpression secondFractions, in bool isMilliseconds) =>
+      (isMilliseconds) 
+        ? SqlDml.FunctionCall("MAKE_TIME", hours, minutes, seconds + (SqlDml.Cast(secondFractions, SqlType.Double) / 1000))
+        : SqlDml.FunctionCall("MAKE_TIME", hours, minutes, seconds + (SqlDml.Cast(secondFractions, SqlType.Double) / 1000000));
 #endif
 
     // Constructors

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

@@ -415,22 +415,40 @@ protected virtual SqlExpression ConstructDate(IReadOnlyList<SqlExpression> argum
 
     protected virtual SqlExpression ConstructTime(IReadOnlyList<SqlExpression> arguments)
     {
+      SqlExpression hour, minute, second, microsecond;
       if (arguments.Count == 4) {
-        return ZeroTimeLiteral
-          + (OneHourInterval * (arguments[0]))
-          + (OneMinuteInterval * (arguments[1]))
-          + (OneSecondInterval * (arguments[2] + (SqlDml.Cast(arguments[3], SqlType.Double) / 1000)));
+        hour = arguments[0];
+        minute = arguments[1];
+        second = arguments[2];
+        microsecond = arguments[3] * 1000;
       }
       else if (arguments.Count == 1) {
         var ticks = arguments[0];
-        if (SqlHelper.IsTimeSpanTicks(ticks, out var intervalExpr)) {
-          return ZeroTimeLiteral + intervalExpr;
+        if (SqlHelper.IsTimeSpanTicks(ticks, out var sourceInterval)) {
+          // try to optimize and reduce calculations when TimeSpan.Ticks where used for TimeOnly(ticks) ctor
+          return SqlDml.Cast(SqlDml.Cast(sourceInterval, SqlType.VarChar), SqlType.Time);
+        }
+        else {
+          hour = SqlDml.Cast(ticks / 36000000000, SqlType.Int32);
+          minute = SqlDml.Cast((ticks / 600000000) % 60, SqlType.Int32);
+          second = SqlDml.Cast((ticks / 10000000) % 60, SqlType.Int32);
+          microsecond = SqlDml.Cast((ticks % 10000000) / 10, SqlType.Int32);
         }
-        return ZeroTimeLiteral + (ticks / SqlDml.Literal(10000000.0) * OneSecondInterval);
       }
       else {
         throw new InvalidOperationException("Unsupported count of parameters");
-      } 
+      }
+
+      // Using string version of time allows to control hours overflow
+      // we cannot add hours, minutes and other parts to 00:00:00.000000 time
+      // because hours might step over 24 hours and start counting from 0.
+      // Starting from v10 new function is in use, which controlls overflow
+      var hourString = SqlDml.Cast(hour, new SqlValueType(SqlType.VarChar, 3));
+      var minuteString = SqlDml.Cast(minute, new SqlValueType(SqlType.VarChar, 2));
+      var secondString = SqlDml.Cast(second, new SqlValueType(SqlType.VarChar, 2));
+      var microsecondString = SqlDml.Cast(microsecond, new SqlValueType(SqlType.VarChar, 7));
+      var composedTimeString = SqlDml.Concat(hourString, SqlDml.Literal(":"), minuteString, SqlDml.Literal(":"), secondString, SqlDml.Literal("."), microsecondString);
+      return SqlDml.Cast(composedTimeString, SqlType.Time);
     }
 
     protected virtual SqlExpression TimeToNanoseconds(SqlExpression time)