WWI-Full Phase 1 — partitioning + columnstore as silent skips, Latin1_General_CI_AS joins the recognized-collation whitelist. WideWorldImporters-Full (Microsoft's larger sibling sample to WWI-Standard; same 48 tables + 4.7M rows but with partitioning, columnstore indexes, and one natively-compiled procedure) now loads end-to-end with a single remaining Skipped element (the natively-compiled procedure, deferred to a follow-up bundle). The .vs/WideWorldImporters-Full.bacpac file is gitignored alongside the other two reference bacpacs.

RyanLamansky · RyanLamansky · commit 730d055c8a0a · 2026-05-16T15:22:41.000-05:00
**Loader dispatcher** (`Storage/Bacpac/ModelXmlReader.cs`):
- `SqlPartitionFunction`, `SqlPartitionScheme`, `SqlColumnStoreIndex` join `SqlFilegroup` as phase-1 silent-skip entries. All four are storage-organization decorations with no semantic effect on row-store query results — `PartitionFunction`/`PartitionScheme` define filegroup-mapping boundaries that tables/indexes reference for physical placement, and `ColumnStoreIndex` is a read-optimization shape over the same row data (the simulator's linear-scan secondary indexes don't model column-major vs row-major storage). Surfacing any of them on `Skipped` would create category noise for features whose absence has zero observable effect on query results.
- `IsHandledByAnotherPhase` accept-list extended with the three new types so the dispatcher's "last phase records to Skipped" guard doesn't double-record them on later passes.

**Collation whitelist** (`Collation.cs`):
- `Latin1_General_CI_AS` (the older 80-collation, sibling to the previously-recognized `Latin1_General_100_CI_AS`) added to `Collation.Recognized` with the standard `sys.fn_helpcollations` description. WWI-Full's `Warehouse.VehicleTemperatures` table declares two columns (`VehicleRegistration`, `FullSensorData`) with this collation — previously these surfaced as warnings with the `COLLATE` clause dropped; now they round-trip cleanly through `sys.columns.collation_name`. Same metadata-only contract as the existing entries: comparison/sort/LIKE still route through the default collation.

**Diagnostic-probe finding** (worth recording for the next bundle's design phase):
- WWI-Full and WWI-Standard carry essentially identical row data — the size difference (61MB vs 59MB compressed) is metadata, not workload. So WWI-Full is *not* the larger-workload memory/performance test we anticipated; it's a structural-coverage test. A genuine perf/memory test would need a different sample (or a synthetic one).
- After this bundle, WWI-Full's `Skipped` list contains exactly one element: `Website.RecordColdRoomTemperatures`, a natively-compiled procedure. Its body decoration shape is `WITH NATIVE_COMPILATION = ON, SCHEMABINDING, EXECUTE AS OWNER AS BEGIN ATOMIC WITH (TRANSACTION ISOLATION LEVEL = SNAPSHOT, LANGUAGE = N'us_english') &lt;body&gt; END`. Unblocking it needs both (i) the `WITH NATIVE_COMPILATION = ON` clause in the procedure-header parser (parse-and-discard since the simulator doesn't natively-compile anything), and (ii) the `BEGIN ATOMIC WITH (...)` block which currently raises `NotSupportedException` at dispatch.

**Tests**:
- `SqlServerSimulator.Tests.Internal/Storage/BacpacLoaderTests.cs`: new `LoadWideWorldImportersFull` helper mirroring the WWI-Standard one, plus 3 new test methods — `Load_WWIFull_Loads_All_Tables` (48 tables land), `Load_WWIFull_Known_Gaps_Recorded_In_Skipped` (asserts the partition/columnstore categories don't appear on Skipped AND that exactly 1 SqlProcedure is on Skipped — locks the current census), `Load_WWIFull_Latin1_CI_AS_Columns_Warning_Free` (no `Latin1_General_CI_AS` warnings + the collation lands on `sys.columns.collation_name`).
- `SqlServerSimulator.Tests/CollationMetadataTests.cs`: new public-API smoke test `Column_Collate_Latin1_General_CI_AS_RoundTrips`; existing `FnHelpCollations_ListsRecognized` count 2 → 3.

**Doc updates**:
- `docs/claude/bacpac-prerequisites.md`: new step 12 captures the WWI-Full Phase 1 bundle; new step 13 documents the natively-compiled-procedure body decoration as the sole remaining `Skipped` category; the WWI-discovered gap inventory in step 16 (renumbered from 14) strikes through the partition/columnstore additions.
- `CLAUDE.md`: BACPAC pointer entry extended — WWI-Full now mentioned alongside AW2025 + WWI-Standard with the partition/columnstore silent-skip note.
diff --git a/CLAUDE.md b/CLAUDE.md
@@ -164,7 +164,7 @@ Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger:
 - **Touching `XmlSqlType` (singleton in `Storage/XmlType.cs`, SystemTypeId=241, IsLob=true), `XmlSchemaCollection` storage class + `Schema.XmlSchemaCollections` dict + `Database.AllocateXmlCollectionId` (seeds at 65536 per probe), `HeapColumn.XmlSchemaCollection` per-column binding, the `xml`-recognizing arms of `SqlType.ResolveSimpleKeyword` / `Precedence` / `SystemTypeId`, the `xml(name)` / `xml(CONTENT name)` / `xml(DOCUMENT name)` column-type parsing in `ParseOneColumnIntoLists` (via `PeekIsXmlSchemaArgument` / `ParseXmlSchemaCollectionArgument`), `Simulation.Xml.cs` partial (CREATE XML SCHEMA COLLECTION / DROP XML SCHEMA COLLECTION / CREATE [PRIMARY] XML INDEX / FOR PATH|VALUE|PROPERTY secondary form), the `Xml` contextual keyword + `Keyword.Primary` dispatch in `TryParseCreate`, `XmlIndex` / `XmlSecondaryIndexType` storage on `HeapTable.XmlIndexes`, the `XmlMethodCall` expression in `Parser/Expressions/XmlMethodCall.cs` (closed accept-list of `value` / `nodes` / `query` / `exist` / `modify`, parses cleanly, throws `NotSupportedException` at `Run`), or the `sys.xml_schema_collections` / `sys.xml_indexes` catalog views** → [`docs/claude/bacpac-prerequisites.md`](docs/claude/bacpac-prerequisites.md) (the "`xml` data type + XML schema collections + XML methods + XML indexes" section carries the implementation detail).
 - **Touching `GeographySqlType` / `GeometrySqlType` (singletons in `Storage/SpatialType.cs`, both inherit `SpatialSqlType : SqlType(SqlTypeCategory.String)`, SystemTypeId=240, UserTypeId=130/129, IsLob=true), `SqlValue.FromGeography` / `FromGeometry` factories + the spatial branches in `FromString`, the `geography` / `geometry`-recognizing arms of `SqlType.ResolveSimpleKeyword` / `Precedence` / `SystemTypeId` / `UserTypeId`, the `SpatialMethodCall` expression in `Parser/Expressions/SpatialMethodCall.cs` (broad ~70-name accept-list of OGC + Microsoft-extension methods; parses cleanly + throws `NotSupportedException` at `Run` except `.ToString()` returns the stored WKT), the `SpatialStaticCall` expression in `Parser/Expressions/SpatialStaticCall.cs` (`geography::Parse(wkt)` / `geography::STGeomFromText(wkt, srid)` / `geometry::Point(x, y, srid)` work; other static methods throw), the `::` dispatch for `geography`/`geometry` in `Expression.cs` alongside `hierarchyid::`, the `.ToString()` polymorphic delegation in `HierarchyIdMethodCall.Run` (spatial receivers return WKT through the spatial path), the `SpatialIndex` storage class + `SpatialIndexKind` enum on `HeapTable.SpatialIndexes`, the `Simulation.Spatial.cs` partial (CREATE SPATIAL INDEX with USING / BOUNDING_BOX / GRIDS / CELLS_PER_OBJECT parsing + default tessellation_scheme), the `Spatial` contextual keyword routing in `TryParseCreate`, or the `sys.spatial_indexes` (23-col probe-confirmed) / `sys.spatial_index_tessellations` (16-col probe-confirmed) / `sys.spatial_reference_systems` (6-col, empty seed) catalog views** → [`docs/claude/bacpac-prerequisites.md`](docs/claude/bacpac-prerequisites.md) (the "`geography` / `geometry` data types" section carries the implementation detail).
 - **Adding a new top-level statement parser or changing the dispatch loop's statement-separator rules** → [`docs/claude/grammar.md`](docs/claude/grammar.md) + [`docs/claude/control-flow.md`](docs/claude/control-flow.md).
-- **Working on BACPAC import (`Simulation.FromBacpac(string, out BacpacLoadResult)` + Stream overload, internal until externally consumed) — the model.xml dispatcher in `SqlServerSimulator/Storage/Bacpac/ModelXmlReader.cs` (9 phases: DB options + schemas + UDDTs + **sequences + roles + table types + filegroups (skip)** → tables → constraints → FKs → (unused) → views → programmable objects → **deferred computed columns + indexes** → extended properties → BCP data), the `BacpacReader` + `BcpRowReader` + `HierarchyIdWireDecoder` data path, the `BacpacLoadResult.Skipped` + `ElementCounts` + `Warnings` + `TableColumnIsAlias` diagnostics carriers, the resilient-loader contract (per-element exceptions land on Skipped with `"Load failed: …"` prefix and don't abort the load; computed-column failures use `"Deferred: …"` prefix so the AW guard stays meaningful), the **BCP-filters-computed-columns contract** (`BacpacReader.LoadRowsFromBcp` strips columns with `HeapColumn.Computed != null` before passing to `BcpRowReader`/`RowEncoder` — DACFx-emitted BCP files exclude computed columns from the wire layout regardless of PERSISTED; the loader emits computed columns *without* the PERSISTED qualifier so the simulator recomputes on every read), the wire-format matrix (fixed-raw / 1-byte-prefix / 2-byte-prefix / 8-byte-prefix tiers — see [`docs/claude/bacpac-prerequisites.md`](docs/claude/bacpac-prerequisites.md) "BCP wire format" section)** → [`docs/claude/bacpac-prerequisites.md`](docs/claude/bacpac-prerequisites.md). Loader baseline ships (2026-05-15) with AdventureWorks2025 at **100% row coverage** (760,167 / 760,167; zero BCP-file failures); WideWorldImporters-Standard loads end-to-end with **48/48 tables + 26/26 sequences + 9/9 roles + 4/4 table types + 8/8 computed columns + 42/42 procedures + 94/94 indexes + 3/3 views + 1/1 scalar function + 4.7M rows**, zero remaining Skipped categories — every WWI element type loads (collation metadata stored as declaration via `Database.CollationName`, though comparison semantics still route through the default collation per `Collation.Default`). MAX types (varchar(MAX) / nvarchar(MAX) / varbinary(MAX)) + xml + CLR-UDT family all use the simple inline 8-byte-prefix wire shape (NOT TDS-PLP chunked form); plain `bit` uses 1-byte length prefix regardless of nullability (probe-confirmed via Production.Document.FolderFlag, the sole non-UDDT bit column in AW). Hierarchyid wire decoder covers AW's [0..79] positive-ordinal envelope via a 4-prefix order-preserving prefix code (`01` / `100` / `101` / `110`); negative ordinals + ordinals ≥ 80 + dotted sub-ordinals raise `NotSupportedException` for a follow-up bundle to extend. Geography rows load with `SpatialLocation = NULL` (WKB→WKT decoding deferred).
+- **Working on BACPAC import (`Simulation.FromBacpac(string, out BacpacLoadResult)` + Stream overload, internal until externally consumed) — the model.xml dispatcher in `SqlServerSimulator/Storage/Bacpac/ModelXmlReader.cs` (9 phases: DB options + schemas + UDDTs + **sequences + roles + table types + filegroups (skip)** → tables → constraints → FKs → (unused) → views → programmable objects → **deferred computed columns + indexes** → extended properties → BCP data), the `BacpacReader` + `BcpRowReader` + `HierarchyIdWireDecoder` data path, the `BacpacLoadResult.Skipped` + `ElementCounts` + `Warnings` + `TableColumnIsAlias` diagnostics carriers, the resilient-loader contract (per-element exceptions land on Skipped with `"Load failed: …"` prefix and don't abort the load; computed-column failures use `"Deferred: …"` prefix so the AW guard stays meaningful), the **BCP-filters-computed-columns contract** (`BacpacReader.LoadRowsFromBcp` strips columns with `HeapColumn.Computed != null` before passing to `BcpRowReader`/`RowEncoder` — DACFx-emitted BCP files exclude computed columns from the wire layout regardless of PERSISTED; the loader emits computed columns *without* the PERSISTED qualifier so the simulator recomputes on every read), the wire-format matrix (fixed-raw / 1-byte-prefix / 2-byte-prefix / 8-byte-prefix tiers — see [`docs/claude/bacpac-prerequisites.md`](docs/claude/bacpac-prerequisites.md) "BCP wire format" section)** → [`docs/claude/bacpac-prerequisites.md`](docs/claude/bacpac-prerequisites.md). Loader baseline ships (2026-05-15) with AdventureWorks2025 at **100% row coverage** (760,167 / 760,167; zero BCP-file failures); WideWorldImporters-Standard loads end-to-end with **48/48 tables + 26/26 sequences + 9/9 roles + 4/4 table types + 8/8 computed columns + 42/42 procedures + 94/94 indexes + 3/3 views + 1/1 scalar function + 4.7M rows**, zero remaining Skipped categories — every WWI element type loads (collation metadata stored as declaration via `Database.CollationName`, though comparison semantics still route through the default collation per `Collation.Default`). **WideWorldImporters-Full** (2026-05-16 probe) adds partitioning + columnstore + a natively-compiled procedure onto the same row volume; the loader survives with `SqlPartitionFunction` / `SqlPartitionScheme` / `SqlColumnStoreIndex` as silent skips (storage-organization decorations with no semantic effect on row-store queries, matching `SqlFilegroup`'s pattern). The only remaining Skipped category is one natively-compiled procedure (`Website.RecordColdRoomTemperatures`) whose `WITH NATIVE_COMPILATION = ON … BEGIN ATOMIC` body decoration isn't parsed. MAX types (varchar(MAX) / nvarchar(MAX) / varbinary(MAX)) + xml + CLR-UDT family all use the simple inline 8-byte-prefix wire shape (NOT TDS-PLP chunked form); plain `bit` uses 1-byte length prefix regardless of nullability (probe-confirmed via Production.Document.FolderFlag, the sole non-UDDT bit column in AW). Hierarchyid wire decoder covers AW's [0..79] positive-ordinal envelope via a 4-prefix order-preserving prefix code (`01` / `100` / `101` / `110`); negative ordinals + ordinals ≥ 80 + dotted sub-ordinals raise `NotSupportedException` for a follow-up bundle to extend. Geography rows load with `SpatialLocation = NULL` (WKB→WKT decoding deferred).
 
 ## Not modeled
 
diff --git a/SqlServerSimulator.Tests.Internal/Storage/BacpacLoaderTests.cs b/SqlServerSimulator.Tests.Internal/Storage/BacpacLoaderTests.cs
@@ -48,6 +48,16 @@ private static Simulation LoadWideWorldImporters(out BacpacLoadResult diagnostic
         return Simulation.FromBacpac(path, out diagnostics);
     }
 
+    private static Simulation LoadWideWorldImportersFull(out BacpacLoadResult diagnostics)
+    {
+        var path = ResolveBacpacPath("WideWorldImporters-Full.bacpac");
+        if (string.IsNullOrEmpty(path))
+        {
+            Inconclusive(".vs/WideWorldImporters-Full.bacpac not present in this workspace; skipping WWI-Full smoke test.");
+        }
+        return Simulation.FromBacpac(path, out diagnostics);
+    }
+
     [TestMethod]
     public void Load_AW_Creates_All_Five_Schemas()
     {
@@ -860,4 +870,81 @@ public void Load_WWI_Most_Tables_Loaded()
         // level).
         AreEqual(48, reader.GetInt32(0));
     }
+
+    [TestMethod]
+    public void Load_WWIFull_Loads_All_Tables()
+    {
+        // WWI-Full has the same 48 tables as Standard but adds partitioning,
+        // columnstore, and one native-compiled SP. The partition-aware /
+        // columnstore-aware decoration elements (SqlPartitionFunction,
+        // SqlPartitionScheme, SqlColumnStoreIndex) are skip-with-diagnostic;
+        // the native-compiled SP failure is independently tracked.
+        var simulation = LoadWideWorldImportersFull(out _);
+        using var connection = (SimulatedDbConnection)simulation.CreateDbConnection();
+        connection.Open();
+        using var command = connection.CreateCommand();
+        command.CommandText = "SELECT COUNT(*) FROM sys.tables;";
+        using var reader = command.ExecuteReader();
+        IsTrue(reader.Read());
+        AreEqual(48, reader.GetInt32(0));
+    }
+
+    [TestMethod]
+    public void Load_WWIFull_Known_Gaps_Recorded_In_Skipped()
+    {
+        _ = LoadWideWorldImportersFull(out var diagnostics);
+        var grouped = diagnostics.Skipped.GroupBy(s => s.ElementType)
+            .ToDictionary(g => g.Key, g => g.Count());
+        TestContext.WriteLine("=== WWI-Full Skipped (current) ===");
+        foreach (var kv in grouped.OrderByDescending(k => k.Value))
+            TestContext.WriteLine($"{kv.Value,5}  {kv.Key}");
+
+        // Storage-layout / read-optimization decorations are silent skips,
+        // not Skipped entries (matching SqlFilegroup's pattern). Surfacing
+        // them on Skipped would create category noise for features whose
+        // absence has zero semantic effect on query results.
+        IsFalse(grouped.ContainsKey("SqlColumnStoreIndex"), "Columnstore indexes skip-with-diagnostic; no semantic effect on row-store query results.");
+        IsFalse(grouped.ContainsKey("SqlPartitionFunction"), "Partition functions are filegroup-mapping metadata; skip-with-diagnostic.");
+        IsFalse(grouped.ContainsKey("SqlPartitionScheme"), "Partition schemes are filegroup-mapping metadata; skip-with-diagnostic.");
+
+        // NATIVE_COMPILATION procedure body is the sole remaining loader
+        // gap for WWI-Full (1 procedure: Website.RecordColdRoomTemperatures).
+        // The WITH NATIVE_COMPILATION = ON ... BEGIN ATOMIC body decoration
+        // isn't parsed; the procedure body falls onto Skipped with a
+        // SimulatedSqlException parse failure.
+        IsTrue(grouped.TryGetValue("SqlProcedure", out var procSkipped));
+        AreEqual(1, procSkipped);
+    }
+
+    [TestMethod]
+    public void Load_WWIFull_Latin1_CI_AS_Columns_Warning_Free()
+    {
+        // WWI-Full's Warehouse.VehicleTemperatures table declares two columns
+        // (VehicleRegistration, FullSensorData) with COLLATE Latin1_General_CI_AS.
+        // Before the whitelist entry, this produced 2 Warnings + dropped clauses;
+        // the whitelist entry recognizes the name and the COLLATE clauses land.
+        var simulation = LoadWideWorldImportersFull(out var diagnostics);
+        var collationWarnings = diagnostics.Warnings
+            .Where(w => w.Contains("Latin1_General_CI_AS", StringComparison.Ordinal))
+            .ToList();
+        IsEmpty(collationWarnings);
+
+        // Confirm round-trip via sys.columns.
+        using var connection = (SimulatedDbConnection)simulation.CreateDbConnection();
+        connection.Open();
+        using var command = connection.CreateCommand();
+        command.CommandText = """
+            SELECT c.collation_name
+            FROM sys.columns c
+            JOIN sys.tables t ON c.object_id = t.object_id
+            JOIN sys.schemas s ON t.schema_id = s.schema_id
+            WHERE s.name = 'Warehouse'
+              AND t.name = 'VehicleTemperatures'
+              AND c.name = 'VehicleRegistration';
+            """;
+        using var reader = command.ExecuteReader();
+        IsTrue(reader.Read());
+        AreEqual("Latin1_General_CI_AS", reader.GetString(0));
+    }
+
 }
diff --git a/SqlServerSimulator.Tests/CollationMetadataTests.cs b/SqlServerSimulator.Tests/CollationMetadataTests.cs
@@ -124,9 +124,18 @@ public void Column_Collate_UnrecognizedName_RaisesNotSupported()
 
     [TestMethod]
     public void FnHelpCollations_ListsRecognized()
-        => AreEqual(2, new Simulation().ExecuteScalar(
+        => AreEqual(3, new Simulation().ExecuteScalar(
             "SELECT COUNT(*) FROM sys.fn_helpcollations()"));
 
+    [TestMethod]
+    public void Column_Collate_Latin1_General_CI_AS_RoundTrips()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("CREATE TABLE t (b nvarchar(50) COLLATE Latin1_General_CI_AS)");
+        AreEqual("Latin1_General_CI_AS", sim.ExecuteScalar(
+            "SELECT collation_name FROM sys.columns WHERE name = 'b'"));
+    }
+
     [TestMethod]
     public void FnHelpCollations_ColumnsAreNameAndDescription()
     {
diff --git a/SqlServerSimulator/Collation.cs b/SqlServerSimulator/Collation.cs
@@ -34,6 +34,7 @@ private protected Collation()
         {
             ["SQL_Latin1_General_CP1_CI_AS"] = "Latin1-General, case-insensitive, accent-sensitive, kanatype-insensitive, width-insensitive for Unicode Data, SQL Server Sort Order 52 on Code Page 1252 for non-Unicode Data",
             ["Latin1_General_100_CI_AS"] = "Latin1-General-100, case-insensitive, accent-sensitive, kanatype-insensitive, width-insensitive",
+            ["Latin1_General_CI_AS"] = "Latin1-General, case-insensitive, accent-sensitive, kanatype-insensitive, width-insensitive",
         }.ToFrozenDictionary(StringComparer.OrdinalIgnoreCase);
 
     /// <summary>
diff --git a/SqlServerSimulator/Storage/Bacpac/ModelXmlReader.cs b/SqlServerSimulator/Storage/Bacpac/ModelXmlReader.cs
@@ -129,10 +129,20 @@ private static void RunPhase(List<XElement> elements, DbConnection connection, B
                     // so the per-SqlTable computed-column pass completes
                     // before the first SqlIndex emission runs.
                     ("SqlIndex", 8) => Run(() => EmitIndex(element, name, connection, viewNames, result)),
-                    // Filegroups are storage-layout metadata; the simulator
-                    // has a single in-process heap so they're parse-and-skip.
+                    // Filegroups + partitioning + columnstore are storage-layout
+                    // concerns; the simulator has a single in-process heap so
+                    // all four are parse-and-skip. PartitionFunction /
+                    // PartitionScheme define filegroup-mapping boundaries that
+                    // tables / indexes reference for physical placement (no
+                    // semantic effect when filegroups themselves are skipped).
+                    // ColumnStoreIndex is a read-optimization shape over the
+                    // same row data; the simulator's linear-scan secondary
+                    // indexes don't model column-major vs row-major storage.
                     // Phase 1 placement is fine — no dependencies either way.
                     ("SqlFilegroup", 1) => Run(static () => { }),
+                    ("SqlPartitionFunction", 1) => Run(static () => { }),
+                    ("SqlPartitionScheme", 1) => Run(static () => { }),
+                    ("SqlColumnStoreIndex", 1) => Run(static () => { }),
                     ("SqlExtendedProperty", 9) => Run(() => EmitExtendedProperty(element, name, connection, viewNames, result)),
                     // Permission statements emit after roles + everything-securable
                     // — phase 7 is "everything is in place except extended
@@ -174,6 +184,7 @@ private static bool Run(Action action)
     private static bool IsHandledByAnotherPhase(string type) => type
         is "SqlDatabaseOptions" or "SqlSchema" or "SqlUserDefinedDataType"
         or "SqlSequence" or "SqlRole" or "SqlTableType" or "SqlFilegroup"
+        or "SqlPartitionFunction" or "SqlPartitionScheme" or "SqlColumnStoreIndex"
         or "SqlTable"
         or "SqlPrimaryKeyConstraint" or "SqlUniqueConstraint"
         or "SqlCheckConstraint" or "SqlDefaultConstraint"
diff --git a/docs/claude/bacpac-prerequisites.md b/docs/claude/bacpac-prerequisites.md

Original file line number	Diff line number	Diff line change
`@@ -34,6 +34,7 @@ private protected Collation()`
`34`	`34`	`{`
`35`	`35`	`["SQL_Latin1_General_CP1_CI_AS"] = "Latin1-General, case-insensitive, accent-sensitive, kanatype-insensitive, width-insensitive for Unicode Data, SQL Server Sort Order 52 on Code Page 1252 for non-Unicode Data",`
`36`	`36`	`["Latin1_General_100_CI_AS"] = "Latin1-General-100, case-insensitive, accent-sensitive, kanatype-insensitive, width-insensitive",`
	`37`	`+ ["Latin1_General_CI_AS"] = "Latin1-General, case-insensitive, accent-sensitive, kanatype-insensitive, width-insensitive",`
`37`	`38`	`}.ToFrozenDictionary(StringComparer.OrdinalIgnoreCase);`
`38`	`39`
`39`	`40`	`/// <summary>`