PgSQL: Support for new TimeOnly(ticks)

Author: alex-kulakov

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

@@ -4,32 +4,29 @@
 // Created by: Alexey Kulakov
 // Created:    2019.09.25
 
+using System;
+using System.Collections.Generic;
 using Xtensive.Sql.Dml;
 
 namespace Xtensive.Sql.Drivers.PostgreSql.v10_0
 {
   internal class Compiler : v9_1.Compiler
   {
-    public override void Visit(SqlFunctionCall node)
-    {
-      var arguments = node.Arguments;
-      switch (node.FunctionType) {
-        case SqlFunctionType.DateTimeConstruct:
-          Visit(MakeDateTime(arguments[0], arguments[1], arguments[2]));
-          return;
+    protected override SqlUserFunctionCall ConstructDateTime(IReadOnlyList<SqlExpression> arguments) => MakeDateTime(arguments[0], arguments[1], arguments[2]);
 #if NET6_0_OR_GREATER
-        case SqlFunctionType.DateConstruct:
-          Visit(MakeDate(arguments[0], arguments[1], arguments[2]));
-          return;
-        case SqlFunctionType.TimeConstruct:
-          Visit(MakeTime(arguments[0], arguments[1], arguments[2], arguments[3]));
-          return;
-#endif
-        default:
-          base.Visit(node);
-          return;
+
+    protected override SqlUserFunctionCall ConstructDate(IReadOnlyList<SqlExpression> arguments) => MakeDate(arguments[0], arguments[1], arguments[2]);
+
+    protected override SqlExpression ConstructTime(IReadOnlyList<SqlExpression> arguments)
+    {
+      if (arguments.Count == 4) {
+        return MakeTime(arguments[0], arguments[1], arguments[2], arguments[3]);
+      }
+      else {
+        return base.ConstructTime(arguments);
       }
     }
+#endif
 
     protected static SqlUserFunctionCall MakeDateTime(SqlExpression year, SqlExpression month, SqlExpression day) =>
       SqlDml.FunctionCall("MAKE_TIMESTAMP", year, month, day, SqlDml.Literal(0), SqlDml.Literal(0), SqlDml.Literal(0.0));

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

@@ -3,6 +3,7 @@
 // See the License.txt file in the project root for more information.
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using Xtensive.Orm.Providers.PostgreSql;
 using Xtensive.Sql.Compiler;
@@ -125,24 +126,14 @@ public override void Visit(SqlFunctionCall node)
           SqlHelper.IntervalAbs(node.Arguments[0]).AcceptVisitor(this);
           return;
         case SqlFunctionType.DateTimeConstruct:
-          var newNode = ReferenceDateTimeLiteral
-                         + (OneYearInterval * (node.Arguments[0] - 2001))
-                         + (OneMonthInterval * (node.Arguments[1] - 1))
-                         + (OneDayInterval * (node.Arguments[2] - 1));
-          newNode.AcceptVisitor(this);
+          ConstructDateTime(node.Arguments).AcceptVisitor(this);
           return;
 #if NET6_0_OR_GREATER
         case SqlFunctionType.DateConstruct:
-          (ReferenceDateLiteral
-            + (OneYearInterval * (node.Arguments[0] - 2001))
-            + (OneMonthInterval * (node.Arguments[1] - 1))
-            + (OneDayInterval * (node.Arguments[2] - 1))).AcceptVisitor(this);
+          ConstructDate(node.Arguments).AcceptVisitor(this);
           return;
         case SqlFunctionType.TimeConstruct:
-          ((ZeroTimeLiteral
-            + (OneHourInterval * (node.Arguments[0]))
-            + (OneMinuteInterval * (node.Arguments[1]))
-            + (OneSecondInterval * (node.Arguments[2] + (SqlDml.Cast(node.Arguments[3], SqlType.Double) / 1000))))).AcceptVisitor(this);
+          ConstructTime(node.Arguments).AcceptVisitor(this);
           return;
 #endif
         case SqlFunctionType.DateTimeTruncate:
@@ -397,6 +388,45 @@ public override void Visit(SqlExtract node)
       base.Visit(node);
     }
 
+    protected virtual SqlExpression ConstructDateTime(IReadOnlyList<SqlExpression> arguments)
+    {
+      return ReferenceDateTimeLiteral
+        + (OneYearInterval * (arguments[0] - 2001))
+        + (OneMonthInterval * (arguments[1] - 1))
+        + (OneDayInterval * (arguments[2] - 1));
+    }
+#if NET6_0_OR_GREATER
+
+    protected virtual SqlExpression ConstructDate(IReadOnlyList<SqlExpression> arguments)
+    {
+      return ReferenceDateLiteral
+        + (OneYearInterval * (arguments[0] - 2001))
+        + (OneMonthInterval * (arguments[1] - 1))
+        + (OneDayInterval * (arguments[2] - 1));
+    }
+
+    protected virtual SqlExpression ConstructTime(IReadOnlyList<SqlExpression> arguments)
+    {
+      if (arguments.Count == 4) {
+        return ZeroTimeLiteral
+          + (OneHourInterval * (arguments[0]))
+          + (OneMinuteInterval * (arguments[1]))
+          + (OneSecondInterval * (arguments[2] + (SqlDml.Cast(arguments[3], SqlType.Double) / 1000)));
+      }
+      else if (arguments.Count == 1) {
+        var ticks = arguments[0];
+        if (SqlHelper.IsTimeSpanTicks(ticks, out var intervalExpr)) {
+          return ZeroTimeLiteral + intervalExpr;
+        }
+        return ZeroTimeLiteral + (ticks / SqlDml.Literal(10000000.0) * OneSecondInterval);
+      }
+      else {
+        throw new InvalidOperationException("Unsupported count of parameters");
+      }
+      
+    }
+#endif
+
     protected SqlExpression DateTimeOffsetExtractDate(SqlExpression timestamp) =>
       SqlDml.FunctionCall("DATE", timestamp);
 
@@ -518,6 +548,23 @@ private bool TryDivideOffsetIntoParts(SqlExpression offsetInMinutes, ref int hou
       return false;
     }
 
+    private bool IsTimeSpanTicks(SqlExpression expressionToCheck, out SqlExpression source)
+    {
+      source = null;
+
+      if (expressionToCheck is SqlCast sqlCast && sqlCast.Type.Type==SqlType.Int64) {
+        var operand = sqlCast.Operand;
+        if (operand is SqlBinary sqlBinary && sqlBinary.NodeType == SqlNodeType.Divide) {
+          var left = sqlBinary.Left;
+          if (left is SqlFunctionCall functionCall && functionCall.FunctionType == SqlFunctionType.IntervalToNanoseconds) {
+            source = functionCall.Arguments[0];
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+
     // Constructors
 
     protected internal Compiler(SqlDriver driver)

Orm/Xtensive.Orm/Orm/Providers/Expressions/MemberCompilers/TimeSpanCompilers.cs

@@ -163,6 +163,7 @@ public static SqlExpression TimeSpanDays(SqlExpression _this)
     [Compiler(typeof(TimeSpan), "Ticks", TargetKind.PropertyGet)]
     public static SqlExpression TimeSpanTicks(SqlExpression _this)
     {
+      // there are some operations that rely on this structure.
       return ExpressionTranslationHelpers.ToLong(SqlDml.IntervalToNanoseconds(_this) / NanosecondsPerTick);
     }