Added support for "uniqueidentifier" and related features.

Author: RyanLamansky

CLAUDE.md

@@ -72,7 +72,8 @@ Heavy-hitters someone might assume work but don't. Source and `git log` are the
 - Transactions / locks / MVCC.
 - Row-overflow / LOB pages and the `varchar(MAX)` / `nvarchar(MAX)` / `varbinary(MAX)` types they enable.
 - Decimal / numeric / float / real / money types. (Also blocks fractional-day `cast(0.5 as datetime)`.)
-- `uniqueidentifier`, fixed-length `char(N)` / `nchar(N)` / `binary(N)`, and identity columns.
+- Fixed-length `char(N)` / `nchar(N)` / `binary(N)`, and identity columns.
+- `NEWSEQUENTIALID()` (deferred until `DEFAULT`-clause support exists in `CREATE TABLE`; the function is only valid in that context).
 - Pattern matching (`LIKE`) and `CONVERT`.
 - Cross-category `Promote` for `varchar` ↔ `nvarchar` and integer ↔ string. Only CAST works for those pairs.
 - EF Core compatibility: the SqlServer provider downcasts `DbParameter` to `SqlParameter` for some mappings — `DateTime → date`, `DateTime → smalldatetime`, `DateOnly`, `TimeOnly`, `TimeSpan` all break at SaveChanges. See `SimulatedDbParameter` for the matrix; a `SqlServerSimulator.EFCore` adapter package is planned to close the gap.

SqlServerSimulator.Tests.EFCore/EFCoreUniqueIdentifier.cs

@@ -0,0 +1,112 @@
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Exercises the simulator's <c>uniqueidentifier</c> column support through
+/// EF Core's idiomatic surface — Guid round-trips, nullable handling, WHERE
+/// filtering by Guid, and ordering. EF maps <see cref="Guid"/> to
+/// <c>uniqueidentifier</c> with <c>SqlDbType.UniqueIdentifier</c> as the
+/// default, so unlike the <c>DateOnly</c> / <c>TimeOnly</c> mappings, this
+/// path doesn't trigger the <c>SqlParameter</c>-downcast incompatibility
+/// noted on <see cref="SimulatedDbParameter"/>.
+/// </summary>
+[TestClass]
+public class EFCoreUniqueIdentifier
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    [TestMethod]
+    public void Insert_Guid_RoundTrips()
+    {
+        using var context = new TestDbContext(TestDbContext.CreateDocumentsSimulation());
+
+        var key = Guid.Parse("aabbccdd-eeff-0011-2233-445566778899");
+        _ = context.Documents.Add(new Document { Id = 1, ExternalKey = key });
+        _ = context.SaveChanges();
+
+        Assert.AreEqual(key, context.Documents.Select(d => d.ExternalKey).First());
+    }
+
+    [TestMethod]
+    public async Task InsertAsync_Guid_RoundTrips()
+    {
+        await using var context = new TestDbContext(TestDbContext.CreateDocumentsSimulation());
+
+        var key = Guid.NewGuid();
+        _ = context.Documents.Add(new Document { Id = 1, ExternalKey = key });
+        _ = await context.SaveChangesAsync(this.TestContext.CancellationToken);
+
+        Assert.AreEqual(key, context.Documents.Select(d => d.ExternalKey).First());
+    }
+
+    [TestMethod]
+    public void Insert_NullableGuid_AcceptsNull()
+    {
+        using var context = new TestDbContext(TestDbContext.CreateDocumentsSimulation());
+        _ = context.Documents.Add(new Document { Id = 1, ExternalKey = Guid.NewGuid() });
+        _ = context.SaveChanges();
+
+        Assert.IsNull(context.Documents.Select(d => d.OptionalKey).First());
+    }
+
+    [TestMethod]
+    public void Insert_NullableGuid_AcceptsValue()
+    {
+        using var context = new TestDbContext(TestDbContext.CreateDocumentsSimulation());
+        var optional = Guid.Parse("00000000-0000-0000-0000-000000000001");
+        _ = context.Documents.Add(new Document { Id = 1, ExternalKey = Guid.NewGuid(), OptionalKey = optional });
+        _ = context.SaveChanges();
+
+        Assert.AreEqual(optional, context.Documents.Select(d => d.OptionalKey).First());
+    }
+
+    [TestMethod]
+    public void Where_FiltersByGuidEquality()
+    {
+        using var context = new TestDbContext(TestDbContext.CreateDocumentsSimulation());
+
+        var target = Guid.Parse("aabbccdd-eeff-0011-2233-445566778899");
+        context.Documents.AddRange(
+            new Document { Id = 1, ExternalKey = Guid.Parse("11111111-1111-1111-1111-111111111111") },
+            new Document { Id = 2, ExternalKey = target },
+            new Document { Id = 3, ExternalKey = Guid.Parse("22222222-2222-2222-2222-222222222222") });
+        _ = context.SaveChanges();
+
+        var match = context.Documents.Where(d => d.ExternalKey == target).Select(d => d.Id).Single();
+        Assert.AreEqual(2, match);
+    }
+
+    [TestMethod]
+    public void OrderBy_Guid_UsesSqlServerSortOrder()
+    {
+        // The Where filter on parameterized Guid above goes through EF's
+        // SqlParameter machinery (no string promotion). This test pins the
+        // server-side ORDER BY behavior — bytes 10..15 most significant,
+        // matching real SQL Server's quirky uniqueidentifier sort.
+        using var context = new TestDbContext(TestDbContext.CreateDocumentsSimulation());
+
+        Guid[] ids =
+        [
+            Guid.Parse("00000000-0000-0000-0000-000000000001"),
+            Guid.Parse("00000000-0000-0000-0000-010000000000"),
+            Guid.Parse("00000001-0000-0000-0000-000000000000"),
+        ];
+        for (var i = 0; i < ids.Length; i++)
+            _ = context.Documents.Add(new Document { Id = i + 1, ExternalKey = ids[i] });
+        _ = context.SaveChanges();
+
+        var ordered = context.Documents.OrderBy(d => d.ExternalKey).Select(d => d.ExternalKey).ToArray();
+
+        // Expected per SQL Server's uid sort: byte 10..15 dominates, so
+        // 00000001-... (byte 0 = 0x01, all top bytes 0) ranks before
+        // 00000000-...-000000000001 (byte 15 = 0x01) which ranks before
+        // 00000000-...-010000000000 (byte 10 = 0x01).
+        CollectionAssert.AreEqual(
+            new[]
+            {
+                Guid.Parse("00000001-0000-0000-0000-000000000000"),
+                Guid.Parse("00000000-0000-0000-0000-000000000001"),
+                Guid.Parse("00000000-0000-0000-0000-010000000000"),
+            },
+            ordered);
+    }
+}

