Extended-property values ride sql_variant with per-value base-type fidelity, CREATE TABLE gains ROWGUIDCOL and IDENTITY NOT FOR REPLICATION, all three surfaced through sys.columns.is_rowguidcol / sys.identity_columns.is_not_for_replication / COLUMNPROPERTY.

Author: RyanLamansky

SqlServerSimulator.Tests/Bacpac/BacpacLoaderTests.cs

@@ -1314,10 +1314,11 @@ public void Role_WithAuthorizationOwner_LandsAsCreateRoleAuthorization()
     }
 
     [TestMethod]
-    public void RowGuidColColumn_AddsWarningAndLoadsWithoutClause()
+    public void RowGuidColColumn_LoadsWithClause_SetsIsRowGuidCol()
     {
-        // ROWGUIDCOL is metadata-only — the loader drops the clause and
-        // records a Warning. Exercises the ROWGUIDCOL warning emission path.
+        // ROWGUIDCOL round-trips: the loader emits the clause so
+        // sys.columns.is_rowguidcol reports it (DacFx re-emits
+        // IsRowGuidColumn=True on export). No Skipped, no Warning.
         using var bacpac = BacpacBuilder.Create()
             .Table("dbo", "Tagged", t => t
                 .Column("Id", "int")
@@ -1327,9 +1328,28 @@ public void RowGuidColColumn_AddsWarningAndLoadsWithoutClause()
         var sim = new Simulation();
         sim.ImportBacpac(bacpac, out var diag);
         IsEmpty(diag.Skipped);
-        IsNotEmpty(diag.Warnings.Where(w => w.Contains("ROWGUIDCOL", StringComparison.Ordinal)).ToList());
-        // Column still loads, just without the metadata annotation.
-        AreEqual(1, sim.ExecuteScalar("SELECT COUNT(*) FROM sys.columns WHERE name = 'RowId';"));
+        IsEmpty(diag.Warnings.Where(w => w.Contains("ROWGUIDCOL", StringComparison.Ordinal)).ToList());
+        IsTrue((bool)sim.ExecuteScalar(
+            "SELECT is_rowguidcol FROM sys.columns WHERE object_id = object_id('dbo.Tagged') AND name = 'RowId';")!);
+    }
+
+    [TestMethod]
+    public void IdentityNotForReplicationColumn_LoadsWithClause_SetsFlag()
+    {
+        // IdentityIsNotForReplication round-trips through
+        // sys.identity_columns.is_not_for_replication so DacFx re-emits the
+        // property on export.
+        using var bacpac = BacpacBuilder.Create()
+            .Table("dbo", "Seeded", t => t
+                .Column("Id", "int", identity: true, identityNotForReplication: true)
+                .Column("Val", "int", nullable: true))
+            .Build();
+
+        var sim = new Simulation();
+        sim.ImportBacpac(bacpac, out var diag);
+        IsEmpty(diag.Skipped);
+        IsTrue((bool)sim.ExecuteScalar(
+            "SELECT is_not_for_replication FROM sys.identity_columns WHERE object_id = object_id('dbo.Seeded');")!);
     }
 
     [TestMethod]

SqlServerSimulator.Tests/Bacpac/TableBuilder.cs

@@ -46,9 +46,9 @@ internal TableBuilder(string schemaName, string tableName)
     /// IsNullable=True default, but for test setup NOT NULL is more
     /// useful so explicit assertions on NULL-handling become opt-in.
     /// </summary>
-    public TableBuilder Column(string name, string sqlType, bool nullable = false, bool identity = false, int identitySeed = 1, int identityIncrement = 1, PeriodColumnKind periodKind = PeriodColumnKind.None, string? collation = null, bool rowGuidCol = false, string? xmlSchemaCollection = null)
+    public TableBuilder Column(string name, string sqlType, bool nullable = false, bool identity = false, int identitySeed = 1, int identityIncrement = 1, PeriodColumnKind periodKind = PeriodColumnKind.None, string? collation = null, bool rowGuidCol = false, string? xmlSchemaCollection = null, bool identityNotForReplication = false)
     {
-        _columns.Add(new ColumnDef(name, sqlType, nullable, identity, identitySeed, identityIncrement, periodKind, collation, rowGuidCol, xmlSchemaCollection));
+        _columns.Add(new ColumnDef(name, sqlType, nullable, identity, identitySeed, identityIncrement, periodKind, collation, rowGuidCol, xmlSchemaCollection, identityNotForReplication));
         _order.Add((Computed: false, _columns.Count - 1));
         return this;
     }
@@ -452,6 +452,8 @@ private XElement ColumnElement(XNamespace ns, ColumnDef column)
             element.Add(PropertyElement(ns, "IsIdentity", "True"));
             element.Add(PropertyElement(ns, "IdentitySeed", column.IdentitySeed.ToString(System.Globalization.CultureInfo.InvariantCulture)));
             element.Add(PropertyElement(ns, "IdentityIncrement", column.IdentityIncrement.ToString(System.Globalization.CultureInfo.InvariantCulture)));
+            if (column.IdentityNotForReplication)
+                element.Add(PropertyElement(ns, "IdentityIsNotForReplication", "True"));
         }
         if (column.PeriodKind == PeriodColumnKind.Start)
             element.Add(PropertyElement(ns, "GeneratedAlwaysType", "1"));
