System.DateTime 和 SQL 服务器 DateTime2 比较产生意外结果

Question

I have included a complete reproduction below but here is the basic operation that is causing strange results.

1. INSERT a row into a SQL Server table with a datetime2(7) column and set the column to SYSUTCDATETIME()
2. Read the datetime of that record into a .net System.DateTime type (using System.Data.SqlClient )
3. Run a query that is SELECT * FROM table WHERE DateColumn < @readDate
4. About 50% of the time, that query will return the created record, even though the code is passing in the date it read from the created column

My assumption is this is a precision issue (eg, .net datetime higher precision than SQL Server datetime2(7) or vice versa).

My questions, then, are:

• Why does this issue occur?
• How can the code be written so these queries would consistently work correctly

I have also discovered the following:

• Using GETUTCDATE() instead of SYSUTCDATETIME() only causes failures 20% of the time
• The issue does not occur using the datetime or datetime2([1-2]) date types, it is only when using precision of 3 or higher with datetime2 the issue occurs

using System;
using System.Data.SqlClient;

namespace DateTimeTesting
{
  public class Program
  {
    public static void Main()
    {
      const string connectionString = "Server=(localdb)\\mssqllocaldb;Trusted_Connection=True;ConnectRetryCount=0";
      const int numRuns = 1000;
      const int printLimiter = 100;

      var connection = new SqlConnection(connectionString);
      connection.Open();

      using (var dropDbCommand = connection.CreateCommand())
      {
        dropDbCommand.CommandText = @"IF NOT EXISTS (SELECT * FROM sys.databases WHERE name = N'DateTimeTesting') BEGIN CREATE DATABASE [DateTimeTesting] END;";
        dropDbCommand.ExecuteNonQuery();
      }

      connection.ChangeDatabase("DateTimeTesting");

      using (var createTableCommand = connection.CreateCommand())
      {
        createTableCommand.CommandText = "IF OBJECT_ID('JustChecking') IS NULL CREATE TABLE JustChecking (id INT IDENTITY(1,1), CreateDateUTC datetime2(7))";
        createTableCommand.ExecuteNonQuery();
      }

      try
      {
        int weirdCounter = 0;
        for (int i = 0; i < numRuns; ++i)
        {
          if ((i + 1) % printLimiter == 0)
          {
            Console.WriteLine($"Run #{i + 1}");
          }

          int id = -1;
          DateTime found = DateTime.MinValue;

          using (var insertCommand = connection.CreateCommand())
          {
            insertCommand.CommandText = "INSERT INTO JustChecking (CreateDateUTC) VALUES (SYSUTCDATETIME()); SELECT @@IDENTITY as id;";
            using var insertReader = insertCommand.ExecuteReader();
            if (insertReader.Read())
            {
              id = (int)insertReader.GetDecimal(0);
            }
          }

          using (var selectCommand = connection.CreateCommand())
          {
            selectCommand.CommandText = "SELECT CreateDateUTC FROM JustChecking WHERE id = @id";
            selectCommand.Parameters.AddWithValue("@id", id);

            using var selectReader = selectCommand.ExecuteReader();

            if (selectReader.Read())
            {
              found = selectReader.GetDateTime(0);
            }
          }

          using (var weirdCommand = connection.CreateCommand())
          {
            weirdCommand.CommandText = "SELECT id, CreateDateUTC FROM JustChecking WHERE CreateDateUtc < @inputDate AND id = @inputId";
            weirdCommand.Parameters.AddWithValue("@inputDate", found);
            weirdCommand.Parameters.AddWithValue("@inputId", id);

            using var weirdReader = weirdCommand.ExecuteReader();
            while (weirdReader.Read())
            {
              weirdCounter++;

              if (weirdCounter % printLimiter == 0)
              {
                Console.WriteLine($"Weird #{weirdCounter} = id: {weirdReader.GetInt32(0)}, createDateUtc: {weirdReader.GetDateTime(1):O}, inputDate: {found:O}");
              }
            }
          }
        }

        Console.WriteLine($"Out of {numRuns} runs found {weirdCounter} weird results which accounted for {(double)weirdCounter / (double)numRuns} percent of runs");

        connection.ChangeDatabase("master");
        using (var dropDbCommand = connection.CreateCommand())
        {
          dropDbCommand.CommandText = "DROP DATABASE DateTimeTesting";
          dropDbCommand.ExecuteNonQuery();
        }
      }
      finally
      {
        connection.Close();
        connection.Dispose();
      }
    }
  }
}

Versions used:

• .NET Core 3.1 (SDK v3.1.301)
• System.Data.SqlClient v4.8.1
• LocalDB version = 13.1.4001.0

Answer 1

There was a breaking change introduced in SQL Server 2016 that changed how DATETIME values are converted to DATETIME2 values, and because of this it's critical to always use DATETIME2 parameters when comparing to DATETIME2 columns.

Under database compatibility level 130, implicit conversions from datetime to datetime2 data types show improved accuracy by accounting for the fractional milliseconds, resulting in different converted values. Use explicit casting to datetime2 datatype whenever a mixed comparison scenario between datetime and datetime2 datatypes exists. For more information, see this Microsoft Support Article .

Breaking changes to Database Engine features in SQL Server 2016

see also this blog

Essentially this is yet another reason to never use AddWithValue, as that sets the parameter type based on the .NET parameter value type, when it should always be set based on the SQL Server column type instead.

To fix just use a DATETIME2 parameter.

weirdCommand.Parameters.Add("@inputDate",System.Data.SqlDbType.DateTime2, 7).Value = found;

Answer 2

Using a DateTime like this is rather unusual and suggest the real problem is something else. From the comments it appears the actual problem is how to delete older records.

The most effective way to do that is to use table partitioning . It's transparent to applications, available in all editions (Express to Enterprise) since SQL Server 2016.

Deletion can be almost instantaneous - you can use partition switching between a full table and an empty one , effectively making the empty partition part of the source table. This is just a metadata operation, making it very fast. You could also move partitions from the live table to an archive table, possibly stored in slower media