Compilers use dedicated SqlDml methods for Date and Time

alex-kulakov · alex-kulakov · commit 2af4f9673cf7 · 2023-02-08T20:25:08.000+05:00
diff --git a/Orm/Xtensive.Orm.Tests.Sql/DateTimeIntervalTest.cs b/Orm/Xtensive.Orm.Tests.Sql/DateTimeIntervalTest.cs
@@ -181,83 +181,75 @@ public virtual void DateOnlyConstructTest()
         DefaultDateOnly);
     }
 
-    [Test]
-    public virtual void DateOnlySubtractDateTimeTest()
-    {
-      CheckEquality(
-        SqlDml.DateMinusDate(DefaultDateOnly, SecondDateOnly),
-        DefaultDateTime - SecondDateTime);
-    }
-
     [Test]
     public virtual void DateOnlyExtractYearTest()
     {
       CheckEquality(
-        SqlDml.Extract(SqlDateTimePart.Year, DefaultDateOnly),
+        SqlDml.Extract(SqlDatePart.Year, DefaultDateOnly),
         DefaultDateOnly.Year);
     }
 
     [Test]
     public virtual void DateOnlyExtractMonthTest()
     {
       CheckEquality(
-        SqlDml.Extract(SqlDateTimePart.Month, DefaultDateOnly),
+        SqlDml.Extract(SqlDatePart.Month, DefaultDateOnly),
         DefaultDateOnly.Month);
     }
 
     [Test]
     public virtual void DateOnlyExtractDayTest()
     {
       CheckEquality(
-        SqlDml.Extract(SqlDateTimePart.Day, DefaultDateOnly),
+        SqlDml.Extract(SqlDatePart.Day, DefaultDateOnly),
         DefaultDateOnly.Day);
     }
 
     [Test]
     public virtual void DateOnlyExtractDayOfWeekTest()
     {
       CheckEquality(
-        SqlDml.Extract(SqlDateTimePart.DayOfWeek, DefaultDateOnly),
+        SqlDml.Extract(SqlDatePart.DayOfWeek, DefaultDateOnly),
         (int) DefaultDateOnly.DayOfWeek);
     }
 
     [Test]
     public virtual void DateOnlyExtractDayOfYearTest()
     {
       CheckEquality(
-        SqlDml.Extract(SqlDateTimePart.DayOfYear, DefaultDateOnly),
+        SqlDml.Extract(SqlDatePart.DayOfYear, DefaultDateOnly),
         DefaultDateOnly.DayOfYear);
     }
 
     [Test]
     public virtual void TimeOnlyExtractHourTest()
     {
       CheckEquality(
-        SqlDml.Extract(SqlDateTimePart.Hour, DefaultTimeOnly),
+        SqlDml.Extract(SqlTimePart.Hour, DefaultTimeOnly),
         DefaultTimeOnly.Hour);
     }
 
     [Test]
     public virtual void TimeOnlyExtractMinuteTest()
     {
       CheckEquality(
-        SqlDml.Extract(SqlDateTimePart.Minute, DefaultTimeOnly),
+        SqlDml.Extract(SqlTimePart.Minute, DefaultTimeOnly),
         DefaultTimeOnly.Minute);
     }
 
     [Test]
     public virtual void TimeOnlyExtractSecondTest()
     {
       CheckEquality(
-        SqlDml.Extract(SqlDateTimePart.Second, DefaultTimeOnly),
+        SqlDml.Extract(SqlTimePart.Second, DefaultTimeOnly),
         DefaultTimeOnly.Second);
     }
 
     [Test]
     public virtual void TimeOnlyExtractMillisecondTest()
     {
       CheckEquality(
-        SqlDml.Extract(SqlDateTimePart.Millisecond, DefaultTimeOnly),
+        SqlDml.Extract(SqlTimePart.Millisecond, DefaultTimeOnly),
         DefaultTimeOnly.Millisecond);
     }
 
