Bacpac round-trips XML schema collections: the loader dispatches SqlXmlSchemaCollection elements and binds typed-xml columns from SqlXmlTypeSpecifier's XmlSchemaCollection relationship, and sys.columns.xml_collection_id populates from the column's bound collection instead of constant 0.

Author: RyanLamansky

SqlServerSimulator.Tests/Bacpac/BacpacBuilder.cs

@@ -41,6 +41,7 @@ public sealed partial class BacpacBuilder
     private readonly List<PermissionDef> _permissions = [];
     private readonly List<ViewIndexDef> _viewIndexes = [];
     private readonly List<UserDefinedDataTypeDef> _uddts = [];
+    private readonly List<XmlSchemaCollectionDef> _xmlSchemaCollections = [];
     private readonly List<(string ElementType, string Name)> _silentlySkipped = [];
     private readonly List<(string ElementType, string Name)> _unknownElements = [];
     private string? _dspName;
@@ -243,6 +244,22 @@ public BacpacBuilder UserDefinedDataType(string schemaName, string typeName, str
         return this;
     }
 
+    /// <summary>
+    /// Adds a <c>CREATE XML SCHEMA COLLECTION [schema].[name] AS N'…'</c>
+    /// emission. <paramref name="xsdText"/> is the raw XSD source (no <c>N'…'</c>
+    /// wrapping) — the builder wraps it into the complete T-SQL string literal
+    /// DACFx stores in the <c>SchemaExpression</c> property's CDATA body (N
+    /// prefix, quotes, doubled embedded quotes). Reference the collection from a
+    /// typed-xml column via <see cref="TableBuilder.Column"/>'s
+    /// <c>xmlSchemaCollection</c> argument.
+    /// </summary>
+    public BacpacBuilder XmlSchemaCollection(string schemaName, string collectionName, string xsdText)
+    {
+        _ = _schemas.Add(schemaName);
+        _xmlSchemaCollections.Add(new XmlSchemaCollectionDef(schemaName, collectionName, xsdText));
+        return this;
+    }
+
     /// <summary>
     /// Emits a <c>SqlPartitionFunction</c> element. The loader treats this
     /// as a silent no-op (filegroup-mapping metadata with no semantic effect
@@ -415,6 +432,9 @@ private void WriteModelXml(ZipArchive archive)
         foreach (var uddt in _uddts)
             model.Add(BuildUddtElement(ns, uddt));
 
+        foreach (var xsc in _xmlSchemaCollections)
+            model.Add(BuildXmlSchemaCollectionElement(ns, xsc));
+
         foreach (var seq in _sequences)
             model.Add(BuildSequenceElement(ns, seq));
 