@@ -574,7 +576,7 @@ public enum PeriodColumnKind
 }
 
 /// <summary>Column metadata captured by <see cref="TableBuilder.Column"/>.</summary>
-internal readonly record struct ColumnDef(string Name, string SqlType, bool Nullable, bool Identity = false, int IdentitySeed = 1, int IdentityIncrement = 1, PeriodColumnKind PeriodKind = PeriodColumnKind.None, string? Collation = null, bool RowGuidCol = false, string? XmlSchemaCollectionRef = null);
+internal readonly record struct ColumnDef(string Name, string SqlType, bool Nullable, bool Identity = false, int IdentitySeed = 1, int IdentityIncrement = 1, PeriodColumnKind PeriodKind = PeriodColumnKind.None, string? Collation = null, bool RowGuidCol = false, string? XmlSchemaCollectionRef = null, bool IdentityNotForReplication = false);
 
 /// <summary>Base for constraint declarations accumulated on a table.</summary>
 internal abstract record ConstraintDef(string Name);

SqlServerSimulator.Tests/ExtendedPropertyTests.cs

@@ -139,6 +139,34 @@ public void Update_ChangesValue()
             "SELECT CAST(value AS nvarchar(MAX)) FROM sys.extended_properties WHERE name = 'X'"));
     }
 
+    [TestMethod]
+    public void Value_NvarcharInput_SurvivesAsNvarcharBaseType()
+    {
+        // DacFx reads sys.extended_properties.value as sql_variant and scripts
+        // the value with an N-prefix iff its base type is nvarchar. An N'…'
+        // input must round-trip as nvarchar (probe-confirmed on SQL Server 2025:
+        // @value=N'…' stores base type nvarchar).
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery(
+            "EXEC sp_addextendedproperty @name=N'X', @value=N'ünïcode', @level0type=N'SCHEMA', @level0name=N'dbo'");
+        AreEqual("nvarchar", sim.ExecuteScalar(
+            "SELECT SQL_VARIANT_PROPERTY(value, 'BaseType') FROM sys.extended_properties WHERE name = 'X'"));
+        AreEqual("ünïcode", sim.ExecuteScalar(
+            "SELECT CAST(value AS nvarchar(MAX)) FROM sys.extended_properties WHERE name = 'X'"));
+    }
+
+    /// <summary>
+    /// A plain (non-N) literal stores varchar base type — probe-confirmed on
+    /// SQL Server 2025 (@value='plain' → varchar). The value column keeps
+    /// per-cell base types like the real sql_variant.
+    /// </summary>
+    [TestMethod]
+    public void Value_VarcharInput_SurvivesAsVarcharBaseType()
+        => AreEqual("varchar", new Simulation().ExecuteScalar("""
+            EXEC sp_addextendedproperty @name=N'X', @value='plain', @level0type=N'SCHEMA', @level0name=N'dbo';
+            SELECT SQL_VARIANT_PROPERTY(value, 'BaseType') FROM sys.extended_properties WHERE name = 'X'
+            """));
+
     [TestMethod]
     public void Update_OnMissing_RaisesMsg15217()
     {

SqlServerSimulator.Tests/IdentityTests.cs

@@ -279,4 +279,31 @@ insert t (x) values (1),(2)
         _ = s2.ExecuteNonQuery("create table t (id int identity(1,1), x int)");
         AreEqual(1m, s2.ExecuteScalar("select IDENT_CURRENT('t')"));
     }
