TimeOnly constructors support

ChangeLog/7.1.0-RC2-dev.txt

@@ -1 +1,2 @@
-[main] Added support for DefaultExpression within Linq queries
+[main] Added support for DefaultExpression within Linq queries
+[main] Support for TimeOnly ctors (time parts and ticks) in Linq, except for SQLite and MySQL providers

Orm/Xtensive.Orm.Firebird/Sql.Drivers.Firebird/v2_5/Compiler.cs

@@ -10,16 +10,20 @@
 using Xtensive.Sql.Ddl;
 using Xtensive.Sql.Dml;
 using Xtensive.Core;
+using System.Collections.Generic;
 
 namespace Xtensive.Sql.Drivers.Firebird.v2_5
 {
   internal class Compiler : SqlCompiler
   {
-    protected static readonly long NanosecondsPerDay = TimeSpan.FromDays(1).Ticks * 100;
-    protected static readonly long NanosecondsPerSecond = 1000000000;
-    protected static readonly long NanosecondsPerMillisecond = 1000000;
-    protected static readonly long MillisecondsPerDay = (long) TimeSpan.FromDays(1).TotalMilliseconds;
-    protected static readonly long MillisecondsPerSecond = 1000L;
+    protected const long NanosecondsPerDay = 86400000000000;
+    protected const long NanosecondsPerHour = 3600000000000;
+    protected const long NanosecondsPerMinute = 60000000000;
+    protected const long NanosecondsPerSecond = 1000000000;
+    protected const long NanosecondsPerMillisecond = 1000000;
+    protected const long MillisecondsPerDay = 86400000;
+    protected const long MillisecondsPerSecond = 1000L;
+
     private bool case_SqlDateTimePart_DayOfYear;
     private bool case_SqlDateTimePart_Second;
 
@@ -228,10 +232,7 @@ public override void Visit(SqlFunctionCall node)
           Visit(DateAddYear(arguments[0], arguments[1]));
           return;
         case SqlFunctionType.DateTimeConstruct:
-          Visit(DateAddDay(DateAddMonth(DateAddYear(SqlDml.Cast(SqlDml.Literal(new DateTime(2001, 1, 1)), SqlType.DateTime),
-            arguments[0] - 2001),
-            arguments[1] - 1),
-            arguments[2] - 1));
+          ConstructDateTime(arguments).AcceptVisitor(this);
           return;
 #if NET6_0_OR_GREATER
         case SqlFunctionType.DateAddYears:
@@ -244,10 +245,7 @@ public override void Visit(SqlFunctionCall node)
           Visit(DateAddDay(arguments[0], arguments[1]));
           return;
         case SqlFunctionType.DateConstruct:
-          Visit(DateAddDay(DateAddMonth(DateAddYear(SqlDml.Cast(SqlDml.Literal(new DateOnly(2001, 1, 1)), SqlType.Date),
-            arguments[0] - 2001),
-            arguments[1] - 1),
-            arguments[2] - 1));
+          ConstructDate(arguments).AcceptVisitor(this);
           return;
         case SqlFunctionType.TimeAddHours:
           Visit(DateAddHour(node.Arguments[0], node.Arguments[1]));
@@ -256,11 +254,10 @@ public override void Visit(SqlFunctionCall node)
           Visit(DateAddMinute(node.Arguments[0], node.Arguments[1]));
           return;
         case SqlFunctionType.TimeConstruct:
-          Visit(DateAddMillisecond(DateAddSecond(DateAddMinute(DateAddHour(SqlDml.Cast(SqlDml.Literal(new TimeOnly(0, 0, 0)), SqlType.Time),
-            arguments[0]),
-            arguments[1]),
-            arguments[2]),
-            arguments[3]));
+          ConstructTime(arguments).AcceptVisitor(this);
+          return;
+        case SqlFunctionType.TimeToNanoseconds:
+          TimeToNanoseconds(arguments[0]).AcceptVisitor(this);
           return;
         case SqlFunctionType.DateToString:
           Visit(DateToString(arguments[0]));
@@ -299,6 +296,73 @@ public override void Visit(SqlAlterSequence node)
       translator.Translate(context, node, NodeSection.Exit);
     }
 
+    protected virtual SqlExpression ConstructDateTime(IReadOnlyList<SqlExpression> arguments)
+    {
+      return DateAddDay(
+        DateAddMonth(
+          DateAddYear(
+            SqlDml.Cast(SqlDml.Literal(new DateTime(2001, 1, 1)), SqlType.DateTime),
+            arguments[0] - 2001),
+          arguments[1] - 1),
+        arguments[2] - 1);
+    }
+#if NET6_0_OR_GREATER
+
+    protected virtual SqlExpression ConstructDate(IReadOnlyList<SqlExpression> arguments)
+    {
+      return DateAddDay(
+        DateAddMonth(
+          DateAddYear(
+            SqlDml.Cast(SqlDml.Literal(new DateOnly(2001, 1, 1)), SqlType.Date),
+            arguments[0] - 2001),
+          arguments[1] - 1),
+        arguments[2] - 1);
+    }
+
+    protected virtual SqlExpression ConstructTime(IReadOnlyList<SqlExpression> arguments)
+    {
+      SqlExpression hour, minute, second, millisecond;
+      if (arguments.Count == 4) {
+        hour = arguments[0];
+        minute = arguments[1];
+        second = arguments[2];
+        millisecond = arguments[3] * 10;
+      }
+      else if (arguments.Count == 1) {
+        var ticks = arguments[0];
+        // try to optimize and reduce calculations when TimeSpan.Ticks where used for TimeOnly(ticks) ctor
+        ticks = SqlHelper.IsTimeSpanTicks(ticks, out var sourceInterval) ? sourceInterval / 100 : ticks;
+        hour = SqlDml.Cast(ticks / 36000000000, SqlType.Int32);
+        minute = SqlDml.Cast((ticks / 600000000) % 60, SqlType.Int32);
+        second = SqlDml.Cast((ticks / 10000000) % 60, SqlType.Int32);
+        millisecond = SqlDml.Cast((ticks % 10000000) / 1000, SqlType.Int32);
+      }
+      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.0000 time
+      // because hours might step over 24 hours and start counting from 0.
+      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 millisecondString = SqlDml.Cast(millisecond, new SqlValueType(SqlType.VarChar, 4));
+      var composedTimeString = SqlDml.Concat(hourString, SqlDml.Literal(":"), minuteString, SqlDml.Literal(":"), secondString, SqlDml.Literal("."), millisecondString);
+      return SqlDml.Cast(composedTimeString, SqlType.Time);
+    }
+
+    protected virtual SqlExpression TimeToNanoseconds(SqlExpression time)
+    {
+      var nPerHour = SqlDml.Extract(SqlTimePart.Hour, time) * NanosecondsPerHour;
+      var nPerMinute = SqlDml.Extract(SqlTimePart.Minute, time) * NanosecondsPerMinute;
+      var nPerSecond = SqlDml.Extract(SqlTimePart.Second, time) * NanosecondsPerSecond;
+      var nPerMillisecond = SqlDml.Extract(SqlTimePart.Millisecond, time) * NanosecondsPerMillisecond;
+
+      return nPerHour + nPerMinute + nPerSecond + nPerMillisecond;
+    }
+#endif
+
     #region Static helpers
 
     protected static SqlExpression DateTimeSubtractDateTime(SqlExpression date1, SqlExpression date2)

Orm/Xtensive.Orm.MySql/Sql.Drivers.MySql/v5_0/Compiler.cs

@@ -10,17 +10,19 @@
 using Xtensive.Sql.Dml;
 using Xtensive.Sql.Model;
 using Xtensive.Core;
+using System.Collections.Generic;
 
 namespace Xtensive.Sql.Drivers.MySql.v5_0
 {
   internal class Compiler : SqlCompiler
   {
-    protected static readonly long NanosecondsPerDay = TimeSpan.FromDays(1).Ticks * 100;
-    protected static readonly long NanosecondsPerSecond = 1000000000;
-    protected static readonly long NanosecondsPerMillisecond = 1000000;
-    protected static readonly long NanosecondsPerMicrosecond = 1000;
-    protected static readonly long MillisecondsPerDay = (long) TimeSpan.FromDays(1).TotalMilliseconds;
-    protected static readonly long MillisecondsPerSecond = 1000L;
+    protected const long NanosecondsPerDay = 86400000000000;
+    protected const long NanosecondsPerHour = 3600000000000;
+    protected const long NanosecondsPerMinute = 60000000000;
+    protected const long NanosecondsPerSecond = 1000000000;
+    protected const long NanosecondsPerMillisecond = 1000000;
+    protected const long NanosecondsPerMicrosecond = 1000;
+    protected const long MillisecondsPerDay = 86400000;
 
     /// <inheritdoc/>
     public override void Visit(SqlSelect node)
@@ -182,10 +184,7 @@ public override void Visit(SqlFunctionCall node)
           Visit(DateTimeAddYear(arguments[0], arguments[1]));
           return;
         case SqlFunctionType.DateTimeConstruct:
-          Visit(DateTimeAddDay(DateTimeAddMonth(DateTimeAddYear(SqlDml.Literal(new DateTime(2001, 1, 1)),
-            arguments[0] - 2001),
-            arguments[1] - 1),
-            arguments[2] - 1));
+          ConstructDateTime(arguments).AcceptVisitor(this);
           return;
 #if NET6_0_OR_GREATER
         case SqlFunctionType.DateAddYears:
@@ -198,10 +197,7 @@ public override void Visit(SqlFunctionCall node)
           Visit(DateAddDay(arguments[0], arguments[1]));
           return;
         case SqlFunctionType.DateConstruct:
-          Visit(DateAddDay(DateAddMonth(DateAddYear(SqlDml.Literal(new DateOnly(2001, 1, 1)),
-            arguments[0] - 2001),
-            arguments[1] - 1),
-            arguments[2] - 1));
+          ConstructDate(arguments).AcceptVisitor(this);          
           return;
         case SqlFunctionType.TimeAddHours:
           Visit(SqlDml.FunctionCall("TIME", SqlDml.FunctionCall(
@@ -219,12 +215,8 @@ public override void Visit(SqlFunctionCall node)
                 SqlDml.RawConcat(SqlDml.Native("INTERVAL "), SqlDml.FunctionCall("TIME_TO_SEC", arguments[0]) + arguments[1] * 60),
                 SqlDml.Native("SECOND")))));
           return;
-        case SqlFunctionType.TimeConstruct:
-          Visit(SqlDml.FunctionCall("TIME", TimeAddMillisecond(TimeAddSecond(TimeAddMinute(TimeAddHour(SqlDml.Literal(new DateTime(2001, 1, 1)),
-            arguments[0]),
-            arguments[1]),
-            arguments[2]),
-            arguments[3])));
+        case SqlFunctionType.TimeToNanoseconds:
+          TimeToNanoseconds(arguments[0]).AcceptVisitor(this);
           return;
         case SqlFunctionType.DateToString:
           Visit(DateToString(arguments[0]));
@@ -302,6 +294,17 @@ public override void Visit(SqlExtract node)
       base.Visit(node);
     }
 
+    protected virtual SqlExpression ConstructDateTime(IReadOnlyList<SqlExpression> arguments)
+    {
+      return DateTimeAddDay(
+        DateTimeAddMonth(
+          DateTimeAddYear(
+            SqlDml.Literal(new DateTime(2001, 1, 1)),
+            arguments[0] - 2001),
+          arguments[1] - 1),
+        arguments[2] - 1);
+    }
+
     protected virtual SqlExpression DateTimeSubtractDateTime(SqlExpression date1, SqlExpression date2)
     {
       return (CastToDecimal(DateDiffDay(date1, date2), 18, 0) * NanosecondsPerDay)
@@ -317,6 +320,27 @@ protected virtual SqlExpression DateTimeAddInterval(SqlExpression date, SqlExpre
     }
 #if NET6_0_OR_GREATER
 
+    protected virtual SqlExpression ConstructDate(IReadOnlyList<SqlExpression> arguments)
+    {
+      return DateAddDay(
+        DateAddMonth(
+          DateAddYear(
+            SqlDml.Literal(new DateOnly(2001, 1, 1)),
+            arguments[0] - 2001),
+          arguments[1] - 1),
+        arguments[2] - 1);
+    }
+
+    protected virtual SqlExpression TimeToNanoseconds(SqlExpression time)
+    {
+      var nPerHour = SqlDml.Extract(SqlTimePart.Hour, time) * NanosecondsPerHour;
+      var nPerMinute = SqlDml.Extract(SqlTimePart.Minute, time) * NanosecondsPerMinute;
+      var nPerSecond = SqlDml.Extract(SqlTimePart.Second, time) * NanosecondsPerSecond;
+      var nPerMillisecond = SqlDml.Extract(SqlTimePart.Millisecond, time) * NanosecondsPerMillisecond;
+
+      return nPerHour + nPerMinute + nPerSecond + nPerMillisecond;
+    }
+
     protected virtual SqlExpression TimeSubtractTime(SqlExpression time1, SqlExpression time2) =>
       SqlDml.Modulo(
         NanosecondsPerDay + CastToDecimal(SqlDml.FunctionCall("TIME_TO_SEC", time1) - SqlDml.FunctionCall("TIME_TO_SEC", time2), 18, 0) * NanosecondsPerSecond,

Orm/Xtensive.Orm.MySql/Sql.Drivers.MySql/v5_6/Compiler.cs

@@ -5,6 +5,7 @@
 // Created:    2013.12.30
 
 using System;
+using System.Collections.Generic;
 using Xtensive.Sql.Dml;
 
 namespace Xtensive.Sql.Drivers.MySql.v5_6
@@ -40,10 +41,6 @@ public override void Visit(SqlFunctionCall node)
                 SqlDml.Cast(arguments[0], SqlType.DateTime),
                 arguments[1] * 100))); // 100 = 0:01:00
           return;