@@ -1077,6 +1097,8 @@ internal sealed record ViewIndexDef(string ViewSchema, string ViewName, string I
 
 internal sealed record UserDefinedDataTypeDef(string SchemaName, string TypeName, string BaseType, bool Nullable);
 
+internal sealed record XmlSchemaCollectionDef(string SchemaName, string CollectionName, string XsdText);
+
 sealed partial class BacpacBuilder
 {
     private static XElement BuildUddtElement(XNamespace ns, UserDefinedDataTypeDef uddt)
@@ -1131,6 +1153,21 @@ private static (string Base, string? Length, string? Precision, string? Scale, b
         return (baseName, null, args[..commaIndex].Trim(), args[(commaIndex + 1)..].Trim(), false);
     }
 
+    private static XElement BuildXmlSchemaCollectionElement(XNamespace ns, XmlSchemaCollectionDef xsc)
+    {
+        // DACFx stores the SchemaExpression as a complete N'…' string literal
+        // in the property's CDATA body — N prefix, surrounding quotes, doubled
+        // embedded quotes. Mirror that so the loader forwards it verbatim into
+        // the AS clause.
+        var literal = "N'" + xsc.XsdText.Replace("'", "''", StringComparison.Ordinal) + "'";
+        return new XElement(ns + "Element",
+            new XAttribute("Type", "SqlXmlSchemaCollection"),
+            new XAttribute("Name", $"[{xsc.SchemaName}].[{xsc.CollectionName}]"),
+            new XElement(ns + "Property",
+                new XAttribute("Name", "SchemaExpression"),
+                new XElement(ns + "Value", new XCData(literal))));
+    }
+
     private static XElement BuildSequenceElement(XNamespace ns, SequenceDef seq)
     {
         var element = new XElement(ns + "Element",

SqlServerSimulator.Tests/Bacpac/BacpacLoaderTests.cs

@@ -1806,4 +1806,57 @@ public void GeographyPolygon_DecodesToPolygonWkt()
         Contains("-122", wkt);
         Contains("47", wkt);
     }
+
+    [TestMethod]
+    public void XmlSchemaCollection_And_TypedXmlColumn_RoundTrip()
+    {
+        // A SqlXmlSchemaCollection element creates the collection in phase 1;
+        // a typed-xml column (SqlXmlTypeSpecifier + XmlSchemaCollection
+        // relationship) binds it so sys.columns.xml_collection_id joins back —
+        // the gap that made AW's re-exported bacpac lose typed xml.
+        const string xsd = "<xsd:schema xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"><xsd:element name=\"Note\" type=\"xsd:string\" /></xsd:schema>";
+        using var bacpac = BacpacBuilder.Create()
+            .XmlSchemaCollection("dbo", "NoteSchema", xsd)
+            .Table("dbo", "Doc", t => t
+                .Column("Id", "int")
+                .Column("Body", "xml", nullable: true, xmlSchemaCollection: "[dbo].[NoteSchema]"))
+            .Build();
+
+        var sim = new Simulation();
+        sim.ImportBacpac(bacpac, out var diag);
+        IsEmpty(diag.Skipped);
+        AreEqual(1, diag.ElementCounts["SqlXmlSchemaCollection"]);
+        // The collection exists in the catalog.
+        AreEqual("NoteSchema", sim.ExecuteScalar("SELECT name FROM sys.xml_schema_collections WHERE name = 'NoteSchema';"));
+        // The typed column's xml_collection_id resolves back to the collection.
+        AreEqual("NoteSchema", sim.ExecuteScalar("""
+            SELECT x.name
+              FROM sys.columns c
+              JOIN sys.tables t ON c.object_id = t.object_id
+              JOIN sys.xml_schema_collections x ON c.xml_collection_id = x.xml_collection_id
+             WHERE t.name = 'Doc' AND c.name = 'Body';
+            """));
+    }
+
+    [TestMethod]
+    public void UntypedXmlColumn_LoadsWith_ZeroXmlCollectionId()
+    {
+        // An untyped xml column carries no XmlSchemaCollection relationship;
+        // sys.columns.xml_collection_id reports the non-nullable 0 default.
+        using var bacpac = BacpacBuilder.Create()
+            .Table("dbo", "Doc", t => t
+                .Column("Id", "int")
+                .Column("Body", "xml", nullable: true))
+            .Build();
+
+        var sim = new Simulation();
+        sim.ImportBacpac(bacpac, out var diag);
+        IsEmpty(diag.Skipped);
+        AreEqual(0, sim.ExecuteScalar("""
+            SELECT c.xml_collection_id
+              FROM sys.columns c
+              JOIN sys.tables t ON c.object_id = t.object_id
+             WHERE t.name = 'Doc' AND c.name = 'Body';
+            """));
+    }
 }

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)
+    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)
     {
-        _columns.Add(new ColumnDef(name, sqlType, nullable, identity, identitySeed, identityIncrement, periodKind, collation, rowGuidCol));
+        _columns.Add(new ColumnDef(name, sqlType, nullable, identity, identitySeed, identityIncrement, periodKind, collation, rowGuidCol, xmlSchemaCollection));
         _order.Add((Computed: false, _columns.Count - 1));
         return this;
     }