+
+    [TestMethod]
+    public void NotForReplication_SetsIdentityColumnFlag()
+    {
+        // NOT FOR REPLICATION has no runtime effect (replication isn't modeled);
+        // it round-trips through sys.identity_columns + COLUMNPROPERTY for BACPAC
+        // parity. DacFx reads is_not_for_replication to emit
+        // IdentityIsNotForReplication=True.
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("create table t (id int identity(1,1) not for replication, x int)");
+        IsTrue((bool)sim.ExecuteScalar(
+            "select is_not_for_replication from sys.identity_columns where object_id = object_id('t')")!);
+        AreEqual(1, sim.ExecuteScalar("select COLUMNPROPERTY(object_id('t'), 'id', 'IsIdNotForRepl')"));
+        // Auto-generation still works normally.
+        _ = sim.ExecuteNonQuery("insert t (x) values (10),(20)");
+        AreEqual(2, sim.ExecuteScalar("select id from t where x = 20"));
+    }
+
+    [TestMethod]
+    public void IdentityWithoutNotForReplication_FlagIsZero()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("create table t (id int identity(1,1), x int)");
+        IsFalse((bool)sim.ExecuteScalar(
+            "select is_not_for_replication from sys.identity_columns where object_id = object_id('t')")!);
+        AreEqual(0, sim.ExecuteScalar("select COLUMNPROPERTY(object_id('t'), 'id', 'IsIdNotForRepl')"));
+    }
 }

SqlServerSimulator.Tests/RowGuidColTests.cs

@@ -0,0 +1,52 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Exercises the <c>ROWGUIDCOL</c> column marker: a uniqueidentifier-only,
+/// one-per-table metadata annotation with no runtime effect (the simulator
+/// doesn't model the <c>$ROWGUID</c> pseudo-column). It round-trips through
+/// <c>sys.columns.is_rowguidcol</c> / <c>COLUMNPROPERTY(…, 'IsRowGuidCol')</c>
+/// for BACPAC parity. Errors probed against SQL Server 2025 (2026-07-17):
+/// Msg 2761 (non-uniqueidentifier) and Msg 8196 (duplicate) — both compile-time.
+/// </summary>
+[TestClass]
+public sealed class RowGuidColTests
+{
+    [TestMethod]
+    public void RowGuidCol_SetsSysColumnsFlag()
+        => IsTrue((bool)new Simulation().ExecuteScalar("""
+            create table t (id uniqueidentifier rowguidcol default newid(), x int);
+            select is_rowguidcol from sys.columns where object_id = object_id('t') and name = 'id'
+            """)!);
+
+    [TestMethod]
+    public void RowGuidCol_ColumnProperty_ReportsOne()
+        => AreEqual(1, new Simulation().ExecuteScalar("""
+            create table t (id uniqueidentifier rowguidcol, x int);
+            select COLUMNPROPERTY(object_id('t'), 'id', 'IsRowGuidCol')
+            """));
+
+    [TestMethod]
+    public void NonRowGuidColumn_FlagIsZero()
+        => IsFalse((bool)new Simulation().ExecuteScalar("""
+            create table t (id uniqueidentifier, x int);
+            select is_rowguidcol from sys.columns where object_id = object_id('t') and name = 'id'
+            """)!);
+
+    [TestMethod]
+    public void RowGuidCol_OnNonUniqueIdentifier_RaisesMsg2761()
+    {
+        var ex = new Simulation().AssertSqlError(
+            "create table t (id int rowguidcol)", 2761);
+        Assert.Contains("uniqueidentifier data type", ex.Message);
+    }
+
+    [TestMethod]
+    public void DuplicateRowGuidCol_RaisesMsg8196()
+    {
+        var ex = new Simulation().AssertSqlError(
+            "create table t (a uniqueidentifier rowguidcol, b uniqueidentifier rowguidcol)", 8196);
+        Assert.Contains("Duplicate column specified as ROWGUIDCOL", ex.Message);
+    }
+}

SqlServerSimulator/BuiltInResources.ColumnFamily.cs