@@ -268,6 +260,14 @@ public virtual void TimeOnlyConstructTest()
         SqlDml.TimeConstruct(DefaultTimeOnly.Hour, DefaultTimeOnly.Minute, DefaultTimeOnly.Second, DefaultTimeOnly.Millisecond),
         DefaultTimeOnly);
     }
+
+    [Test]
+    public virtual void TimeOnlySubtractTimeOnlyTest()
+    {
+      CheckEquality(
+        SqlDml.TimeMinusTime(DefaultTimeOnly, SecondTimeOnly),
+        DefaultTimeOnly - SecondTimeOnly);
+    }
 #endif
 
     [Test]
diff --git a/Orm/Xtensive.Orm/Orm/Providers/Expressions/MemberCompilers/DateOnlyCompilers.cs b/Orm/Xtensive.Orm/Orm/Providers/Expressions/MemberCompilers/DateOnlyCompilers.cs
@@ -117,11 +117,11 @@ public static SqlExpression DateOnlyOperatorLessThanOrEqual(
 
     [Compiler(typeof(DateOnly), "AddYears")]
     public static SqlExpression DateOnlyAddYears(SqlExpression _this, [Type(typeof(int))] SqlExpression value) =>
-      SqlDml.DateTimeAddYears(_this, value);
+      SqlDml.DateAddYears(_this, value);
 
     [Compiler(typeof(DateOnly), "AddMonths")]
     public static SqlExpression DateOnlyAddMonths(SqlExpression _this, [Type(typeof(int))] SqlExpression value) =>
-      SqlDml.DateTimeAddMonths(_this, value);
+      SqlDml.DateAddMonths(_this, value);
 
     [Compiler(typeof(DateOnly), "AddDays")]
     public static SqlExpression DateOnlyAddDays(SqlExpression _this, [Type(typeof(int))] SqlExpression value) =>
diff --git a/Orm/Xtensive.Orm/Orm/Providers/Expressions/MemberCompilers/TimeOnlyCompilers.cs b/Orm/Xtensive.Orm/Orm/Providers/Expressions/MemberCompilers/TimeOnlyCompilers.cs
@@ -75,58 +75,58 @@ public static SqlExpression TimeOnlyCtor(
 
     [Compiler(typeof(TimeOnly), Operator.Equality, TargetKind.Operator)]
     public static SqlExpression TimeOnlyOperatorEquality(
-      [Type(typeof(TimeOnly))] SqlExpression d1,
-      [Type(typeof(TimeOnly))] SqlExpression d2)
+      [Type(typeof(TimeOnly))] SqlExpression t1,
+      [Type(typeof(TimeOnly))] SqlExpression t2)
     {
-      return d1 == d2;
+      return t1 == t2;
     }
 
     [Compiler(typeof(TimeOnly), Operator.Inequality, TargetKind.Operator)]
     public static SqlExpression TimeOnlyOperatorInequality(
-      [Type(typeof(TimeOnly))] SqlExpression d1,
-      [Type(typeof(TimeOnly))] SqlExpression d2)
+      [Type(typeof(TimeOnly))] SqlExpression t1,
+      [Type(typeof(TimeOnly))] SqlExpression t2)
     {
-      return d1 != d2;
+      return t1 != t2;
     }
 
     [Compiler(typeof(TimeOnly), Operator.GreaterThan, TargetKind.Operator)]
     public static SqlExpression TimeOnlyyOperatorGreaterThan(
-      [Type(typeof(TimeOnly))] SqlExpression d1,
-      [Type(typeof(TimeOnly))] SqlExpression d2)
+      [Type(typeof(TimeOnly))] SqlExpression t1,
+      [Type(typeof(TimeOnly))] SqlExpression t2)
     {
-      return d1 > d2;
+      return t1 > t2;
     }
 
     [Compiler(typeof(TimeOnly), Operator.GreaterThanOrEqual, TargetKind.Operator)]
     public static SqlExpression TimeOnlyOperatorGreaterThanOrEqual(
-      [Type(typeof(TimeOnly))] SqlExpression d1,
-      [Type(typeof(TimeOnly))] SqlExpression d2)
+      [Type(typeof(TimeOnly))] SqlExpression t1,
+      [Type(typeof(TimeOnly))] SqlExpression t2)
     {
-      return d1 >= d2;
+      return t1 >= t2;
     }
 
     [Compiler(typeof(TimeOnly), Operator.LessThan, TargetKind.Operator)]
     public static SqlExpression TimeOnlyOperatorLessThan(
-      [Type(typeof(TimeOnly))] SqlExpression d1,
-      [Type(typeof(TimeOnly))] SqlExpression d2)
+      [Type(typeof(TimeOnly))] SqlExpression t1,
+      [Type(typeof(TimeOnly))] SqlExpression t2)
     {
-      return d1 < d2;
+      return t1 < t2;
     }
 
     [Compiler(typeof(TimeOnly), Operator.LessThanOrEqual, TargetKind.Operator)]
     public static SqlExpression TimeOnlyOperatorLessThanOrEqual(
-      [Type(typeof(TimeOnly))] SqlExpression d1,
-      [Type(typeof(TimeOnly))] SqlExpression d2)
+      [Type(typeof(TimeOnly))] SqlExpression t1,
+      [Type(typeof(TimeOnly))] SqlExpression t2)
     {
-      return d1 <= d2;
+      return t1 <= t2;
     }
 
     [Compiler(typeof(TimeOnly), Operator.Subtraction, TargetKind.Operator)]
     public static SqlExpression TimeOnlyOperatorSubtraction(
-      [Type(typeof(TimeOnly))] SqlExpression d1,
-      [Type(typeof(TimeOnly))] SqlExpression d2)
+      [Type(typeof(TimeOnly))] SqlExpression t1,
+      [Type(typeof(TimeOnly))] SqlExpression t2)
     {
-      throw new NotImplementedException();
+      return SqlDml.TimeMinusTime(t1, t2);
     }
 
     #endregion