@@ -462,12 +462,36 @@ private XElement ColumnElement(XNamespace ns, ColumnDef column)
         if (column.RowGuidCol)
             element.Add(PropertyElement(ns, "IsRowGuidColumn", "True"));
 
+        var typeSpecifier = column.XmlSchemaCollectionRef is { } collectionRef
+            ? XmlTypeSpecifierElement(ns, collectionRef)
+            : TypeSpecifierElement(ns, column.SqlType);
         element.Add(new XElement(ns + "Relationship",
             new XAttribute("Name", "TypeSpecifier"),
-            new XElement(ns + "Entry", TypeSpecifierElement(ns, column.SqlType))));
+            new XElement(ns + "Entry", typeSpecifier)));
         return element;
     }
 
+    /// <summary>
+    /// Emits a <c>SqlXmlTypeSpecifier</c> bound to a schema collection — the
+    /// shape DACFx uses for a typed-xml column (<c>xml([schema].[collection])</c>).
+    /// A <c>Type</c> relationship to the <c>[xml]</c> built-in plus an
+    /// <c>XmlSchemaCollection</c> relationship to the collection reference.
+    /// </summary>
+    private static XElement XmlTypeSpecifierElement(XNamespace ns, string collectionRef) =>
+        new(ns + "Element",
+            new XAttribute("Type", "SqlXmlTypeSpecifier"),
+            new XElement(ns + "Relationship",
+                new XAttribute("Name", "Type"),
+                new XElement(ns + "Entry",
+                    new XElement(ns + "References",
+                        new XAttribute("Name", "[xml]"),
+                        new XAttribute("ExternalSource", "BuiltIns")))),
+            new XElement(ns + "Relationship",
+                new XAttribute("Name", "XmlSchemaCollection"),
+                new XElement(ns + "Entry",
+                    new XElement(ns + "References",
+                        new XAttribute("Name", collectionRef)))));
+
     private static XElement TypeSpecifierElement(XNamespace ns, string sqlType)
     {
         // Bracketed 2-part name → UDDT reference (no ExternalSource, no
@@ -550,7 +574,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);
+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);
 
 /// <summary>Base for constraint declarations accumulated on a table.</summary>
 internal abstract record ConstraintDef(string Name);

SqlServerSimulator.Tests/XmlTests.cs

@@ -83,6 +83,24 @@ public void XmlColumn_WithSchemaCollection_Binds()
         AreEqual("<hi/>", sim.ExecuteScalar("select body from dbo.doc"));
     }
 
