release: 2.5.4 — coerce Date↔DateTimeOffset for ORDER/WHERE compare

TryCompare only handled same-kind pairs for Date vs Date and DTO vs
DTO; mixed kinds fell through to the "Cannot order X against Y" throw.
Mailserver's SmtpQueue.ClaimPending hit this every RelayWorker tick
on marivil post-cutover — @now bound as SqlValueKind.Date (DateTime
.UtcNow), next_retry column is DATETIMEOFFSET, comparison crashes the
worker loop.

Fix: coerce both sides to DateTimeOffset on the mixed branch. Force
Utc when a DateTime's Kind is Unspecified — the mailserver schema and
GETUTCDATE default both store UTC, so that's the safe assumption
(matches TypeCoercer.CoerceDateTimeOffset which already accepts Date
as DTO for INSERT). 3 new tests in Phase15CompareDtoTests cover the
mixed comparison both directions plus NULL semantics.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: vkuttyp

Directory.Build.props

@@ -7,6 +7,6 @@
     <Authors>vkuttyp</Authors>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <RepositoryUrl>https://github.com/vkuttyp/CosmoSQLClient-Dotnet</RepositoryUrl>
-    <Version>2.5.3</Version>
+    <Version>2.5.4</Version>
   </PropertyGroup>
 </Project>

src/CosmoSQLClient.CosmoKv/Execution/ExpressionEvaluator.cs

@@ -355,6 +355,26 @@ public static bool TryCompare(SqlValue l, SqlValue r, out int cmp)
             cmp = l.DateTimeOffsetValue.CompareTo(r.DateTimeOffsetValue);
             return true;
         }
