BACPAC loader Phases F+G — extended properties + BCP row data. With this bundle, AdventureWorks loads end-to-end through a single Simulation.FromBacpac call: schema + constraints + indexes + views + functions + procedures + triggers + extended properties (Phase F), plus 718K of 760K rows of actual table data (Phase G). Remaining row gap is feature-gated by four wire-format decoders (hierarchyid / geography / xml / MAX types) that the loader cleanly defers to Skipped rather than aborting.

**Phase F — extended properties** in `EmitExtendedProperty`. DACFx encodes the host kind in the element name's leading bracketed segment (`[SqlColumn]` / `[SqlTableBase]` / `[SqlSchema]` / `[SqlDatabaseOptions]` / `[SqlDatabaseDdlTrigger]` / `[SqlFilegroup]`); the emitter resolves each to `sp_addextendedproperty`'s `@level0type` / `@level1type` / `@level2type` arg triplet (SCHEMA / TABLE | VIEW / COLUMN) and uses the existing `viewNames` HashSet to distinguish TABLE vs VIEW level1. Out-of-scope hosts (SqlFilegroup, SqlDatabaseDdlTrigger) plus 9 column/table-level properties whose host columns/tables didn't load (computed-col tables, vJobCandidate-family views) land on Skipped. New shared helpers `SplitBracketedSegments`, `Unbracket`, `TrySplit2Part`, `TrySplit3Part` factor out the bracketed-name parsing. SqlPermissionStatement intentionally Skipped — AW's 2 entries are Always-Encrypted permissions using DACFx integer enum codes (1107/1108) that need a separate enum→T-SQL mapping.

**Phase G — BCP data loader**. New `BcpRowReader` decodes 18 base types directly into `SqlValue[]` rows; `BacpacReader.LoadRowsFromBcp` pokes each row into `HeapTable.Heap` via `RowEncoder.EncodeRow` + `Heap.Insert`, bypassing SQL parsing for the 760K-row hot path. Decoded types: int / bigint / smallint / tinyint / bit, datetime / smalldatetime / date, money / smallmoney, decimal/numeric (BigInteger-based mantissa decode for arbitrary precision), datetime2 / time / datetimeoffset, uniqueidentifier, varchar / nvarchar / nchar / char (bounded), varbinary / binary (bounded). Per-file try/catch surfaces decode failures on Skipped with the exception type + message rather than aborting the whole load.

**Two real probe-confirmed wire-format quirks** (verified via hex-dump of AW's `Sales.SpecialOffer` and `HumanResources.Shift` BCP files on 2026-05-15, both corrections vs. the original prereqs-doc matrix):

1. **UDDT-aliased columns get a 1-byte length prefix even when NOT NULL**, regardless of underlying type. AW's `Sales.SalesOrderHeader.OnlineOrderFlag` (declared via `dbo.Flag` alias = `bit NOT NULL`) encodes as `01 01` (1-byte prefix = 1, then 1 byte value) rather than a single raw bit byte. Threaded through via a new `BacpacLoadResult.TableColumnIsAlias` side map populated during `EmitTable` (via the new `IsAliasTypedColumn` helper that checks `<References ExternalSource="BuiltIns" …>` vs. unmarked refs in the TypeSpecifier's Type relationship) and consumed in `BcpRowReader.TryReadRow`. The fix unblocked 33K rows in AW (685K → 718K loaded).

2. **money / smallmoney / time(N) / datetime2(N) / datetimeoffset(N) are fixed-raw NOT NULL, not always length-prefixed** as the original prereqs-doc matrix claimed. `Sales.SpecialOffer.DiscountPct` smallmoney NOT NULL = 4 raw bytes (no prefix) for value 0; `HumanResources.Shift.StartTime` time(7) NOT NULL = 5 raw bytes (no prefix). Reclassified from `ReadLengthPrefixed1Variable` to `ReadFixedRaw` with width = `TimeSqlType.timeBytes` (3/4/5 by precision) / `DateTime2SqlType.timeBytes + 3` / `DateTimeOffsetSqlType.timeBytes + 5`. NULL handling for these types uses the same `0xFF`-as-NULL 1-byte prefix as int/datetime/etc.