+    [TestMethod]
+    public void TypedXmlColumn_SysColumnsXmlCollectionId_JoinsBackToCollection()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("create xml schema collection xsc1 as N'<xsd:schema/>'");
+        _ = sim.ExecuteNonQuery("create table dbo.doc (id int, body xml(xsc1))");
+        // The typed column's sys.columns.xml_collection_id resolves to the
+        // collection through sys.xml_schema_collections (the join DacFx's
+        // reverse-engineering query relies on).
+        AreEqual("xsc1", sim.ExecuteScalar("""
+            select x.name from sys.columns c
+              join sys.xml_schema_collections x on c.xml_collection_id = x.xml_collection_id
+             where c.object_id = object_id('dbo.doc') and c.name = 'body'
+            """));
+        // The untyped id column reports the non-nullable 0 default.
+        AreEqual(0, sim.ExecuteScalar("select xml_collection_id from sys.columns where object_id = object_id('dbo.doc') and name = 'id'"));
+    }
+
     [TestMethod]
     public void XmlColumn_WithContentDiscriminator_Parses()
     {

SqlServerSimulator/BuiltInResources.CoreObjects.cs

@@ -306,10 +306,11 @@ HeapColumn[] ColumnsShape() =>
             new("is_sparse", SqlType.Bit, null, true),
             // Probe-confirmed constants (SQL Server 2025, 2026-07-15) that SMO's
             // SSMS Object-Explorer column / index / key sub-node queries read
-            // off sys.all_columns: no XML documents, XML-schema collections,
-            // column sets, dropped ledger columns, or vector columns are
-            // modeled, so is_xml_document / is_column_set / is_dropped_ledger_column
-            // are 0, xml_collection_id is 0, and the vector_* pair is NULL.
+            // off sys.all_columns: no XML documents, column sets, dropped ledger
+            // columns, or vector columns are modeled, so is_xml_document /
+            // is_column_set / is_dropped_ledger_column are 0 and the vector_*
+            // pair is NULL. xml_collection_id carries the bound schema
+            // collection's id for a typed-xml column (0 when untyped / non-xml).
             new("is_xml_document", SqlType.Bit, null, false),
             new("xml_collection_id", SqlType.Int32, null, false),
             new("is_column_set", SqlType.Bit, null, true),
@@ -370,6 +371,14 @@ SqlValue AnsiPaddedFor(HeapColumn c) =>
             c.Type.SystemTypeId is 165 or 167 or 173 or 175 or 231 or 239 ? trueBit : falseBit;
         SqlValue DefaultObjectIdFor(HeapColumn c) =>
             c.DefaultConstraint is { } df ? SqlValue.FromInt32(df.ObjectId) : zeroInt;
+        // xml_collection_id is the id of the schema collection a typed-xml
+        // column binds (0 for untyped xml and every non-xml column — real SQL
+        // Server's non-nullable-int convention for this column). The binding
+        // lives on HeapColumn.XmlSchemaCollection, set by the xml(collection)
+        // column DDL. View / inline-TVF output columns never carry a binding,
+        // so their rows keep the 0 default below.
+        SqlValue XmlCollectionIdFor(HeapColumn c) =>
+            c.XmlSchemaCollection is { } coll ? SqlValue.FromInt32(coll.Id) : zeroInt;
         // The per-database default collation flows from CurrentDatabase.
         // The captured defaultCollation arg is a legacy fallback; today the
         // active database's CollationName drives the value, with per-column
@@ -404,7 +413,7 @@ SqlValue CollationFor(HeapColumn c) =>
                         CollationFor(col),
                         falseBit,
                         falseBit,
-                        zeroInt,
+                        XmlCollectionIdFor(col),
                         falseBit,
                         falseBit,
                         nullInt,
@@ -545,7 +554,7 @@ SqlValue CollationFor(HeapColumn c) =>
                         CollationFor(col),
                         falseBit,
                         falseBit,
-                        zeroInt,
+                        XmlCollectionIdFor(col),
                         falseBit,
                         falseBit,
                         nullInt,

SqlServerSimulator/Storage/Bacpac/ModelXmlReader.cs

@@ -168,6 +168,7 @@ private static void RunPhase(List<XElement> elements, DbConnection connection, B
                     ("SqlSequence", 1) => Run(() => EmitSequence(element, name, connection)),
                     ("SqlRole", 1) => Run(() => EmitRole(element, name, connection)),
                     ("SqlTableType", 1) => Run(() => EmitTableType(element, name, connection, result)),
+                    ("SqlXmlSchemaCollection", 1) => Run(() => EmitXmlSchemaCollection(element, name, connection)),
                     ("SqlTable", 2) => Run(() => EmitTable(element, name, connection, result, deferredComputedTables)),
                     ("SqlPrimaryKeyConstraint", 3) => Run(() => EmitKeyConstraint(element, name, connection, isPrimary: true)),
                     ("SqlUniqueConstraint", 3) => Run(() => EmitKeyConstraint(element, name, connection, isPrimary: false)),
@@ -251,7 +252,8 @@ private static bool Run(Action action)
     /// </summary>
     private static bool IsHandledByAnotherPhase(string type) => type
         is "SqlDatabaseOptions" or "SqlSchema" or "SqlUserDefinedDataType"
-        or "SqlSequence" or "SqlRole" or "SqlTableType" or "SqlFilegroup"
+        or "SqlSequence" or "SqlRole" or "SqlTableType" or "SqlXmlSchemaCollection"
+        or "SqlFilegroup"
         or "SqlPartitionFunction" or "SqlPartitionScheme" or "SqlColumnStoreIndex"
         or "SqlTable"
         or "SqlPrimaryKeyConstraint" or "SqlUniqueConstraint"
@@ -541,6 +543,32 @@ private static void EmitTableType(XElement element, string? qualifiedName, DbCon
         _ = command.ExecuteNonQuery();
     }
 
+    /// <summary>
+    /// Emits <c>CREATE XML SCHEMA COLLECTION [schema].[name] AS &lt;literal&gt;</c>
+    /// for a <c>SqlXmlSchemaCollection</c> element. The <c>SchemaExpression</c>
+    /// property carries a complete T-SQL string literal in its CDATA body — the
+    /// <c>N'…'</c> prefix, the surrounding quotes, and any doubled embedded
+    /// quotes are all present — so the loader forwards it verbatim into the
+    /// <c>AS</c> clause. Emitted in phase 1 alongside the other type-namespace
+    /// objects (alias types / table types) so any table whose column binds
+    /// <c>xml([schema].[collection])</c> resolves the reference when the table
+    /// is created in phase 2.
+    /// </summary>
+    private static void EmitXmlSchemaCollection(XElement element, string? qualifiedName, DbConnection connection)
+    {
+        if (string.IsNullOrEmpty(qualifiedName))
+            throw new InvalidDataException("bacpac: SqlXmlSchemaCollection element missing Name attribute.");
+
+        var schemaExpression = ReadScriptProperty(element, "SchemaExpression")
+            ?? throw new InvalidDataException($"bacpac: SqlXmlSchemaCollection '{qualifiedName}' missing SchemaExpression.");
+
+        using var command = connection.CreateCommand();
+#pragma warning disable CA2100 // bacpac content is caller-trusted; the loader is a translator, not an end-user input handler
+        command.CommandText = $"CREATE XML SCHEMA COLLECTION {qualifiedName} AS {schemaExpression};";
+#pragma warning restore CA2100
+        _ = command.ExecuteNonQuery();
+    }
+
     /// <summary>
     /// Emits <c>CREATE ROLE [name] [AUTHORIZATION owner]</c> for a
     /// <c>SqlRole</c> element. The <c>Authorizer</c> relationship points at
@@ -908,6 +936,18 @@ private static string TranslateTypeSpecifier(XElement typeSpec)
         // simulator's Schema.AliasTypes lookup runs through the qualified path.
         var renderedTypeName = isBuiltin ? NormalizeBuiltinName(typeName) : typeName;
 
+        // Typed-xml column: a SqlXmlTypeSpecifier carries an XmlSchemaCollection
+        // relationship naming the [schema].[collection] the xml value is bound
+        // to. Emit xml([schema].[collection]) so the column records the binding
+        // (surfaced through sys.columns.xml_collection_id) — the collection was
+        // created in phase 1, ahead of this table. Only the default CONTENT
+        // facet is handled: AW carries no XmlStyle/DOCUMENT property (probe:
+        // zero occurrences), so a DOCUMENT facet would need a separate property
+        // read and CONTENT/DOCUMENT emission here.
+        var xmlCollectionRef = ReadSingleReference(typeSpec, "XmlSchemaCollection");
+        if (xmlCollectionRef is not null)
+            return $"{renderedTypeName}({xmlCollectionRef})";
+
         var isMax = ReadBoolProperty(typeSpec, "IsMax", defaultValue: false);
         var length = ReadStringProperty(typeSpec, "Length");
         var precision = ReadStringProperty(typeSpec, "Precision");