Merge branch '7.0'

# Conflicts:
#	Extensions/Xtensive.Orm.BulkOperations/Internals/BaseSqlVisitor.cs
#	Orm/Xtensive.Orm.Tests.Sql/SqlServer/ExtractorTest.cs
#	Version.props

Author: alex-kulakov

ChangeLog/6.0.9_Z_Final.txt

@@ -0,0 +1,5 @@
+[main] Improved enum comparison in queries so result SQL queries won't break index seek if any exists
+[main] Improved enum comparison in partial indexes
+[main] Addressed certain issues with with async queries containing .Store() and .In() via temporary table
+[sqlserver] Fixed Full-text indexes extraction for Azure SQL provider
+[sqlserver] Correct extraction of custom sequences based on types other than BIGINT

ChangeLog/7.0.2.txt

@@ -0,0 +1,3 @@
+[main] Addressed certain issues of enum equality expressions translation that appeared in v7.0.0
+[sqlserver] Replaced usage of DATEDIFF with DATEDIFF_BIG for v13 and newer
+[sqlserver] Improved certain operations based on DateTime/DateTimeOffset subtraction for v13 and newer

Extensions/Xtensive.Orm.BulkOperations/Internals/BaseSqlVisitor.cs

@@ -516,7 +516,6 @@ public virtual void Visit(SqlWhile node)
       VisitInternal(node.Statement);
     }
 
-
     public virtual void Visit(SqlFragment node)
     {
       VisitInternal(node.Expression);
@@ -526,6 +525,11 @@ public virtual void Visit(SqlComment node)
     {
     }
 
+    public virtual void Visit(SqlMetadata node)
+    {
+      VisitInternal(node.Expression);
+    }
+
     #region Non-public methods
 
     private void VisitInternal(ISqlNode node)
@@ -539,4 +543,4 @@ private void VisitInternal(ISqlNode node)
 
     #endregion
   }
-}
+}

Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/Azure/Extractor.cs

@@ -1,28 +1,18 @@
-// Copyright (C) 2010-2020 Xtensive LLC.
+// Copyright (C) 2010-2021 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 // Created by: Denis Krjuchkov
 // Created:    2010.03.02
 
-using System.Threading;
-using System.Threading.Tasks;
-
 namespace Xtensive.Sql.Drivers.SqlServer.Azure
 {
   internal class Extractor : v12.Extractor
   {
-    protected override void ExtractFulltextIndexes(ExtractionContext context)
-    {
-    }
-
-    protected override Task ExtractFulltextIndexesAsync(ExtractionContext context, CancellationToken token) => Task.CompletedTask;
-
-
     // Constructors
 
     public Extractor(SqlDriver driver)
       : base(driver)
     {
     }
   }
-}
+}

Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/v09/Compiler.cs