SqlServerSimulator.Tests.EFCore/TestDbContext.cs

@@ -67,6 +67,25 @@ internal class Event
 
 }
 
+/// <summary>
+/// Exercises the simulator's <c>uniqueidentifier</c> column support through
+/// EF Core. <see cref="ExternalKey"/> is the natural-key identifier (a
+/// freshly minted <see cref="Guid"/>); <see cref="OptionalKey"/> covers the
+/// nullable column path. Pinning <see cref="Id"/> on a separate
+/// <see cref="int"/> primary key keeps EF's tracker out of the
+/// uniqueidentifier-comparison story so the tests focus on the type itself.
+/// </summary>
+internal class Document
+{
+    public int Id { get; set; }
+
+    [Column(TypeName = "uniqueidentifier")]
+    public Guid ExternalKey { get; set; }
+
+    [Column(TypeName = "uniqueidentifier")]
+    public Guid? OptionalKey { get; set; }
+}
+
 internal class TestDbContext(Simulation simulation) : DbContext
 {
     public Simulation Simulation { get; set; } = simulation;
@@ -87,6 +106,8 @@ protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
 
     public DbSet<Event> Events => Set<Event>();
 
+    public DbSet<Document> Documents => Set<Document>();
+
     public static Simulation CreateDefaultSimulation(params ReadOnlySpan<int> values)
     {
         var simulation = new Simulation();
@@ -126,6 +147,22 @@ Avatar varbinary(64) null
         return simulation;
     }
 
+    public static Simulation CreateDocumentsSimulation()
+    {
+        var simulation = new Simulation();
+        _ = simulation
+            .CreateOpenConnection()
+            .CreateCommand("""
+                create table Documents (
+                    Id int,
+                    ExternalKey uniqueidentifier not null,
+                    OptionalKey uniqueidentifier null
+                )
+                """)
+            .ExecuteNonQuery();
+        return simulation;
+    }
+
     public static Simulation CreateEventsSimulation()
     {
         var simulation = new Simulation();