@@ -139,6 +139,10 @@ public static SqlExpression TimeOnlyAddHours(SqlExpression _this, [Type(typeof(d
     public static SqlExpression TimeOnlyAddMinutes(SqlExpression _this, [Type(typeof(double))] SqlExpression value) =>
       SqlDml.TimeAddMinutes(_this, value);
 
+    [Compiler(typeof(TimeOnly), "Add")]
+    public static SqlExpression TimeOnlyAdd(SqlExpression _this, [Type(typeof(TimeSpan))] SqlExpression value) =>
+      SqlDml.TimePlusInterval(_this, value);
+
     [Compiler(typeof(TimeOnly), "ToString")]
     public static SqlExpression TimeOnlyToStringIso(SqlExpression _this)
     {
diff --git a/Orm/Xtensive.Orm/Sql/Internals/SqlValidator.cs b/Orm/Xtensive.Orm/Sql/Internals/SqlValidator.cs
@@ -180,6 +180,10 @@ public static bool IsArithmeticExpression(SqlExpression node)
         case SqlNodeType.DateTimeOffsetMinusInterval:
         case SqlNodeType.DateTimeOffsetPlusInterval:
         case SqlNodeType.DateTimeOffsetMinusDateTimeOffset:
+#if NET6_0_OR_GREATER
+        case SqlNodeType.TimePlusInterval:
+        case SqlNodeType.TimeMinusTime:
+#endif
           return true;
         case SqlNodeType.Variant:
           var variant = (SqlVariant) node;
diff --git a/Orm/Xtensive.Orm/Sql/SqlDml.cs b/Orm/Xtensive.Orm/Sql/SqlDml.cs
@@ -648,28 +648,35 @@ public static SqlBinary DateTimePlusInterval(SqlExpression left, SqlExpression r
       return new SqlBinary(SqlNodeType.DateTimePlusInterval, left, right);
     }
 
-    public static SqlBinary DateTimeMinusInterval(SqlExpression left, SqlExpression right)
+#if NET6_0_OR_GREATER //DO_DATEONLY
+    public static SqlBinary TimePlusInterval(SqlExpression left, SqlExpression right)
     {
       ArgumentValidator.EnsureArgumentNotNull(left, "left");
       ArgumentValidator.EnsureArgumentNotNull(right, "right");
-      return new SqlBinary(SqlNodeType.DateTimeMinusInterval, left, right);
+      return new SqlBinary(SqlNodeType.TimePlusInterval, left, right);
     }
 
-    public static SqlBinary DateTimeMinusDateTime(SqlExpression left, SqlExpression right)
+    public static SqlBinary TimeMinusTime(SqlExpression left, SqlExpression right)
     {
       ArgumentValidator.EnsureArgumentNotNull(left, "left");
       ArgumentValidator.EnsureArgumentNotNull(right, "right");
-      return new SqlBinary(SqlNodeType.DateTimeMinusDateTime, left, right);
+      return new SqlBinary(SqlNodeType.TimeMinusTime, left, right);
     }
+#endif
 
-#if NET6_0_OR_GREATER //DO_DATEONLY
-    public static SqlBinary DateMinusDate(SqlExpression left, SqlExpression right)
+    public static SqlBinary DateTimeMinusInterval(SqlExpression left, SqlExpression right)
     {
       ArgumentValidator.EnsureArgumentNotNull(left, "left");
       ArgumentValidator.EnsureArgumentNotNull(right, "right");
-      return new SqlBinary(SqlNodeType.DateMinusDate, left, right);
+      return new SqlBinary(SqlNodeType.DateTimeMinusInterval, left, right);
+    }
+
+    public static SqlBinary DateTimeMinusDateTime(SqlExpression left, SqlExpression right)
+    {
+      ArgumentValidator.EnsureArgumentNotNull(left, "left");
+      ArgumentValidator.EnsureArgumentNotNull(right, "right");
+      return new SqlBinary(SqlNodeType.DateTimeMinusDateTime, left, right);
     }
-#endif
 
     public static SqlFunctionCall DateTimeAddYears(SqlExpression source, SqlExpression years)
     {
diff --git a/Orm/Xtensive.Orm/Sql/SqlNodeType.cs b/Orm/Xtensive.Orm/Sql/SqlNodeType.cs
@@ -47,6 +47,10 @@ public enum SqlNodeType
     DateTimeOffsetPlusInterval,
     DateTimeOffsetMinusInterval,
     DateTimeOffsetMinusDateTimeOffset,
+#if NET6_0_OR_GREATER //DO_DATEONLY
+    TimePlusInterval,
+    TimeMinusTime,
+#endif
     DeclareCursor,
     DefaultValue,
     Delete,
@@ -113,6 +117,5 @@ public enum SqlNodeType
     While,
     Fragment,
     Metadata,
-    DateMinusDate,
   }
 }

Original file line number	Diff line number	Diff line change
`@@ -181,83 +181,75 @@ public virtual void DateOnlyConstructTest()`
`181`	`181`	`DefaultDateOnly);`
`182`	`182`	`}`
`183`	`183`
`184`		`- [Test]`
`185`		`- public virtual void DateOnlySubtractDateTimeTest()`
`186`		`- {`
`187`		`- CheckEquality(`
`188`		`- SqlDml.DateMinusDate(DefaultDateOnly, SecondDateOnly),`
`189`		`- DefaultDateTime - SecondDateTime);`
`190`		`- }`
`191`		`-`
`192`	`184`	`[Test]`
`193`	`185`	`public virtual void DateOnlyExtractYearTest()`
`194`	`186`	`{`
`195`	`187`	`CheckEquality(`
`196`		`- SqlDml.Extract(SqlDateTimePart.Year, DefaultDateOnly),`
	`188`	`+ SqlDml.Extract(SqlDatePart.Year, DefaultDateOnly),`
`197`	`189`	`DefaultDateOnly.Year);`
`198`	`190`	`}`
`199`	`191`
`200`	`192`	`[Test]`
`201`	`193`	`public virtual void DateOnlyExtractMonthTest()`
`202`	`194`	`{`
`203`	`195`	`CheckEquality(`
`204`		`- SqlDml.Extract(SqlDateTimePart.Month, DefaultDateOnly),`
	`196`	`+ SqlDml.Extract(SqlDatePart.Month, DefaultDateOnly),`
`205`	`197`	`DefaultDateOnly.Month);`
`206`	`198`	`}`
`207`	`199`
`208`	`200`	`[Test]`
`209`	`201`	`public virtual void DateOnlyExtractDayTest()`
`210`	`202`	`{`
`211`	`203`	`CheckEquality(`
`212`		`- SqlDml.Extract(SqlDateTimePart.Day, DefaultDateOnly),`
	`204`	`+ SqlDml.Extract(SqlDatePart.Day, DefaultDateOnly),`
`213`	`205`	`DefaultDateOnly.Day);`
`214`	`206`	`}`
`215`	`207`
`216`	`208`	`[Test]`
`217`	`209`	`public virtual void DateOnlyExtractDayOfWeekTest()`
`218`	`210`	`{`
`219`	`211`	`CheckEquality(`
`220`		`- SqlDml.Extract(SqlDateTimePart.DayOfWeek, DefaultDateOnly),`
	`212`	`+ SqlDml.Extract(SqlDatePart.DayOfWeek, DefaultDateOnly),`
`221`	`213`	`(int) DefaultDateOnly.DayOfWeek);`
`222`	`214`	`}`
`223`	`215`
`224`	`216`	`[Test]`
`225`	`217`	`public virtual void DateOnlyExtractDayOfYearTest()`
`226`	`218`	`{`
`227`	`219`	`CheckEquality(`
`228`		`- SqlDml.Extract(SqlDateTimePart.DayOfYear, DefaultDateOnly),`
	`220`	`+ SqlDml.Extract(SqlDatePart.DayOfYear, DefaultDateOnly),`
`229`	`221`	`DefaultDateOnly.DayOfYear);`
`230`	`222`	`}`
`231`	`223`
`232`	`224`	`[Test]`
`233`	`225`	`public virtual void TimeOnlyExtractHourTest()`
`234`	`226`	`{`
`235`	`227`	`CheckEquality(`
`236`		`- SqlDml.Extract(SqlDateTimePart.Hour, DefaultTimeOnly),`
	`228`	`+ SqlDml.Extract(SqlTimePart.Hour, DefaultTimeOnly),`
`237`	`229`	`DefaultTimeOnly.Hour);`
`238`	`230`	`}`
`239`	`231`
`240`	`232`	`[Test]`
`241`	`233`	`public virtual void TimeOnlyExtractMinuteTest()`
`242`	`234`	`{`
`243`	`235`	`CheckEquality(`
`244`		`- SqlDml.Extract(SqlDateTimePart.Minute, DefaultTimeOnly),`
	`236`	`+ SqlDml.Extract(SqlTimePart.Minute, DefaultTimeOnly),`
`245`	`237`	`DefaultTimeOnly.Minute);`
`246`	`238`	`}`
`247`	`239`
`248`	`240`	`[Test]`
`249`	`241`	`public virtual void TimeOnlyExtractSecondTest()`
`250`	`242`	`{`
`251`	`243`	`CheckEquality(`
`252`		`- SqlDml.Extract(SqlDateTimePart.Second, DefaultTimeOnly),`
	`244`	`+ SqlDml.Extract(SqlTimePart.Second, DefaultTimeOnly),`
`253`	`245`	`DefaultTimeOnly.Second);`
`254`	`246`	`}`
`255`	`247`
`256`	`248`	`[Test]`
`257`	`249`	`public virtual void TimeOnlyExtractMillisecondTest()`
`258`	`250`	`{`
`259`	`251`	`CheckEquality(`
`260`		`- SqlDml.Extract(SqlDateTimePart.Millisecond, DefaultTimeOnly),`
	`252`	`+ SqlDml.Extract(SqlTimePart.Millisecond, DefaultTimeOnly),`
`261`	`253`	`DefaultTimeOnly.Millisecond);`
`262`	`254`	`}`
`263`	`255`
`@@ -268,6 +260,14 @@ public virtual void TimeOnlyConstructTest()`
`268`	`260`	`SqlDml.TimeConstruct(DefaultTimeOnly.Hour, DefaultTimeOnly.Minute, DefaultTimeOnly.Second, DefaultTimeOnly.Millisecond),`
`269`	`261`	`DefaultTimeOnly);`
`270`	`262`	`}`
	`263`	`+`
	`264`	`+ [Test]`
	`265`	`+ public virtual void TimeOnlySubtractTimeOnlyTest()`
	`266`	`+ {`
	`267`	`+ CheckEquality(`
	`268`	`+ SqlDml.TimeMinusTime(DefaultTimeOnly, SecondTimeOnly),`
	`269`	`+ DefaultTimeOnly - SecondTimeOnly);`
	`270`	`+ }`
`271`	`271`	`#endif`
`272`	`272`
`273`	`273`	`[Test]`
Original file line number	Diff line number	Diff line change
`@@ -648,28 +648,35 @@ public static SqlBinary DateTimePlusInterval(SqlExpression left, SqlExpression r`
`648`	`648`	`return new SqlBinary(SqlNodeType.DateTimePlusInterval, left, right);`
`649`	`649`	`}`
`650`	`650`
`651`		`- public static SqlBinary DateTimeMinusInterval(SqlExpression left, SqlExpression right)`
	`651`	`+#if NET6_0_OR_GREATER //DO_DATEONLY`
	`652`	`+ public static SqlBinary TimePlusInterval(SqlExpression left, SqlExpression right)`
`652`	`653`	`{`
`653`	`654`	`ArgumentValidator.EnsureArgumentNotNull(left, "left");`
`654`	`655`	`ArgumentValidator.EnsureArgumentNotNull(right, "right");`
`655`		`- return new SqlBinary(SqlNodeType.DateTimeMinusInterval, left, right);`
	`656`	`+ return new SqlBinary(SqlNodeType.TimePlusInterval, left, right);`
`656`	`657`	`}`
`657`	`658`
`658`		`- public static SqlBinary DateTimeMinusDateTime(SqlExpression left, SqlExpression right)`
	`659`	`+ public static SqlBinary TimeMinusTime(SqlExpression left, SqlExpression right)`
`659`	`660`	`{`
`660`	`661`	`ArgumentValidator.EnsureArgumentNotNull(left, "left");`
`661`	`662`	`ArgumentValidator.EnsureArgumentNotNull(right, "right");`
`662`		`- return new SqlBinary(SqlNodeType.DateTimeMinusDateTime, left, right);`
	`663`	`+ return new SqlBinary(SqlNodeType.TimeMinusTime, left, right);`
`663`	`664`	`}`
	`665`	`+#endif`
`664`	`666`
`665`		`-#if NET6_0_OR_GREATER //DO_DATEONLY`
`666`		`- public static SqlBinary DateMinusDate(SqlExpression left, SqlExpression right)`
	`667`	`+ public static SqlBinary DateTimeMinusInterval(SqlExpression left, SqlExpression right)`
`667`	`668`	`{`
`668`	`669`	`ArgumentValidator.EnsureArgumentNotNull(left, "left");`
`669`	`670`	`ArgumentValidator.EnsureArgumentNotNull(right, "right");`
`670`		`- return new SqlBinary(SqlNodeType.DateMinusDate, left, right);`
	`671`	`+ return new SqlBinary(SqlNodeType.DateTimeMinusInterval, left, right);`
	`672`	`+ }`
	`673`	`+`
	`674`	`+ public static SqlBinary DateTimeMinusDateTime(SqlExpression left, SqlExpression right)`
	`675`	`+ {`
	`676`	`+ ArgumentValidator.EnsureArgumentNotNull(left, "left");`
	`677`	`+ ArgumentValidator.EnsureArgumentNotNull(right, "right");`
	`678`	`+ return new SqlBinary(SqlNodeType.DateTimeMinusDateTime, left, right);`
`671`	`679`	`}`
`672`		`-#endif`
`673`	`680`
`674`	`681`	`public static SqlFunctionCall DateTimeAddYears(SqlExpression source, SqlExpression years)`
`675`	`682`	`{`