CREATE [UNIQUE] [CLUSTERED | NONCLUSTERED] INDEX … ON table (col [ASC | DESC] [, …]) [INCLUDE (cols)] [WHERE filter] [WITH (options)] + DROP INDEX [IF EXISTS] name ON table [, …] + sys.indexes / sys.index_columns catalog views — closes the largest remaining EF Migrations DDL gap. New Storage/Index.cs (Name / ObjectId / IsUnique / IsClustered / IndexKeyColumn[] / IncludedColumns / Filter) and HeapTable.Indexes list; Simulation.CreateIndex.cs partial routes from the CREATE dispatch (Unique / Clustered / NonClustered / Index keywords) through modifier parsing, column resolution (Msg 1911 missing column), duplicate-name check against both Indexes + KeyConstraints (Msg 1913 with dbo.t qualification), and existing-data validation (Msg 1505 reusing the ALTER-bundle helper, filter-aware so excluded rows don't trigger). WITH (option = value) parsed parens-balanced and discarded (FILLFACTOR / IGNORE_DUP_KEY / ONLINE / etc all accepted, none honored). DROP INDEX routes ahead of the comma-list path in TryParseDrop (different grammar: name ON table), surfaces Msg 3701 St 6 / St 7 for missing-table / missing-index, Msg 3723 with PRIMARY KEY or UNIQUE constraint-kind word when targeting a PK/UQ-backing index, and supports IF EXISTS suppression for the does-not-exist paths only (probe-confirmed: 3723 fires regardless of IF EXISTS). UNIQUE enforcement extends both INSERT (EnforceUniqueIndexes in Simulation.Coerce.cs, called from Simulation.Insert.cs) and UPDATE / MERGE (EnforceUniqueIndexesForUpdate in Simulation.Update.cs, called from Simulation.Update.cs + Simulation.Merge.cs), raising Msg 2601 with the standard dbo.t qualification and key-tuple rendering. Filter-aware on both paths: an index with a WHERE filter only checks rows where the filter evaluates true on both the new row and the existing row being compared — false / UNKNOWN both skip, mirroring SQL Server's filtered-unique-index semantic. sys.indexes (24-column probe-confirmed shape) synthesizes one row per (table, index): PK at index_id=1 type_desc=CLUSTERED is_primary_key=1; tables without a PK emit index_id=0 type_desc=HEAP name=NULL; UQ constraints and user indexes share index_id 2+ in ObjectId order (matches SQL Server's declaration-order behavior); is_unique_constraint distinguishes UQ from CREATE UNIQUE INDEX. sys.index_columns (10-column probe-confirmed shape) emits per-column rows with key_ordinal 1..N for KEY columns and 0 for INCLUDE columns, is_descending_key from the per-column DESC flag, and column_id mapped back from storage ordinal via sys.columns-compatible full-column ordinal. Six new error factories: IndexAlreadyExists (Msg 1913), CannotFindObjectForCreateIndex (Msg 1088), CannotDropIndexDoesNotExist (Msg 3701 with state parameter), ExplicitDropIndexNotAllowed (Msg 3723), ViolationOfUniqueIndex (Msg 2601). 37 new CreateIndexTests cover grammar (UNIQUE / CLUSTERED / NONCLUSTERED / multi-column ASC / DESC / INCLUDE / WHERE filter / WITH options), error paths (1088 / 1505 / 1911 / 1913 / 3701 St 6+7 / 3723 on PK + UQ), filter-aware uniqueness (allows duplicates outside filter, rejects inside, UPDATE doesn't false-trigger across filter-excluded rows), Msg 2601 at INSERT + UPDATE, sys.indexes synthesis (HEAP for no-PK / CLUSTERED for PK / index_id assignment / is_unique_constraint vs is_unique distinction), and sys.index_columns shape. CLAUDE.md gains a trigger-phrase entry; new docs/claude/indexes.md documents the storage shape, enforcement loops, filter-aware semantic, catalog projection, and the four documented fidelity gaps (filter_definition always NULL, CLUSTERED keyword decorative, multiple-CLUSTERED silently accepted, WITH options ignored).

Author: RyanLamansky

CLAUDE.md

@@ -153,6 +153,7 @@ Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger:
 - **Touching `FOREIGN KEY` parsing (`REFERENCES` inline / `FOREIGN KEY (cols) REFERENCES other(cols)` table-level), referential-action wiring (`ON DELETE` / `ON UPDATE` × `NO ACTION` / `CASCADE` / `SET NULL` / `SET DEFAULT`), the FK enforcement loop in `Simulation.ForeignKeys.cs`, the `HeapTable.OutgoingForeignKeys` / `IncomingForeignKeys` lists, cascade-cycle detection (Msg 1785), DROP-TABLE protection (Msg 3726), or `sys.foreign_keys` / `sys.foreign_key_columns`** → [`docs/claude/foreign-keys.md`](docs/claude/foreign-keys.md).
 - **Touching `PERIOD FOR SYSTEM_TIME` / `GENERATED ALWAYS AS ROW START / END [HIDDEN]` / `WITH (SYSTEM_VERSIONING = ON (HISTORY_TABLE = …))` DDL, `ALTER TABLE … SET (SYSTEM_VERSIONING = OFF)`, the auto-created history sibling, `FOR SYSTEM_TIME ALL / AS OF` query syntax, or `HeapTable.PeriodColumns` / `HeapTable.SystemVersioning` / `HeapColumn.GeneratedAs` / `HeapColumn.IsHidden`** → [`docs/claude/temporal-tables.md`](docs/claude/temporal-tables.md).
 - **Touching `ALTER TABLE … ADD CONSTRAINT` (PK / UQ / FK / CHECK / DEFAULT), `ALTER TABLE … DROP CONSTRAINT [IF EXISTS]`, `ALTER TABLE … (CHECK | NOCHECK) CONSTRAINT (ALL | name [,…])` trust toggling, `WITH CHECK` / `WITH NOCHECK`, the existing-data-validation scan, the constraint-name uniqueness check, the atomic multi-drop / multi-toggle pipeline, the `IsDisabled` / `IsNotTrusted` enforcement gates, or `sys.check_constraints` / `sys.key_constraints` / `sys.default_constraints`** → [`docs/claude/alter-table.md`](docs/claude/alter-table.md).
+- **Touching `CREATE [UNIQUE] [CLUSTERED | NONCLUSTERED] INDEX` (with `INCLUDE` / `WHERE` filter / `WITH (options)` clauses), `DROP INDEX [IF EXISTS] name ON table [, …]`, the `HeapTable.Indexes` list, UNIQUE-index enforcement (filter-aware Msg 2601 via `EnforceUniqueIndexes` / `EnforceUniqueIndexesForUpdate`), the PK-or-UQ-name DROP rejection (Msg 3723), or `sys.indexes` / `sys.index_columns`** → [`docs/claude/indexes.md`](docs/claude/indexes.md).
 - **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).
 
 ## Not modeled