@@ -18,6 +18,18 @@ namespace Xtensive.Sql.Drivers.SqlServer.v09
 {
   internal class Compiler : SqlCompiler
   {
+    #region Date parts
+    protected const string NanosecondPart = "NS";
+    protected const string MillisecondPart = "MS";
+    protected const string SecondPart = "SECOND";
+    protected const string MinutePart = "MINUTE";
+    protected const string HourPart = "HOUR";
+    protected const string DayPart = "DAY";
+    protected const string MonthPart = "MONTH";
+    protected const string YearPart = "YEAR";
+    protected const string WeekdayPart = "WEEKDAY";
+    #endregion
+
     protected static readonly long NanosecondsPerDay = TimeSpan.FromDays(1).Ticks*100;
     protected static readonly long NanosecondsPerSecond = 1000000000;
     protected static readonly long NanosecondsPerMillisecond = 1000000;
@@ -383,64 +395,64 @@ public override void Visit(SqlCreateIndex node, IndexColumn item)
 
     #region Static helpers
 
-    private static SqlCast CastToLong(SqlExpression arg)
+    protected static SqlCast CastToLong(SqlExpression arg)
     {
       return SqlDml.Cast(arg, SqlType.Int64);
     }
 
-    private static SqlCast CastToDecimal(SqlExpression arg, short precision, short scale)
+    protected static SqlCast CastToDecimal(SqlExpression arg, short precision, short scale)
     {
       return SqlDml.Cast(arg, SqlType.Decimal, precision, scale);
     }
 
     protected static SqlUserFunctionCall DatePartWeekDay(SqlExpression date)
     {
-      return SqlDml.FunctionCall("DATEPART", SqlDml.Native("WEEKDAY"), date);
+      return SqlDml.FunctionCall("DATEPART", SqlDml.Native(WeekdayPart), date);
     }
 
     protected static SqlUserFunctionCall DateDiffDay(SqlExpression date1, SqlExpression date2)
     {
-      return SqlDml.FunctionCall("DATEDIFF", SqlDml.Native("DAY"), date1, date2);
+      return SqlDml.FunctionCall("DATEDIFF", SqlDml.Native(DayPart), date1, date2);
     }
 
     protected static SqlUserFunctionCall DateDiffMillisecond(SqlExpression date1, SqlExpression date2)
     {
-      return SqlDml.FunctionCall("DATEDIFF", SqlDml.Native("MS"), date1, date2);
+      return SqlDml.FunctionCall("DATEDIFF", SqlDml.Native(MillisecondPart), date1, date2);
     }
 
     protected static SqlUserFunctionCall DateAddYear(SqlExpression date, SqlExpression years)
     {
-      return SqlDml.FunctionCall("DATEADD", SqlDml.Native("YEAR"),years, date);
+      return SqlDml.FunctionCall("DATEADD", SqlDml.Native(YearPart),years, date);
     }
 
     protected static SqlUserFunctionCall DateAddMonth(SqlExpression date, SqlExpression months)
     {
-      return SqlDml.FunctionCall("DATEADD", SqlDml.Native("MONTH"), months, date);
+      return SqlDml.FunctionCall("DATEADD", SqlDml.Native(MonthPart), months, date);
     }
 
     protected static SqlUserFunctionCall DateAddDay(SqlExpression date, SqlExpression days)
     {
-      return SqlDml.FunctionCall("DATEADD", SqlDml.Native("DAY"), days, date);
+      return SqlDml.FunctionCall("DATEADD", SqlDml.Native(DayPart), days, date);
     }
 
     protected static SqlUserFunctionCall DateAddHour(SqlExpression date, SqlExpression hours)
     {
-      return SqlDml.FunctionCall("DATEADD", SqlDml.Native("HOUR"), hours, date);
+      return SqlDml.FunctionCall("DATEADD", SqlDml.Native(HourPart), hours, date);
     }
 
     protected static SqlUserFunctionCall DateAddMinute(SqlExpression date, SqlExpression minutes)
     {
-      return SqlDml.FunctionCall("DATEADD", SqlDml.Native("MINUTE"), minutes, date);
+      return SqlDml.FunctionCall("DATEADD", SqlDml.Native(MinutePart), minutes, date);
     }
 
     protected static SqlUserFunctionCall DateAddSecond(SqlExpression date, SqlExpression seconds)
     {
-      return SqlDml.FunctionCall("DATEADD", SqlDml.Native("SECOND"), seconds, date);
+      return SqlDml.FunctionCall("DATEADD", SqlDml.Native(SecondPart), seconds, date);
     }
 
     protected static SqlUserFunctionCall DateAddMillisecond(SqlExpression date, SqlExpression milliseconds)
     {
-      return SqlDml.FunctionCall("DATEADD", SqlDml.Native("MS"), milliseconds, date);
+      return SqlDml.FunctionCall("DATEADD", SqlDml.Native(MillisecondPart), milliseconds, date);
     }
 
     protected static SqlUserFunctionCall DateTimeToStringIso(SqlExpression dateTime)

Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/v10/Compiler.cs

@@ -11,15 +11,17 @@ namespace Xtensive.Sql.Drivers.SqlServer.v10
 {
   internal class Compiler : v09.Compiler
   {
+    protected const string OffsetPart = "TZoffset";
     protected const string UtcTimeZone = "+00:00";
+    protected const string ZeroTime = "'00:00:00.0000000'";
     protected const string SqlDateTypeName = "date";
     protected const string SqlDateTime2TypeName = "datetime2";
 
     protected static SqlUserFunctionCall DateAddNanosecond(SqlExpression date, SqlExpression nanoseconds) =>
-      SqlDml.FunctionCall("DATEADD", SqlDml.Native("NS"), nanoseconds, date);
+      SqlDml.FunctionCall("DATEADD", SqlDml.Native(NanosecondPart), nanoseconds, date);
 
     protected static SqlUserFunctionCall DateDiffNanosecond(SqlExpression date1, SqlExpression date2) =>
-      SqlDml.FunctionCall("DATEDIFF", SqlDml.Native("NS"), date1, date2);
+      SqlDml.FunctionCall("DATEDIFF", SqlDml.Native(NanosecondPart), date1, date2);
 
     protected override SqlExpression DateTimeTruncate(SqlExpression date) =>
       SqlDml.Cast(
@@ -144,7 +146,7 @@ private static SqlExpression DateTimeOffsetPartOffset(SqlExpression dateTimeOffs
 
     private static SqlExpression DateTimeOffsetTimeOfDay(SqlExpression dateTimeOffset) =>
       DateDiffMillisecond(
-        SqlDml.Native("'00:00:00.0000000'"),
+        SqlDml.Native(ZeroTime),
         SqlDml.Cast(dateTimeOffset, new SqlValueType("time")))
       * NanosecondsPerMillisecond;
 
@@ -158,7 +160,7 @@ private static SqlExpression Switchoffset(SqlExpression dateTimeOffset, SqlExpre
       SqlDml.FunctionCall("SWITCHOFFSET", dateTimeOffset, offset);
 
     private static SqlUserFunctionCall DateTimeOffsetTimeZoneInMinutes(SqlExpression date) =>
-      SqlDml.FunctionCall("DATEPART", SqlDml.Native("TZoffset"), date);
+      SqlDml.FunctionCall("DATEPART", SqlDml.Native(OffsetPart), date);
 
     private static SqlExpression DateTimeOffsetToLocalTime(SqlExpression dateTimeOffset) =>
       Switchoffset(dateTimeOffset, DateTimeOffsetTimeZoneInMinutes(SqlDml.Native("SYSDATETIMEOFFSET()")));
@@ -170,7 +172,7 @@ private static SqlExpression DateTimeToDateTimeOffset(SqlExpression dateTime) =>
       SqlDml.FunctionCall("TODATETIMEOFFSET",
         dateTime,
         SqlDml.FunctionCall("DATEPART",
-          SqlDml.Native("TZoffset"),
+          SqlDml.Native(OffsetPart),
           SqlDml.Native("SYSDATETIMEOFFSET()")));
 
     #endregion

Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/v11/Extractor.cs

@@ -4,6 +4,7 @@
 // Created by: Denis Krjuchkov
 // Created:    2012.04.05
 
+using System;
 using System.Collections.Generic;
 using System.Data.Common;
 using System.Threading;
@@ -13,6 +14,8 @@ namespace Xtensive.Sql.Drivers.SqlServer.v11
 {
   internal class Extractor : v10.Extractor
   {
+    private readonly Dictionary<int, Func<DbDataReader, int, long>> valueReaders;
+
     protected override void ExtractCatalogContents(ExtractionContext context)
     {
       base.ExtractCatalogContents(context);
@@ -57,6 +60,7 @@ private string BuildExtractSequencesQuery(ExtractionContext context)
   SELECT
     schema_id,
     name,
+    user_type_id,
     start_value,
     increment,
     minimum_value,
@@ -74,15 +78,22 @@ ORDER BY
 
     private void ReadSequenceData(DbDataReader reader, ExtractionContext context)
     {
+
       var currentSchema = context.SchemaIndex[reader.GetInt32(0)];
-      var sequence = currentSchema.CreateSequence(reader.GetString(1));
+      var sequenceName = reader.GetString(1);
+      var sequence = currentSchema.CreateSequence(sequenceName);
       var descriptor = sequence.SequenceDescriptor;
-      descriptor.StartValue = reader.GetInt64(2);
-      descriptor.Increment = reader.GetInt64(3);
-      descriptor.MinValue = reader.GetInt64(4);
-      descriptor.MaxValue = reader.GetInt64(5);
-      descriptor.IsCyclic = reader.GetBoolean(6);
-      descriptor.LastValue = reader.GetInt64(7);
+
+      if (!valueReaders.TryGetValue(reader.GetInt32(2), out var valueReader)) {
+        throw new ArgumentOutOfRangeException($"Type of sequence '{sequenceName}' is not supported.");
+      }
+
+      descriptor.StartValue = valueReader(reader, 3);
+      descriptor.Increment = valueReader(reader, 4);
+      descriptor.MinValue = valueReader(reader, 5);
+      descriptor.MaxValue = valueReader(reader, 6);
+      descriptor.IsCyclic = reader.GetBoolean(7);
+      descriptor.LastValue = valueReader(reader, 8);
     }
 
 
@@ -95,6 +106,11 @@ protected override void RegisterReplacements(ExtractionContext context)
     public Extractor(SqlDriver driver)
       : base(driver)
     {
+      valueReaders = new Dictionary<int, Func<DbDataReader, int, long>>(4);
+      valueReaders[48] = (DbDataReader reader, int index) => reader.GetByte(index);
+      valueReaders[52] = (DbDataReader reader, int index) => reader.GetInt16(index);
+      valueReaders[56] = (DbDataReader reader, int index) => reader.GetInt32(index);
+      valueReaders[127] = (DbDataReader reader, int index) => reader.GetInt64(index);
     }
   }
-}
+}

Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/v13/Compiler.cs

@@ -1,13 +1,85 @@
-// Copyright (C) 2018 Xtensive LLC.
-// All rights reserved.
-// For conditions of distribution and use, see license.
+// Copyright (C) 2018-2021 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
 // Created by: Alexey Kulakov
 // Created:    2018.09.21
 
+using Xtensive.Sql.Dml;
+
 namespace Xtensive.Sql.Drivers.SqlServer.v13
 {
   internal class Compiler : v12.Compiler
   {
+    protected const string MicrosecondPart = "MCS";
+    protected const long NanosecondsPerMicrosecond = 1000;
+
+    /// <inheritdoc/>
+    public override void Visit(SqlFunctionCall node)
+    {
+      switch (node.FunctionType) {
+        case SqlFunctionType.DateTimeOffsetTimeOfDay:
+          DateTimeOffsetTimeOfDay(node.Arguments[0]).AcceptVisitor(this);
+          break;
+        case SqlFunctionType.IntervalToMilliseconds: {
+          if (node.Arguments[0] is SqlBinary binary 
+              && (binary.NodeType == SqlNodeType.DateTimeMinusDateTime || binary.NodeType == SqlNodeType.DateTimeOffsetMinusDateTimeOffset)) {
+            Visit(DateDiffBigMicrosecond(binary.Right, binary.Left) / CastToLong(1000));
+          }
+          else {
+            base.Visit(node);
+          }
+          break;
+        }
+        case SqlFunctionType.IntervalToNanoseconds: {
+          if (node.Arguments[0] is SqlBinary binary
+              && (binary.NodeType == SqlNodeType.DateTimeMinusDateTime || binary.NodeType == SqlNodeType.DateTimeOffsetMinusDateTimeOffset)) {
+            // we have to use time consuming algorithm here because
+            // DATEDIFF_BIG can throw arithmetic overflow on nanoseconds
+            // so we should handle it by this big formula
+            Visit(CastToLong(DateTimeSubtractDateTimeExpensive(binary.Right, binary.Left)));
+          }
+          else {
+            base.Visit(node);
+          }
+          break;
+        }
+        default:
+          base.Visit(node); break;
+      }
+    }
+
+    protected override SqlExpression DateTimeSubtractDateTime(SqlExpression date1, SqlExpression date2)
+    {
+      return CastToDecimal(DateDiffBigMicrosecond(date2, date1), 18, 0) * CastToLong(1000);
+    }
+
+    private SqlExpression DateTimeSubtractDateTimeExpensive(SqlExpression date1, SqlExpression date2)
+    {
+      return CastToDecimal(DateDiffBigDay(date2, date1), 18, 0) * NanosecondsPerDay
+          + CastToDecimal(DateDiffBigMillisecond(DateAddDay(date2, DateDiffBigDay(date2, date1)), date1), 18, 0) * NanosecondsPerMillisecond;
+    }
+
+    #region Static Helpers
+
+    protected static SqlExpression DateTimeOffsetTimeOfDay(SqlExpression dateTimeOffset) =>
+      DateDiffBigNanosecond(
+        SqlDml.Native(ZeroTime),
+        SqlDml.Cast(dateTimeOffset, new SqlValueType("time")));
+
+    protected static SqlUserFunctionCall DateDiffBigNanosecond(SqlExpression date1, SqlExpression date2) =>
+      SqlDml.FunctionCall("DATEDIFF_BIG", SqlDml.Native(NanosecondPart), date1, date2);
+
+    protected static SqlUserFunctionCall DateDiffBigMicrosecond(SqlExpression date1, SqlExpression date2) =>
+      SqlDml.FunctionCall("DATEDIFF_BIG", SqlDml.Native(MicrosecondPart), date1, date2);
+
+    protected static SqlUserFunctionCall DateDiffBigMillisecond(SqlExpression date1, SqlExpression date2) =>
+      SqlDml.FunctionCall("DATEDIFF_BIG", SqlDml.Native(MillisecondPart), date1, date2);
+
+    protected static SqlUserFunctionCall DateDiffBigDay(SqlExpression date1, SqlExpression date2) =>
+      SqlDml.FunctionCall("DATEDIFF_BIG", SqlDml.Native(DayPart), date1, date2);
+
+    #endregion
+
     public Compiler(SqlDriver driver)
       : base(driver)
     {