**Loader bug fix in `TranslateSimpleColumn`**: `IsNullable` absent from DACFx means "inherit the column-type's default" (NULL for builtins per ANSI, the alias's stored IsNullable for UDDT-typed columns). Was previously defaulting to True → always emitting `NULL` in the CREATE TABLE column declaration → forcing UDDT-typed columns (where the alias defaults NOT NULL, e.g. `dbo.Flag`) to load as nullable. New `isNullableExplicit` flag tracks the presence/absence distinction; omitting the marker entirely when absent lets the simulator's resolver pick the right default through both paths.

**Loader infrastructure expansion**: `BacpacLoadResult` gains the `TableColumnIsAlias: Dictionary<string, bool[]>` side map keyed by bracketed `[schema].[table]`; per-row-decode bookkeeping adds `ElementCounts["_DataFile"]` (per-shard count) and `ElementCounts["_DataRows"]` (cumulative). `BacpacReader.Load` now does a single pass over all archive entries — model.xml first (existing 7-phase dispatch), then the Data folder iteration for the row pass. New helper `ParseDataFolderName` splits `Data/<schema>.<table>/TableData-NNN-NNNNN.BCP` paths into `(schema, table)` tuples. `RunPhase`'s last-phase counter advances to 8 to cover the new extended-property dispatch.

**Loader pushback stream**: new `PushbackStream` helper class inside `BcpRowReader` peeks the first byte of each row to detect EOF without throwing, then puts the byte back into the decoder pipeline. Required because `Stream.ReadByte` returns -1 at EOF but the column decoders all use `ReadExact` (which throws on premature EOF) — without the pushback the loader couldn't distinguish "end of file" from "torn row."

**AW coverage**: 5/5 schemas, 71/71 tables, 6/6 UDDTs, 71/71 PKs, 1/1 UQ, 90/90 FKs, 89/89 CHECKs, 152/152 DEFAULTs, 89/95 indexes, 11/20 views, 8/10 procs, 10/11 functions, 10/10 DML triggers, 1/1 DDL trigger, 527/538 extended properties, and **718,369/760,167 rows**. Remaining deferrals (all on Skipped with type-named reasons): hierarchyid (HumanResources.Employee.OrganizationNode, Production.Document.DocumentNode), geography (Person.Address.SpatialLocation), xml (Person.Person.Demographics, HumanResources.JobCandidate.Resume), varbinary(MAX) / nvarchar(MAX) (Production.ProductPhoto's photo blobs, etc.).

Author: RyanLamansky

SqlServerSimulator.Tests.Internal/Storage/BacpacLoaderTests.cs

@@ -83,16 +83,18 @@ public void Load_AW_Element_Counts_Match_Probe()
     public void Load_AW_Unhandled_Elements_Recorded_In_Skipped()
     {
         _ = LoadAdventureWorks(out var diagnostics);
-        // Phases A-C handled types are off Skipped; everything else still
-        // appears there awaiting future bundles.
+        // Phases A-F handled types are off Skipped; the few remaining bucket
+        // types (SqlComputedColumn, SqlPermissionStatement, full-text, XML
+        // schema collections / indexes, filegroup-hosted extended properties)
+        // appear awaiting their own 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());
+        IsNotEmpty(diagnostics.Skipped.Where(s => s.ElementType == "SqlPermissionStatement").ToList());
     }
 
     [TestMethod]
@@ -253,6 +255,68 @@ private static int QueryCount(SimulatedDbConnection connection, string sql)
 
     public TestContext TestContext { get; set; } = null!;
 
+    [TestMethod]
+    public void Load_AW_Bcp_Data_Loads()
+    {
+        var simulation = LoadAdventureWorks(out var diagnostics);
+        // AW carries 760,167 rows across 1103 BCP shards. Phase G's
+        // first-cut decoder lands ~718K (94%); the remaining ~42K live in
+        // tables with xml / hierarchyid / geography / varbinary(MAX)
+        // columns whose wire-format decoders are deferred to a follow-up
+        // bundle. Each unloaded shard surfaces on Skipped with the type
+        // that's blocking it.
+        var rowsLoaded = diagnostics.ElementCounts.GetValueOrDefault("_DataRows", 0);
+        IsGreaterThanOrEqualTo(700_000, rowsLoaded, $"expected >= 700K rows, got {rowsLoaded}");
+
+        // Production.ProductCategory's 4 rows must land (no exotic types).
+        using var connection = (SimulatedDbConnection)simulation.CreateDbConnection();
+        connection.Open();
+        AreEqual(4, QueryCount(connection, "SELECT COUNT(*) FROM Production.ProductCategory;"));
+
+        // Sales.SpecialOffer's 16 rows must land (exercises smallmoney +
+        // nullable int + uniqueidentifier + alias-typed dbo.Flag).
+        AreEqual(16, QueryCount(connection, "SELECT COUNT(*) FROM Sales.SpecialOffer;"));
+
+        // The Skipped data files all name their blocking type or feature.
+        var dataFileFailures = diagnostics.Skipped.Where(s => s.ElementType == "_DataFile").ToList();
+        foreach (var entry in dataFileFailures)
+        {
+            IsTrue(entry.Reason.Contains("hierarchyid", StringComparison.OrdinalIgnoreCase)
+                || entry.Reason.Contains("geography", StringComparison.OrdinalIgnoreCase)
+                || entry.Reason.Contains("xml", StringComparison.OrdinalIgnoreCase)
+                || entry.Reason.Contains("MAX", StringComparison.OrdinalIgnoreCase),
+                $"unexpected BCP failure: {entry.ElementName}: {entry.Reason}");
+        }
+    }
+
+    [TestMethod]
+    public void Load_AW_Extended_Properties_Land()
+    {
+        var simulation = LoadAdventureWorks(out var diagnostics);
+        using var connection = (SimulatedDbConnection)simulation.CreateDbConnection();
+        connection.Open();
+        // AW has 538 SqlExtendedProperty elements: 461 column-level + 69
+        // table-level + 5 schema + 1 DB + 1 filegroup + 1 DDL-trigger. The
+        // loader handles SqlColumn / SqlTableBase / SqlSchema /
+        // SqlDatabaseOptions hosts; SqlFilegroup + SqlDatabaseDdlTrigger
+        // hosts are out of scope, and 9 column/table-level properties miss
+        // because their host columns / tables didn't load (computed-col
+        // tables, vJobCandidate-family views, etc.). 527 land in practice.
+        var landed = QueryCount(connection, "SELECT COUNT(*) FROM sys.extended_properties;");
+        IsGreaterThanOrEqualTo(525, landed);
+
+        // The 1 DB-level MS_Description should be present.
+        using var command = connection.CreateCommand();
+        command.CommandText = "SELECT CAST(value AS nvarchar(MAX)) FROM sys.extended_properties WHERE class = 0 AND name = 'MS_Description';";
+        using var reader = command.ExecuteReader();
+        IsTrue(reader.Read());
+        AreEqual("AdventureWorks 2025 Sample OLTP Database", reader.GetString(0));
+
+        // Filegroup + DDL-trigger hosts land on Skipped with the expected reason.
+        var skipped = diagnostics.Skipped.Where(s => s.ElementType == "SqlExtendedProperty").ToList();
+        IsNotEmpty(skipped.Where(s => s.Reason.Contains("SqlFilegroup", StringComparison.Ordinal)).ToList());
+    }
+
     [TestMethod]
     public void Load_AW_Cascade_FK_Has_Correct_Action()
     {

SqlServerSimulator/Storage/Bacpac/BacpacLoadResult.cs

@@ -29,6 +29,16 @@ internal sealed class BacpacLoadResult
 
     /// <summary>Element counts seen during the walk, keyed by element type.</summary>
     internal readonly Dictionary<string, int> ElementCounts = new(StringComparer.Ordinal);
+
+    /// <summary>
+    /// Per-table per-column "declared via UDDT alias" flags, keyed by
+    /// <c>[schema].[table]</c>. UDDT-typed columns get a 1-byte length prefix
+    /// in BCP wire format even when NOT NULL, regardless of the underlying
+    /// type's natural encoding — the BCP decoder needs this distinction to
+    /// align column boundaries correctly. Populated during model.xml
+    /// emission, consumed during the data-load pass.
+    /// </summary>
+    internal readonly Dictionary<string, bool[]> TableColumnIsAlias = new(StringComparer.OrdinalIgnoreCase);
 }
 
 /// <summary>

SqlServerSimulator/Storage/Bacpac/BacpacReader.cs

@@ -39,18 +39,95 @@ public static void Load(Stream stream, Simulation simulation, BacpacLoadResult r
         using (var modelStream = modelEntry.Open())
             ModelXmlReader.Apply(modelStream, simulation, result);
 
-        // Data load deferred to a follow-up phase. The Data/ entries are
-        // enumerated here so the caller sees the inventory in
-        // result.ElementCounts under a synthetic "_DataFile" bucket; the
-        // actual row-decoder pass lands when BcpRowReader is implemented.
+        // Data load pass — iterate every Data/<schema>.<table>/TableData-NNN-NNNNN.BCP
+        // entry, resolve the destination HeapTable, and stream-decode rows
+        // into the simulator's storage via Heap.Insert (bypasses SQL parsing
+        // so the AW 760K-row payload loads in tolerable time).
+        var database = simulation.Databases[Simulation.DefaultDatabaseName];
         foreach (var entry in archive.Entries)
         {
-            if (entry.FullName.StartsWith("Data/", StringComparison.Ordinal)
-                && entry.FullName.EndsWith(".BCP", StringComparison.Ordinal))
+            if (!entry.FullName.StartsWith("Data/", StringComparison.Ordinal)
+                || !entry.FullName.EndsWith(".BCP", StringComparison.Ordinal))
             {
-                _ = result.ElementCounts.TryGetValue("_DataFile", out var current);
-                result.ElementCounts["_DataFile"] = current + 1;
+                continue;
+            }
+
+            _ = result.ElementCounts.TryGetValue("_DataFile", out var current);
+            result.ElementCounts["_DataFile"] = current + 1;
+
+            var (schemaName, tableName) = ParseDataFolderName(entry.FullName);
+            if (!database.Schemas.TryGetValue(schemaName, out var schema)
+                || !schema.HeapTables.TryGetValue(tableName, out var table))
+            {
+                result.Skipped.Add(new BacpacSkipped("_DataFile", entry.FullName,
+                    $"Destination table {schemaName}.{tableName} not found — likely failed to load during DDL phase."));
+                continue;
+            }
+
+            try
+            {
+                using var bcpStream = entry.Open();
+                LoadRowsFromBcp(bcpStream, table, schemaName, tableName, result);
+            }
+            catch (Exception ex) when (ex is InvalidDataException or NotSupportedException
+                or EndOfStreamException or ArgumentOutOfRangeException
+                or ArgumentException or OverflowException or FormatException
+                or IndexOutOfRangeException)
+            {
+                // Best-effort: a single malformed row aborts that file but
+                // doesn't kill the whole load. Each per-file failure lands on
+                // Skipped with the exception type + message so the caller has
+                // a precise inventory.
+                result.Skipped.Add(new BacpacSkipped("_DataFile", entry.FullName,
+                    $"BCP decode failed ({ex.GetType().Name}): {ex.Message}"));
             }
         }
     }
+
+    /// <summary>
+    /// Walks the per-row BCP stream and pokes each row directly into the
+    /// destination heap. Bypasses the simulator's INSERT machinery — no
+    /// IDENTITY allocation (bacpac data carries the original identity
+    /// values), no FK enforcement, no triggers (data is already consistent
+    /// from the source DB).
+    /// </summary>
+    private static void LoadRowsFromBcp(Stream bcpStream, HeapTable table, string schemaName, string tableName, BacpacLoadResult result)
+    {
+        // Look up the per-column alias map populated during model.xml table
+        // emission. Key uses bracketed [schema].[table] form to match the
+        // DACFx name shape; default to empty if missing.
+        var qualifiedKey = $"[{schemaName}].[{tableName}]";
+        var columnIsAlias = result.TableColumnIsAlias.TryGetValue(qualifiedKey, out var flags)
+            ? flags
+            : new bool[table.Columns.Length];
+
+        var rowCount = 0;
+        while (true)
+        {
+            var values = BcpRowReader.TryReadRow(bcpStream, table.Columns, columnIsAlias);
+            if (values is null)
+                break;
+            var rowBytes = RowEncoder.EncodeRow(table.Columns, values, table.Heap);
+            _ = table.Heap.Insert(rowBytes);
+            rowCount++;
+        }
+
+        _ = result.ElementCounts.TryGetValue("_DataRows", out var rowsSoFar);
+        result.ElementCounts["_DataRows"] = rowsSoFar + rowCount;
+    }
+
+    /// <summary>
+    /// Splits <c>Data/&lt;schema&gt;.&lt;table&gt;/TableData-NNN-NNNNN.BCP</c>
+    /// into <c>(schema, table)</c>. The folder name is always two bracketed
+    /// segments separated by a single dot — sub-schema dots aren't a concern
+    /// here since SQL Server schemas can't contain dots in their names.
+    /// </summary>
+    private static (string Schema, string Table) ParseDataFolderName(string entryFullName)
+    {
+        var firstSlash = entryFullName.IndexOf('/', StringComparison.Ordinal);
+        var secondSlash = entryFullName.IndexOf('/', firstSlash + 1);
+        var folder = entryFullName[(firstSlash + 1)..secondSlash];
+        var dot = folder.IndexOf('.', StringComparison.Ordinal);
+        return (folder[..dot], folder[(dot + 1)..]);
+    }
 }