+        // Mixed Date / DateTimeOffset — coerce to DateTimeOffset on both sides.
+        // The implicit conversion mirrors TypeCoercer.CoerceDateTimeOffset's
+        // accept-Date-as-DateTimeOffset rule used at INSERT/UPDATE time, so
+        // a WHERE/ORDER BY against a DateTimeOffset column with a plain
+        // DateTime parameter (or vice versa) compares as expected instead
+        // of throwing "Cannot order Date against DateTimeOffset" — caught
+        // by the mailserver's SmtpQueue claim-pending path where @now is
+        // bound as SqlValueKind.Date but next_retry is DATETIMEOFFSET.
+        if ((l.Kind == SqlValueKind.Date && r.Kind == SqlValueKind.DateTimeOffset) ||
+            (l.Kind == SqlValueKind.DateTimeOffset && r.Kind == SqlValueKind.Date))
+        {
+            var lDto = l.Kind == SqlValueKind.DateTimeOffset
+                ? l.DateTimeOffsetValue
+                : new DateTimeOffset(DateTime.SpecifyKind(l.DateValue, DateTimeKind.Utc));
+            var rDto = r.Kind == SqlValueKind.DateTimeOffset
+                ? r.DateTimeOffsetValue
+                : new DateTimeOffset(DateTime.SpecifyKind(r.DateValue, DateTimeKind.Utc));
+            cmp = lDto.CompareTo(rDto);
+            return true;
+        }
         // Guid — byte-wise.
         if (l.Kind == SqlValueKind.Uuid && r.Kind == SqlValueKind.Uuid)
         {

tests/CosmoSQLClient.CosmoKv.Tests/Phase15DateDtoCompareTests.cs

@@ -0,0 +1,104 @@
+using CosmoSQLClient.Core;
+using CosmoSQLClient.CosmoKv;
+
+namespace CosmoSQLClient.CosmoKv.Tests;
+
+/// <summary>
+/// v2.5.4 — mixed Date / DateTimeOffset comparisons. Pre-fix the executor's
+/// TryCompare only matched same-kind pairs (Date↔Date, DTO↔DTO) and threw
+/// "Cannot order Date against DateTimeOffset" on the mixed case. The mail
+/// server's SmtpQueue claim-pending path hit this on every RelayWorker
+/// iteration: column next_retry is DATETIMEOFFSET, but @now was bound as
+/// SqlValueKind.Date (DateTime.UtcNow). Now coerced via DateTimeOffset on
+/// both sides at compare time.
+/// </summary>
+public class Phase15DateDtoCompareTests : IAsyncLifetime
+{
+    private readonly string _dir = Path.Combine(
+        Path.GetTempPath(),
+        "cosmosql-cosmokv-p15-" + Guid.NewGuid().ToString("N"));
+    private CosmoKvConnection? _conn;
+
+    public async Task InitializeAsync()
+    {
+        _conn = await CosmoKvConnection.OpenAsync(
+            new CosmoKvConfiguration { DataSource = _dir });
+        await _conn.ExecuteAsync("""
+            CREATE TABLE Q (
+                Id BIGINT IDENTITY PRIMARY KEY,
+                NextRetry DATETIMEOFFSET NULL,
+                Status NVARCHAR(32) NOT NULL DEFAULT 'pending')
+            """);
+    }
+
+    public async Task DisposeAsync()
+    {
+        if (_conn is not null) await _conn.DisposeAsync();
+        try { if (Directory.Exists(_dir)) Directory.Delete(_dir, recursive: true); } catch { }
+    }
+
+    [Fact]
+    public async Task DateTimeParam_ComparedToDateTimeOffsetColumn_Works()
+    {
+        // Seed three rows with explicit DTO retry times.
+        var t0 = DateTimeOffset.Parse("2026-01-01T00:00:00Z");
+        await _conn!.ExecuteAsync(
+            "INSERT INTO Q (NextRetry) VALUES (@a), (@b), (@c)",
+            new[]
+            {
+                SqlParameter.Named("@a", SqlValue.From(t0)),
+                SqlParameter.Named("@b", SqlValue.From(t0.AddHours(1))),
+                SqlParameter.Named("@c", SqlValue.From(t0.AddHours(2))),
+            });
+
+        // Compare DTO column against DateTime (SqlValueKind.Date) param.
+        // Pre-fix: throws "Cannot order Date against DateTimeOffset".
+        var threshold = t0.AddHours(1).UtcDateTime;   // plain DateTime
+        var rows = await _conn.QueryAsync(
+            "SELECT Id FROM Q WHERE NextRetry <= @now ORDER BY Id",
+            new[] { SqlParameter.Named("@now", SqlValue.From(threshold)) });
+
+        Assert.Equal(2, rows.Count);
+        Assert.Equal(1L, rows[0]["Id"].AsInt());
+        Assert.Equal(2L, rows[1]["Id"].AsInt());
+    }
+
+    [Fact]
+    public async Task DateTimeColumn_ComparedToDateTimeOffsetParam_Works()
+    {
+        // Reverse direction: column is Date (DATETIME2), parameter is DTO.
+        await _conn!.ExecuteAsync("""
+            CREATE TABLE Events (
+                Id BIGINT IDENTITY PRIMARY KEY,
+                Ts DATETIME2 NOT NULL)
+            """);
+        await _conn.ExecuteAsync(
+            "INSERT INTO Events (Ts) VALUES (@a), (@b)",
+            new[]
+            {
+                SqlParameter.Named("@a", SqlValue.From(new DateTime(2026, 1, 1, 10, 0, 0, DateTimeKind.Utc))),
+                SqlParameter.Named("@b", SqlValue.From(new DateTime(2026, 1, 1, 12, 0, 0, DateTimeKind.Utc))),
+            });
+
+        var threshold = DateTimeOffset.Parse("2026-01-01T11:00:00Z");
+        var rows = await _conn.QueryAsync(
+            "SELECT Id FROM Events WHERE Ts < @t",
+            new[] { SqlParameter.Named("@t", SqlValue.From(threshold)) });
+
+        Assert.Single(rows);
+        Assert.Equal(1L, rows[0]["Id"].AsInt());
+    }
+
+    [Fact]
+    public async Task NullDateTimeOffset_StillReturnsNullOnCompare()
+    {
+        // SQL semantics: NULL comparisons return NULL (treated as false in
+        // a WHERE clause). The Date/DTO coercion path must not break this.
+        await _conn!.ExecuteAsync("INSERT INTO Q (NextRetry) VALUES (NULL)");
+        var now = DateTime.UtcNow;
+        var rows = await _conn.QueryAsync(
+            "SELECT Id FROM Q WHERE NextRetry <= @now",
+            new[] { SqlParameter.Named("@now", SqlValue.From(now)) });
+        Assert.Empty(rows);
+    }
+}