BACPAC loader Phases C+D+E — constraints, indexes, programmable objects. Dispatcher restructured from a bool isPhase1 to a phase int (1-7) driven by a top-level loop in Apply; Skipped-recording deferred to the last phase so each unhandled type reports once. Phase ordering encodes the AW dependency graph: 1=schemas/UDDTs/options, 2=tables, 3=PK/UQ/CHECK/DEFAULT, 4=FK, 5=indexes, 6=views, 7=functions/procs/DML triggers/DDL triggers.

RyanLamansky · RyanLamansky · commit 1809bce9fe11 · 2026-05-15T09:25:52.000-05:00
**New emitters**:
- `EmitKeyConstraint` — shared PK+UQ via an `isPrimary` flag (PK defaults CLUSTERED, UQ defaults NONCLUSTERED). Unnamed UQ constraints (the AW pattern where the auto-generated name lives in a SysCommentsObjectAnnotation rather than the element's Name attribute) drop the `CONSTRAINT name` segment and let the simulator allocate.
- `EmitForeignKeyConstraint` — maps DACFx's `OnDeleteAction`/`OnUpdateAction` integer enum (0=NO ACTION/omitted, 1=CASCADE, 2=SET NULL, 3=SET DEFAULT) via `TranslateReferentialAction`.
- `EmitCheckConstraint` / `EmitDefaultConstraint` — pass the CDATA expression script verbatim to the simulator's already-shipped parsers.
- `EmitIndex` — `CREATE [UNIQUE] [CLUSTERED|NONCLUSTERED] INDEX … ON … (…) [INCLUDE (…)]`; pre-built `viewNames` HashSet lets indexed-view targets skip cleanly (indexed views need SCHEMABINDING machinery the simulator doesn't model). Wrapped in try/catch so indexes referencing not-yet-loaded computed columns degrade to Skipped with the simulator's diagnostic rather than aborting the whole load.
- `EmitProgrammableObject` — universal emitter for views/scalar funcs/multi-stmt TVFs/procs/DML triggers/DDL triggers. Uses the canonical `HeaderContents` from each element's `SysCommentsObjectAnnotation` and concatenates the body (`QueryScript` for views, `BodyScript` everywhere else). Transparently follows the `FunctionBody → SqlScriptFunctionImplementation` indirection for both scalar and multi-statement functions where the annotation lives one level deeper.

**Shared XML helpers** factored out: `ReadScriptProperty` (CDATA body bodies), `ReadSingleReference` (one-Entry relationship → Name), `ReadMultipleReferences` (N-Entry relationship → ordered list), `Leaf` (bracketed leaf of a qualified name — constraint and index names arrive 2-part `[schema].[name]` but ALTER TABLE ADD CONSTRAINT / CREATE INDEX expect the unqualified form).

**Simulator bug fix** — `NOT FOR REPLICATION` in CREATE TRIGGER and CREATE PROCEDURE has been broken since those features shipped: `Replication` is in the reserved `Keyword` enum, so the tokenizer returns it as `ReservedKeyword`, but both parsers were pattern-matching only `UnquotedString { ContextualKeyword: ContextualKeyword.Replication }`. Test coverage missed this because no existing test exercises the `NOT FOR REPLICATION` clause. Patched both sites to accept either token form. Surfaced via 4 AW DML triggers (`HumanResources.dEmployee`, `Person.iuPerson`, `Purchasing.dVendor`, and one more) and 2 AW procs that use the clause.

**AW load coverage after this bundle**: 5/5 schemas, 71/71 tables (with simple columns), 6/6 UDDTs, 71/71 PKs, 1/1 UQ, 90/90 FKs (2 CASCADE), 89/89 CHECKs, 152/152 DEFAULTs, 89/95 indexes (2 indexed-views + 4 computed-col-referencing deferred to Skipped), 11/20 views, 8/10 procs, 10/11 functions, 10/10 DML triggers, 1/1 DDL trigger.

**Documented remaining gaps** on `BacpacLoadResult.Skipped`: CROSS APPLY in `vJobCandidate`-family view bodies (parser rejects); unbracketed UDDT `dbo.Flag` as a procedure parameter type (1-part alias resolution misses on this path); 3 scalar UDFs hit `RETURN`-with-value-in-unsupported-context. Each surfaces as a future simulator-feature bundle rather than a loader concern. Computed columns, extended properties, permissions, full-text catalog/index, and XML schema collections + indexes are all still on Skipped pending their own phases.
diff --git a/SqlServerSimulator.Tests.Internal/Storage/BacpacLoaderTests.cs b/SqlServerSimulator.Tests.Internal/Storage/BacpacLoaderTests.cs
@@ -83,15 +83,191 @@ public void Load_AW_Element_Counts_Match_Probe()
     public void Load_AW_Unhandled_Elements_Recorded_In_Skipped()
     {
         _ = LoadAdventureWorks(out var diagnostics);
-        // Phase A + B handled element types (SqlSchema, SqlDatabaseOptions,
-        // SqlTable, SqlSimpleColumn) are off Skipped; everything else still
+        // Phases A-C handled types are off Skipped; everything else still
         // appears there awaiting future bundles.
         IsNotEmpty(diagnostics.Skipped);
         IsEmpty(diagnostics.Skipped.Where(s => s.ElementType == "SqlTable").ToList());
+        IsEmpty(diagnostics.Skipped.Where(s => s.ElementType == "SqlPrimaryKeyConstraint").ToList());
+        IsEmpty(diagnostics.Skipped.Where(s => s.ElementType == "SqlForeignKeyConstraint").ToList());
+        IsEmpty(diagnostics.Skipped.Where(s => s.ElementType == "SqlCheckConstraint").ToList());
+        IsEmpty(diagnostics.Skipped.Where(s => s.ElementType == "SqlDefaultConstraint").ToList());
         IsNotEmpty(diagnostics.Skipped.Where(s => s.ElementType == "SqlExtendedProperty").ToList());
         IsNotEmpty(diagnostics.Skipped.Where(s => s.ElementType == "SqlComputedColumn").ToList());
     }
 
+    [TestMethod]
+    public void Load_AW_Constraints_Land_On_Tables()
+    {
+        var simulation = LoadAdventureWorks(out _);
+        using var connection = (SimulatedDbConnection)simulation.CreateDbConnection();
+        connection.Open();
+
+        // PK count — every AW table has a PK (71 SqlPrimaryKeyConstraint).
+        using (var command = connection.CreateCommand())
+        {
+            command.CommandText = "SELECT COUNT(*) FROM sys.key_constraints WHERE type = 'PK';";
+            using var reader = command.ExecuteReader();
+            IsTrue(reader.Read());
+            AreEqual(71, reader.GetInt32(0));
+        }
+
+        // UQ count — AW has 1 SqlUniqueConstraint (Production.Document.rowguid).
+        using (var command = connection.CreateCommand())
+        {
+            command.CommandText = "SELECT COUNT(*) FROM sys.key_constraints WHERE type = 'UQ';";
+            using var reader = command.ExecuteReader();
+            IsTrue(reader.Read());
+            AreEqual(1, reader.GetInt32(0));
+        }
+
+        // FK count — 90 SqlForeignKeyConstraint in AW.
+        using (var command = connection.CreateCommand())
+        {
+            command.CommandText = "SELECT COUNT(*) FROM sys.foreign_keys;";
+            using var reader = command.ExecuteReader();
+            IsTrue(reader.Read());
+            AreEqual(90, reader.GetInt32(0));
+        }
+
+        // CHECK count — 89 SqlCheckConstraint in AW.
+        using (var command = connection.CreateCommand())
+        {
+            command.CommandText = "SELECT COUNT(*) FROM sys.check_constraints;";
+            using var reader = command.ExecuteReader();
+            IsTrue(reader.Read());
+            AreEqual(89, reader.GetInt32(0));
+        }
+
+        // DEFAULT count — 152 SqlDefaultConstraint in AW.
+        using (var command = connection.CreateCommand())
+        {
+            command.CommandText = "SELECT COUNT(*) FROM sys.default_constraints;";
+            using var reader = command.ExecuteReader();
+            IsTrue(reader.Read());
+            AreEqual(152, reader.GetInt32(0));
+        }
+    }
+
+    [TestMethod]
+    public void Load_AW_Production_ProductCategory_PK_Wired()
+    {
+        var simulation = LoadAdventureWorks(out _);
+        using var connection = (SimulatedDbConnection)simulation.CreateDbConnection();
+        connection.Open();
+        using var command = connection.CreateCommand();
+        // Production.ProductCategory's PK is named [PK_ProductCategory_ProductCategoryID].
+        command.CommandText = """
+            SELECT kc.name
+              FROM sys.key_constraints kc
+              JOIN sys.tables t ON kc.parent_object_id = t.object_id
+              JOIN sys.schemas s ON t.schema_id = s.schema_id
+             WHERE s.name = 'Production' AND t.name = 'ProductCategory' AND kc.type = 'PK';
+            """;
+        using var reader = command.ExecuteReader();
+        IsTrue(reader.Read());
+        AreEqual("PK_ProductCategory_ProductCategoryID", reader.GetString(0));
+    }
+
+    [TestMethod]
+    public void Load_AW_Indexes_Land()
+    {
+        var simulation = LoadAdventureWorks(out var diagnostics);
+        using var connection = (SimulatedDbConnection)simulation.CreateDbConnection();
+        connection.Open();
+        // AW has 95 SqlIndex elements: 2 target views (deferred — indexed
+        // views need view + SCHEMABINDING machinery), N target computed
+        // columns that aren't loaded yet (deferred until functions land).
+        // Verify the bulk lands and the deferrals are recorded.
+        using var command = connection.CreateCommand();
+        command.CommandText = "SELECT COUNT(*) FROM sys.indexes WHERE name LIKE 'AK[_]%' OR name LIKE 'IX[_]%';";
+        using var reader = command.ExecuteReader();
+        IsTrue(reader.Read());
+        // 89 user indexes land = 95 SqlIndex - 2 view-targeted (deferred:
+        // indexed views need SCHEMABINDING) - 4 that reference computed
+        // columns the loader currently defers until functions land. The 6
+        // deferrals all surface as Skipped entries.
+        AreEqual(89, reader.GetInt32(0));
+        var skippedIndexEntries = diagnostics.Skipped.Where(s => s.ElementType == "SqlIndex").ToList();
+        HasCount(6, skippedIndexEntries);
+        // Both deferral reasons appear in Skipped.
+        IsNotEmpty(skippedIndexEntries.Where(s => s.Reason.Contains("on view '", StringComparison.OrdinalIgnoreCase)).ToList());
+        IsNotEmpty(skippedIndexEntries.Where(s => s.Reason.Contains("CREATE INDEX", StringComparison.OrdinalIgnoreCase) && s.Reason.Contains("failed", StringComparison.OrdinalIgnoreCase)).ToList());
+    }
+
+    [TestMethod]
+    public void Load_AW_Programmable_Counts()
+    {
+        var simulation = LoadAdventureWorks(out var diagnostics);
+        using var connection = (SimulatedDbConnection)simulation.CreateDbConnection();
+        connection.Open();
+
+        // AW counts: 20 views, 10 procs, 10 scalar functions, 1 multi-stmt
+        // TVF, 10 DML triggers, 1 DDL trigger (DDL trigger isn't programmable
+        // in the same sense — deferred). Best-effort load may miss some that
+        // reference computed cols / unsupported features; lower bounds keep
+        // the test green as the loader matures. The Skipped log on the
+        // BacpacLoadResult names the reason for each miss.
+        var views = QueryCount(connection, "SELECT COUNT(*) FROM sys.views;");
+        var procs = QueryCount(connection, "SELECT COUNT(*) FROM sys.procedures;");
+        var funcs = QueryCount(connection, "SELECT COUNT(*) FROM sys.objects WHERE type IN ('FN', 'TF', 'IF');");
+        var triggers = QueryCount(connection, "SELECT COUNT(*) FROM sys.triggers WHERE parent_class = 1;");
+
+        // Current landing rates against AW (probed 2026-05-15). Gaps:
+        //   views: 11/20 — 3 vJobCandidate-family views use CROSS APPLY in
+        //     a shape the simulator's view-body parser rejects; the rest
+        //     reference computed columns (deferred until functions land) or
+        //     other unsupported syntax.
+        //   procs: 8/10 — 2 reject the unbracketed UDDT `dbo.Flag` parameter
+        //     type (1-part alias resolution in proc param list).
+        //   funcs: 10/11 — 3 scalar UDFs hit RETURN-with-value-in-context
+        //     diagnostic; the multi-stmt TVF lands.
+        //   triggers: 10/10 — all DML triggers land after the NOT FOR
+        //     REPLICATION reserved-keyword fix. (1 DDL trigger lands
+        //     separately via SqlDatabaseDdlTrigger.)
+        AreEqual(11, views);
+        AreEqual(8, procs);
+        AreEqual(10, funcs);
+        AreEqual(10, triggers);
+
+        // Any Skipped programmable entries name their reason (helps the
+        // next-phase development checklist).
+        var skippedProgrammable = diagnostics.Skipped
+            .Where(s => s.ElementType is "SqlView" or "SqlScalarFunction"
+                or "SqlMultiStatementTableValuedFunction" or "SqlProcedure" or "SqlDmlTrigger")
+            .ToList();
+        // No assertion on count — may be 0 if all land. Just sanity-check
+        // that the dispatcher routed every element type (none on Skipped
+        // means everything succeeded; >0 means we have a Reason to inspect).
+        foreach (var entry in skippedProgrammable)
+            IsFalse(string.IsNullOrEmpty(entry.Reason), $"empty Reason on Skipped entry {entry}");
+    }
+
+    private static int QueryCount(SimulatedDbConnection connection, string sql)
+    {
+        using var command = connection.CreateCommand();
+        command.CommandText = sql;
+        using var reader = command.ExecuteReader();
+        IsTrue(reader.Read());
+        return reader.GetInt32(0);
+    }
+
+    public TestContext TestContext { get; set; } = null!;
+
+    [TestMethod]
+    public void Load_AW_Cascade_FK_Has_Correct_Action()
+    {
+        var simulation = LoadAdventureWorks(out _);
+        using var connection = (SimulatedDbConnection)simulation.CreateDbConnection();
+        connection.Open();
+        // AW carries 2 FKs with OnDeleteAction=CASCADE on Sales.SalesOrderHeader's
+        // child tables. Verify delete_referential_action=1 (CASCADE) lands.
+        using var command = connection.CreateCommand();
+        command.CommandText = "SELECT COUNT(*) FROM sys.foreign_keys WHERE delete_referential_action = 1;";
+        using var reader = command.ExecuteReader();
+        IsTrue(reader.Read());
+        AreEqual(2, reader.GetInt32(0));
+    }
+
     [TestMethod]
     public void Load_AW_Tables_Land_With_Correct_Column_Counts()
     {
diff --git a/SqlServerSimulator/Simulation/Simulation.CreateProcedure.cs b/SqlServerSimulator/Simulation/Simulation.CreateProcedure.cs
@@ -332,8 +332,15 @@ private static void ParseProcedureWithOptions(ParserContext context)
                     context.MoveNextRequired();
                     break;
                 case ReservedKeyword { Keyword: Keyword.For }:
-                    if (context.GetNextRequired() is not UnquotedString { ContextualKeyword: ContextualKeyword.Replication })
+                    // REPLICATION lives in the reserved Keyword enum, so the
+                    // tokenizer surfaces it as ReservedKeyword — not as the
+                    // ContextualKeyword.Replication UnquotedString form. Accept
+                    // either to survive both classification paths.
+                    if (context.GetNextRequired() is not ReservedKeyword { Keyword: Keyword.Replication }
+                        and not UnquotedString { ContextualKeyword: ContextualKeyword.Replication })
+                    {
                         throw SimulatedSqlException.SyntaxErrorNear(context);
+                    }
                     context.MoveNextRequired();
                     break;
                 default:
diff --git a/SqlServerSimulator/Simulation/Simulation.CreateTrigger.cs b/SqlServerSimulator/Simulation/Simulation.CreateTrigger.cs
@@ -112,8 +112,15 @@ private static bool TryParseCreateTrigger(ParserContext context, bool isAlter, b
         {
             if (context.GetNextRequired() is not ReservedKeyword { Keyword: Keyword.For })
                 throw SimulatedSqlException.SyntaxErrorNear(context);
-            if (context.GetNextRequired() is not UnquotedString { ContextualKeyword: ContextualKeyword.Replication })
+            // REPLICATION lives in the reserved Keyword enum, so the tokenizer
+            // surfaces it as ReservedKeyword — not as the
+            // ContextualKeyword.Replication UnquotedString form. Accept either
+            // to survive both classification paths.
+            if (context.GetNextRequired() is not ReservedKeyword { Keyword: Keyword.Replication }
+                and not UnquotedString { ContextualKeyword: ContextualKeyword.Replication })
+            {
                 throw SimulatedSqlException.SyntaxErrorNear(context);
+            }
             context.MoveNextRequired();
         }
 
diff --git a/SqlServerSimulator/Storage/Bacpac/ModelXmlReader.cs b/SqlServerSimulator/Storage/Bacpac/ModelXmlReader.cs