@@ -387,7 +387,7 @@ private static IEnumerable<SqlValue[]> EnumerateIdentityColumns(Parser.BatchCont
                         SqlValue.FromInt64(identity.Seed),
                         SqlValue.FromInt64(identity.Increment),
                         identity.Snapshot() is { } last ? SqlValue.FromInt64(last) : nullLast,
-                        falseBit,
+                        SqlValue.FromBoolean(identity.NotForReplication),
                     ];
                 }
             }

SqlServerSimulator/BuiltInResources.CoreObjects.cs

@@ -430,7 +430,7 @@ SqlValue CollationFor(HeapColumn c) =>
                         falseBit,
                         SqlValue.FromBoolean(col.IsHidden),
                         falseBit,
-                        falseBit,
+                        SqlValue.FromBoolean(col.IsRowGuidCol),
                         zeroInt,
                     ];
                 }
@@ -477,7 +477,7 @@ SqlValue CollationFor(HeapColumn c) =>
                         falseBit,
                         SqlValue.FromBoolean(col.IsHidden),
                         falseBit,
-                        falseBit,
+                        SqlValue.FromBoolean(col.IsRowGuidCol),
                         zeroInt,
                     ];
                 }
@@ -524,7 +524,7 @@ SqlValue CollationFor(HeapColumn c) =>
                         falseBit,
                         SqlValue.FromBoolean(col.IsHidden),
                         falseBit,
-                        falseBit,
+                        SqlValue.FromBoolean(col.IsRowGuidCol),
                         zeroInt,
                     ];
                 }
@@ -571,7 +571,7 @@ SqlValue CollationFor(HeapColumn c) =>
                         falseBit,
                         SqlValue.FromBoolean(col.IsHidden),
                         falseBit,
-                        falseBit,
+                        SqlValue.FromBoolean(col.IsRowGuidCol),
                         zeroInt,
                     ];
                 }

SqlServerSimulator/BuiltInResources.Security.cs

@@ -88,17 +88,19 @@ void Sys(string name, HeapColumn[] columns, Func<Parser.BatchContext, Database,
         // attached to schemas / tables / columns / etc. via the
         // sp_addextendedproperty / sp_updateextendedproperty /
         // sp_dropextendedproperty trio. Real SQL Server's `value` column is
-        // typed `sql_variant` — the simulator surfaces it as `nvarchar(MAX)`
-        // since sql_variant isn't modeled; AW's 538 properties are all
-        // nvarchar values so functional fidelity is preserved.
+        // typed `sql_variant`, carrying the base type of the value the sproc
+        // stored (nvarchar for an N'…' literal, varchar for a plain literal).
+        // The simulator surfaces it as sql_variant too so DacFx reads the
+        // base type off the wire and re-scripts the value with the correct
+        // N-prefix on export — a BACPAC round-trip preserves nvarchar.
         Sys("extended_properties",
         [
             new("class", SqlType.TinyInt, null, false),
             new("class_desc", SqlType.SystemName, 60, true),
             new("major_id", SqlType.Int32, null, false),
             new("minor_id", SqlType.Int32, null, false),
             new("name", SqlType.SystemName, 128, false),
-            new("value", NVarcharSqlType.Get(-1, Collation.Baseline, Coercibility.CoercibleDefault), SqlType.MaxLengthSentinel, true),
+            new("value", SqlType.SqlVariant, null, true),
         ], EnumerateSysExtendedProperties);
 
         // sys.database_principals: probe-confirmed shipped subset of columns
@@ -471,10 +473,10 @@ void Sys(string name, HeapColumn[] columns, Func<Parser.BatchContext, Database,
     /// derived from the class number per real SQL Server's enum (0 =
     /// DATABASE, 1 = OBJECT_OR_COLUMN, 3 = SCHEMA — the only classes the
     /// simulator currently emits; others fall through as the string form
-    /// of the class number for forward compat). Value is coerced to
-    /// <c>nvarchar(MAX)</c> since the simulator doesn't model
-    /// <c>sql_variant</c>; for AW's all-nvarchar workload, this is a
-    /// lossless surfacing.
+    /// of the class number for forward compat). Value is surfaced as a
+    /// <c>sql_variant</c> wrapping the stored value's own type, so the value's
+    /// base type (nvarchar vs varchar) survives to <c>SQL_VARIANT_PROPERTY</c>
+    /// and the TDS wire — DacFx reads it to re-script the correct N-prefix.
     /// </summary>
     private static IEnumerable<SqlValue[]> EnumerateSysExtendedProperties(Parser.BatchContext batch, Database database)
     {
@@ -495,7 +497,7 @@ private static IEnumerable<SqlValue[]> EnumerateSysExtendedProperties(Parser.Bat
                 SqlValue.FromInt32(key.MajorId),
                 SqlValue.FromInt32(key.MinorId),
                 SqlValue.FromSystemName(key.Name),
-                kvp.Value.IsNull ? SqlValue.Null(NVarcharSqlType.Get(-1, Collation.Baseline, Coercibility.CoercibleDefault)) : kvp.Value.CoerceTo(NVarcharSqlType.Get(-1, Collation.Baseline, Coercibility.CoercibleDefault)),
+                kvp.Value.IsNull ? SqlValue.Null(SqlType.SqlVariant) : SqlValue.FromVariant(kvp.Value),
             ];
         }
     }

SqlServerSimulator/Errors/SimulatedSqlException.SchemaErrors.cs

@@ -510,6 +510,22 @@ internal static SimulatedSqlException MultipleIdentityColumns(string tableName)
     internal static SimulatedSqlException IdentityInvalidIncrement(string columnName) =>
         new($"Identity column '{columnName}' contains invalid INCREMENT.", 2753, 16, 2);
 
+    /// <summary>
+    /// Mimics SQL Server error 2761: the <c>ROWGUIDCOL</c> property was declared
+    /// on a column whose type isn't <c>uniqueidentifier</c>. Probe-confirmed
+    /// wording / number / state (SQL Server 2025, 2026-07-17).
+    /// </summary>
+    internal static SimulatedSqlException RowGuidColRequiresUniqueIdentifier() =>
+        new("The ROWGUIDCOL property can only be specified on the uniqueidentifier data type.", 2761, 16, 2);
+
+    /// <summary>
+    /// Mimics SQL Server error 8196: more than one column in a table was
+    /// declared with the <c>ROWGUIDCOL</c> property. Probe-confirmed wording /
+    /// number / state (SQL Server 2025, 2026-07-17).
+    /// </summary>
+    internal static SimulatedSqlException MultipleRowGuidColumns() =>
+        new("Duplicate column specified as ROWGUIDCOL.", 8196, 16, 1);
+
     /// <summary>
     /// Mimics SQL Server error 8115's IDENTITY-specific wording: the next
     /// identity value would overflow the column's underlying integer type.

SqlServerSimulator/Parser/Expressions/ColumnProperty.cs

@@ -16,7 +16,10 @@ namespace SqlServerSimulator.Parser.Expressions;
 /// <item><description><c>AllowsNull</c> — 1 / 0 from <see cref="HeapColumn.Nullable"/>.</description></item>
 /// <item><description><c>IsIdentity</c> — 1 / 0 from <see cref="HeapColumn.Identity"/>.</description></item>
 /// <item><description><c>IsComputed</c> — 1 / 0 from <see cref="HeapColumn.Computed"/>.</description></item>
-/// <item><description><c>IsRowGuidCol</c> — always 0 (ROWGUIDCOL not modeled).</description></item>
+/// <item><description><c>IsRowGuidCol</c> — 1 / 0 from <see cref="HeapColumn.IsRowGuidCol"/>.</description></item>
+/// <item><description><c>IsIdNotForRepl</c> — 1 when the column is an IDENTITY
+/// declared NOT FOR REPLICATION, else 0 (0 on non-identity columns, matching
+/// real, probe-confirmed 2026-07-17).</description></item>
 /// <item><description><c>Precision</c> — type-dependent: integer family yields
 /// (decimal-equivalent precision), <c>varchar(N)</c> / <c>nvarchar(N)</c> yield
 /// <c>N</c>, money family yields 19 / 10.</description></item>
@@ -114,10 +117,15 @@ private static (HeapColumn? Column, int Ordinal) FindColumn(HeapTable table, str
             },
             12 => upper switch
             {
-                "ISROWGUIDCOL" => 0,
+                "ISROWGUIDCOL" => column.IsRowGuidCol ? 1 : 0,
                 "USESANSITRIM" => SqlType.IsStringCategory(column.Type) ? 1 : 0,
                 _ => null,
             },
+            14 => upper switch
+            {
+                "ISIDNOTFORREPL" => column.Identity is { NotForReplication: true } ? 1 : 0,
+                _ => null,
+            },
             _ => null,
         };
     }