-        case SqlFunctionType.TimeConstruct: {
-          Visit(MakeTime(arguments[0], arguments[1], arguments[2], arguments[3]));
-          return;
-        }
         case SqlFunctionType.TimeToDateTime:
           Visit(SqlDml.Cast(arguments[0], SqlType.DateTime));
           return;
@@ -53,21 +50,17 @@ public override void Visit(SqlFunctionCall node)
       }
     }
 
-    protected override SqlExpression TimeAddInterval(SqlExpression time, SqlExpression interval)
+    protected override SqlUserFunctionCall TimeAddInterval(SqlExpression time, SqlExpression interval)
     {
       var timeAsDate = SqlDml.Cast(time, SqlType.DateTime);
       return DateTimeAddMicrosecond(timeAsDate,
         (interval / NanosecondsPerMillisecond * NanosecondsPerMicrosecond) % (MillisecondsPerDay * NanosecondsPerMicrosecond));
     }
 
-    protected override SqlExpression TimeSubtractTime(SqlExpression time1, SqlExpression time2) =>
+    protected override SqlBinary TimeSubtractTime(SqlExpression time1, SqlExpression time2) =>
       SqlDml.Modulo(
         NanosecondsPerDay + CastToDecimal(DateTimeDiffMicrosecond(time2, time1), 18, 0) * NanosecondsPerMicrosecond,
         NanosecondsPerDay);
-
-    protected SqlUserFunctionCall MakeTime(
-        SqlExpression hours, SqlExpression minutes, SqlExpression seconds, SqlExpression milliseconds) =>
-      SqlDml.FunctionCall("MAKETIME", hours, minutes, seconds + (milliseconds / 1000));
 #endif
 
     // Constructors