SqlServerSimulator.Tests/CreateIndexTests.cs

@@ -84,14 +84,28 @@ internal static SimulatedSqlException CheckConstraintViolation(string constraint
     /// PRIMARY KEY or UNIQUE-constraint key tuple already existed in the
     /// table. SQL Server uses Msg 2627 for both PK and UNIQUE *constraint*
     /// violations (Msg 2601 is for unique-index violations from
-    /// <c>CREATE UNIQUE INDEX</c>, which the simulator doesn't model).
+    /// <c>CREATE UNIQUE INDEX</c>, raised via
+    /// <see cref="ViolationOfUniqueIndex"/>).
     /// <paramref name="kindWord"/> selects between <c>"PRIMARY KEY"</c> and
     /// <c>"UNIQUE KEY"</c>; <paramref name="formattedKeyValues"/> is the
     /// rendered tuple text without enclosing parens (e.g. <c>"1, &lt;NULL&gt;"</c>).
     /// </summary>
     internal static SimulatedSqlException ViolationOfKeyConstraint(string kindWord, string constraintName, string tableName, string formattedKeyValues) =>
         new($"Violation of {kindWord} constraint '{constraintName}'. Cannot insert duplicate key in object 'dbo.{tableName}'. The duplicate key value is ({formattedKeyValues}).", 2627, 14, 1);
 
+    /// <summary>
+    /// Mimics SQL Server error 2601: an INSERT or UPDATE produced a row
+    /// whose key tuple already existed in a <c>CREATE UNIQUE INDEX</c>-
+    /// declared index. Distinct from Msg 2627 (unique <em>constraint</em>
+    /// violation) — same scenario semantically, different error number
+    /// per the surface. Probe-confirmed wording (the trailing
+    /// <c>"The statement has been terminated."</c> phrase is emitted as a
+    /// separate informational line by real SQL Server; the simulator
+    /// folds it into the primary error message).
+    /// </summary>
+    internal static SimulatedSqlException ViolationOfUniqueIndex(string indexName, string qualifiedTableName, string formattedKeyValues) =>
+        new($"Cannot insert duplicate key row in object '{qualifiedTableName}' with unique index '{indexName}'. The duplicate key value is ({formattedKeyValues}).", 2601, 14, 1);
+
     /// <summary>
     /// Mimics SQL Server error 547 on the child side: an <c>INSERT</c> /
     /// <c>UPDATE</c> / <c>MERGE</c> placed a value in a FOREIGN KEY column

SqlServerSimulator/BuiltInResources.cs

@@ -741,4 +741,41 @@ internal static SimulatedSqlException ConstraintReferencedByForeignKey(string co
     /// </summary>
     internal static SimulatedSqlException ConstraintDoesNotExist(string name) =>
         new($"Constraint '{name}' does not exist.", 4917, 16, 0);
+
+    /// <summary>
+    /// Mimics SQL Server error 1913: <c>CREATE INDEX</c> with a name that
+    /// already exists on the target table. Probe-confirmed verbatim
+    /// against SQL Server 2025 — message names the index and the
+    /// qualified table.
+    /// </summary>
+    internal static SimulatedSqlException IndexAlreadyExists(string indexName, string qualifiedTableName) =>
+        new($"The operation failed because an index or statistics with name '{indexName}' already exists on table '{qualifiedTableName}'.", 1913, 16, 1);
+
+    /// <summary>
+    /// Mimics SQL Server error 1088: <c>CREATE INDEX</c> (or any
+    /// catalog-scoped reference) named a target object that doesn't exist.
+    /// Distinct from Msg 208 (which surfaces from DML) — Msg 1088 is the
+    /// CREATE-INDEX / sp_help-shaped diagnostic. State 12 probe-confirmed.
+    /// </summary>
+    internal static SimulatedSqlException CannotFindObjectForCreateIndex(string qualifiedName) =>
+        new($"Cannot find the object \"{qualifiedName}\" because it does not exist or you do not have permissions.", 1088, 16, 12);
+
+    /// <summary>
+    /// Mimics SQL Server error 3701 with the <c>index</c> wording variant:
+    /// <c>DROP INDEX name ON table</c> targeted an index that doesn't
+    /// exist. State 6 when the parent table itself is missing; State 7
+    /// when the table exists but has no such index. Probe-confirmed.
+    /// </summary>
+    internal static SimulatedSqlException CannotDropIndexDoesNotExist(string qualifiedTableName, string indexName, byte state) =>
+        new($"Cannot drop the index '{qualifiedTableName}.{indexName}', because it does not exist or you do not have permission.", 3701, 11, state);
+
+    /// <summary>
+    /// Mimics SQL Server error 3723: <c>DROP INDEX</c> targeted a system
+    /// index that backs a PRIMARY KEY or UNIQUE constraint. Real SQL
+    /// Server forbids dropping the index directly; the caller must
+    /// <c>ALTER TABLE … DROP CONSTRAINT</c> instead. Probe-confirmed
+    /// wording.
+    /// </summary>
+    internal static SimulatedSqlException ExplicitDropIndexNotAllowed(string qualifiedTableName, string indexName, string constraintKindWord) =>
+        new($"An explicit DROP INDEX is not allowed on index '{qualifiedTableName}.{indexName}'. It is being used for {constraintKindWord} constraint enforcement.", 3723, 16, 4);
 }

SqlServerSimulator/Errors/SimulatedSqlException.ConstraintErrors.cs

@@ -44,6 +44,7 @@ enum ContextualKeyword
     Grouping,
     Hidden,
     History_Table,
+    Include,
     Increment,
     Input,
     Instead,

SqlServerSimulator/Errors/SimulatedSqlException.SchemaErrors.cs

@@ -260,6 +260,82 @@ private static void EnforceKeyConstraints(HeapTable destinationTable, SqlValue[]
         }
     }
 
+    /// <summary>
+    /// Walks <see cref="HeapTable.Indexes"/> for every UNIQUE entry and
+    /// raises Msg 2601 on the first key-tuple collision against existing
+    /// rows. When an index has a <c>Index.Filter</c>, only rows for
+    /// which the filter evaluates true on both sides participate in the
+    /// uniqueness check (filtered-unique-index semantic). Mirrors
+    /// <see cref="EnforceKeyConstraints"/>'s linear-scan shape; called
+    /// alongside it after a successful row build.
+    /// </summary>
+    private static void EnforceUniqueIndexes(HeapTable destinationTable, SqlValue[] rowValues, SqlValue[] storedRowValues, BatchContext batch)
+    {
+        if (destinationTable.Indexes.Count == 0)
+            return;
+
+        var hasUnique = false;
+        foreach (var ix in destinationTable.Indexes)
+        {
+            if (ix.IsUnique)
+            {
+                hasUnique = true;
+                break;
+            }
+        }
+        if (!hasUnique)
+            return;
+
+        var storedColumns = destinationTable.StoredColumns;
+        var lobStore = destinationTable.Heap;
+        SqlValue[]? existingRowValues = null;
+        var qualifiedTableName = $"{Database.DefaultSchemaName}.{destinationTable.Name}";
+
+        foreach (var index in destinationTable.Indexes)
+        {
+            if (!index.IsUnique)
+                continue;
+            if (index.Filter is not null && Simulation.EvaluateIndexFilter(index.Filter, destinationTable, rowValues, batch) != true)
+                continue;
+
+            foreach (var rowBytes in destinationTable.Heap.EnumerateRows())
+            {
+                if (index.Filter is { } filter)
+                {
+                    existingRowValues ??= new SqlValue[destinationTable.Columns.Length];
+                    for (var c = 0; c < destinationTable.Columns.Length; c++)
+                    {
+                        var storageOrd = destinationTable.StorageOrdinals[c];
+                        existingRowValues[c] = storageOrd >= 0
+                            ? RowDecoder.DecodeColumn(storedColumns, rowBytes, storageOrd, lobStore)
+                            : SqlValue.Null(destinationTable.Columns[c].Type);
+                    }
+                    if (Simulation.EvaluateIndexFilter(filter, destinationTable, existingRowValues, batch) != true)
+                        continue;
+                }
+
+                var allEqual = true;
+                for (var i = 0; i < index.KeyColumns.Length; i++)
+                {
+                    var ord = index.KeyColumns[i].StorageOrdinal;
+                    var existing = RowDecoder.DecodeColumn(storedColumns, rowBytes, ord, lobStore);
+                    if (!existing.Equals(storedRowValues[ord]))
+                    {
+                        allEqual = false;
+                        break;
+                    }
+                }
+                if (allEqual)
+                {
+                    var key = new SqlValue[index.KeyColumns.Length];
+                    for (var i = 0; i < index.KeyColumns.Length; i++)
+                        key[i] = storedRowValues[index.KeyColumns[i].StorageOrdinal];
+                    throw SimulatedSqlException.ViolationOfUniqueIndex(index.Name, qualifiedTableName, Simulation.FormatIndexKeyValues(key));
+                }
+            }
+        }
+    }
+
     /// <summary>
     /// Renders a key-tuple slot the way SQL Server's Msg 2627 does: NULL as
     /// <c>&lt;NULL&gt;</c>, strings raw (no enclosing quotes), numerics in

SqlServerSimulator/Parser/ContextualKeyword.cs

@@ -27,6 +27,8 @@ private bool TryParseCreate(ParserContext context)
                 return Simulation.TryParseCreateProcedure(context, isAlter: false, createOrAlter: false);
             case ReservedKeyword { Keyword: Keyword.Trigger }:
                 return Simulation.TryParseCreateTrigger(context, isAlter: false, createOrAlter: false);
+            case ReservedKeyword { Keyword: Keyword.Unique or Keyword.Clustered or Keyword.NonClustered or Keyword.Index }:
+                return Simulation.TryParseCreateIndex(context);
             case UnquotedString { ContextualKeyword: ContextualKeyword.Type }:
                 return TryParseCreateType(context);
             case UnquotedString { ContextualKeyword: ContextualKeyword.Sequence }: