BuiltInToken introduced to provide a clear pattern for SQL query elements that don't use database collation but have more relaxed parsing rules than keywords.

RyanLamansky · RyanLamansky · commit 87b64dbdd0f2 · 2026-05-21T17:53:12.000-05:00
diff --git a/SqlServerSimulator/BuiltInToken.cs b/SqlServerSimulator/BuiltInToken.cs
@@ -0,0 +1,77 @@
+using System.Globalization;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// String-matcher for T-SQL "built-in token" values — spec-defined fixed
+/// strings that aren't subject to <c>ALTER DATABASE COLLATE</c>. Examples:
+/// the <c>INSERTED</c> / <c>DELETED</c> trigger pseudo-table names; the
+/// <c>OBJECT_ID(..., 'U')</c> type-filter codes (<c>U</c> / <c>FN</c> /
+/// <c>IF</c> / <c>TF</c> / <c>V</c> / <c>P</c>); the
+/// <c>sp_addextendedproperty</c> arg names (<c>@name</c>, <c>@value</c>,
+/// <c>@level0type</c>, ...); and the spec-defined arg values for level
+/// types (<c>SCHEMA</c>, <c>TABLE</c>, <c>VIEW</c>, <c>PROCEDURE</c>,
+/// <c>FUNCTION</c>, <c>TYPE</c>, <c>COLUMN</c>, <c>CONSTRAINT</c>,
+/// <c>INDEX</c>).
+/// </summary>
+/// <remarks>
+/// <para>
+/// Properties: CI + IgnoreKanaType + IgnoreWidth. Behaviorally a subset of
+/// today's <see cref="Collation.Default"/> at the compare level, but
+/// without any of the Collation-class machinery
+/// (<see cref="Collation.Name"/> / <see cref="Collation.Description"/> /
+/// <see cref="Collation.StorageEncoding"/> / coercibility-precedence /
+/// supplementary-character toggle / <c>LIKE</c> case-sensitivity flag) —
+/// none of which apply at fixed-token sites.
+/// </para>
+/// <para>
+/// Probe-confirmed against SQL Server 2025 (2026-05-21) on a CS database
+/// (<c>SQL_Latin1_General_CP1_CS_AS</c>): the sites above continue to
+/// match canonical and wrong-case forms (<c>'u'</c>, <c>inserted</c>,
+/// <c>'ｓchema'</c>, <c>'ｄbo'</c>) even when the database itself is
+/// case-sensitive. By contrast, user identifiers (table / column names,
+/// schema names, catalog views, system proc names,
+/// <c>hierarchyid::</c> / <c>geography::</c> / <c>geometry::</c>
+/// type-prefix dispatch, the <c>dbo</c>/<c>sys</c>/<c>INFORMATION_SCHEMA</c>
+/// reserved-name check) <em>do</em> flip under CS — those route through the
+/// database's identifier collation, not this matcher. See
+/// <c>docs/claude/collations.md</c> for the regime breakdown.
+/// </para>
+/// </remarks>
+internal static class BuiltInToken
+{
+    private static readonly CompareInfo compareInfo = CultureInfo.InvariantCulture.CompareInfo;
+
+    private const CompareOptions Options =
+        CompareOptions.IgnoreCase | CompareOptions.IgnoreKanaType | CompareOptions.IgnoreWidth;
+
+    /// <summary>
+    /// Returns true when <paramref name="x"/> and <paramref name="y"/>
+    /// match under the built-in-token compare options (CI + width- /
+    /// kanatype-insensitive). Both arms accept <see langword="null"/>:
+    /// two nulls are equal; one null + one non-null is not.
+    /// </summary>
+    public static bool Equals(string? x, string? y) =>
+        x is null
+            ? y is null
+            : y is not null && compareInfo.Compare(x, y, Options) == 0;
+
+    /// <summary>
+    /// Returns true when <paramref name="value"/> matches any of
+    /// <paramref name="options"/> under the built-in-token compare options.
+    /// A <see langword="null"/> <paramref name="value"/> returns false —
+    /// the caller is asking "is this one of X/Y/Z?", and a null can't
+    /// match any of those.
+    /// </summary>
+    public static bool EqualsAny(string? value, params ReadOnlySpan<string> options)
+    {
+        if (value is null)
+            return false;
+        foreach (var option in options)
+        {
+            if (compareInfo.Compare(value, option, Options) == 0)
+                return true;
+        }
+        return false;
+    }
+}
diff --git a/SqlServerSimulator/Parser/BatchContext.cs b/SqlServerSimulator/Parser/BatchContext.cs
@@ -1204,12 +1204,12 @@ public bool TryResolveTable(MultiPartName name, [System.Diagnostics.CodeAnalysis
         // (no DDL can target them).
         if (this.TriggerFrame is { } triggerFrame && name.Count == 1)
         {
-            if (Collation.Default.Equals(name.Leaf, "inserted") && triggerFrame.Inserted is { } ins)
+            if (BuiltInToken.Equals(name.Leaf, "inserted") && triggerFrame.Inserted is { } ins)
             {
                 table = ins;
                 return true;
             }
-            if (Collation.Default.Equals(name.Leaf, "deleted") && triggerFrame.Deleted is { } del)
+            if (BuiltInToken.Equals(name.Leaf, "deleted") && triggerFrame.Deleted is { } del)
             {
                 table = del;
                 return true;
diff --git a/SqlServerSimulator/Parser/Expressions/ObjectId.cs b/SqlServerSimulator/Parser/Expressions/ObjectId.cs
@@ -69,14 +69,8 @@ public override SqlValue Run(RuntimeContext runtime)
             // 'IF' (inline table-valued function), 'V' (view), 'P' (stored
             // procedure). Other documented codes (TF / TR / ...) return
             // NULL pending those features.
-            if (!Collation.Default.Equals(typeFilter, "U")
-                && !Collation.Default.Equals(typeFilter, "FN")
-                && !Collation.Default.Equals(typeFilter, "IF")
-                && !Collation.Default.Equals(typeFilter, "V")
-                && !Collation.Default.Equals(typeFilter, "P"))
-            {
+            if (!BuiltInToken.EqualsAny(typeFilter, "U", "FN", "IF", "V", "P"))
                 return SqlValue.Null(SqlType.Int32);
-            }
         }
 
         var nameStr = nameValue.CoerceTo(SqlType.NVarchar).AsString;
@@ -87,19 +81,16 @@ public override SqlValue Run(RuntimeContext runtime)
         // specific filter the function must match that kind (scalar vs.
         // inline TVF vs. multi-statement TVF); without a filter, any kind
         // matches.
-        if (typeFilter is null
-            || Collation.Default.Equals(typeFilter, "FN")
-            || Collation.Default.Equals(typeFilter, "IF")
-            || Collation.Default.Equals(typeFilter, "TF"))
+        if (typeFilter is null || BuiltInToken.EqualsAny(typeFilter, "FN", "IF", "TF"))
         {
             if (runtime.Batch.TryResolveFunction(parsed, out var function))
             {
                 var kindMatches = typeFilter switch
                 {
                     null => true,
-                    _ when Collation.Default.Equals(typeFilter, "FN") => function is ScalarFunction,
-                    _ when Collation.Default.Equals(typeFilter, "IF") => function is InlineTableValuedFunction,
-                    _ when Collation.Default.Equals(typeFilter, "TF") => function is MultiStatementTableValuedFunction,
+                    _ when BuiltInToken.Equals(typeFilter, "FN") => function is ScalarFunction,
+                    _ when BuiltInToken.Equals(typeFilter, "IF") => function is InlineTableValuedFunction,
+                    _ when BuiltInToken.Equals(typeFilter, "TF") => function is MultiStatementTableValuedFunction,
                     _ => false,
                 };
                 if (kindMatches)
@@ -111,7 +102,7 @@ _ when Collation.Default.Equals(typeFilter, "TF") => function is MultiStatementT
 
         // 'V' / no filter: try view resolution before falling through to
         // tables. With a specific 'V' filter, a table miss returns NULL.
-        if (typeFilter is null || Collation.Default.Equals(typeFilter, "V"))
+        if (typeFilter is null || BuiltInToken.Equals(typeFilter, "V"))
         {
             if (runtime.Batch.TryResolveView(parsed, out var view))
                 return SqlValue.FromInt32(view.ObjectId);
@@ -122,7 +113,7 @@ _ when Collation.Default.Equals(typeFilter, "TF") => function is MultiStatementT
         // 'P' / no filter: try procedure resolution. Procs share the
         // object-name namespace with tables / views / functions, so the
         // no-filter form falls through here too.
-        if (typeFilter is null || Collation.Default.Equals(typeFilter, "P"))
+        if (typeFilter is null || BuiltInToken.Equals(typeFilter, "P"))
         {
             if (runtime.Batch.TryResolveProcedure(parsed, out var procedure))
                 return SqlValue.FromInt32(procedure.ObjectId);
diff --git a/SqlServerSimulator/Parser/MultiPartName.cs b/SqlServerSimulator/Parser/MultiPartName.cs
@@ -103,7 +103,7 @@ public MultiPartName WithAddedPart(string next)
     /// <c>schema.table.col</c>, the table in <c>db.schema.table.col</c> —
     /// or <see langword="null"/> when the reference is unqualified
     /// (<see cref="Count"/> == 1). Use with
-    /// <c>Collation.Default.Equals(name.ImmediateQualifier, "INSERTED")</c>
+    /// <c>BuiltInToken.Equals(name.ImmediateQualifier, "INSERTED")</c>
     /// shape: the equality check folds the null-or-unqualified case into a
     /// <c>false</c> result without a separate guard.
     /// </summary>
diff --git a/SqlServerSimulator/Parser/Selection.ListExtendedProperty.cs b/SqlServerSimulator/Parser/Selection.ListExtendedProperty.cs
@@ -152,12 +152,12 @@ private static IEnumerable<byte[]> EnumerateListExtendedPropertyRows(
             f.ClassFilter = 0;
             return f;
         }
-        if (!Collation.Default.Equals(l0Type, "SCHEMA"))
+        if (!BuiltInToken.Equals(l0Type, "SCHEMA"))
             throw new NotSupportedException($"fn_listextendedproperty level0type '{l0Type}' isn't modeled (only SCHEMA / NULL).");
         if (l0Name is null)
             return null;
         if (!batch.CurrentDatabase.Schemas.TryGetValue(l0Name, out var schema)
-            && !Collation.Default.Equals(l0Name, "default"))
+            && !BuiltInToken.Equals(l0Name, "default"))
         {
             return null;
         }
@@ -176,7 +176,7 @@ private static IEnumerable<byte[]> EnumerateListExtendedPropertyRows(
         // 'default' wildcard fans out across every object of that kind in
         // the parent schema.
         SchemaObject? l1Obj = null;
-        if (schema is not null && !Collation.Default.Equals(l1Name, "default"))
+        if (schema is not null && !BuiltInToken.Equals(l1Name, "default"))
         {
             Span<char> l1Kind = stackalloc char[l1Type.Length];
             _ = l1Type.ToUpperInvariant(l1Kind);
@@ -203,14 +203,14 @@ private static IEnumerable<byte[]> EnumerateListExtendedPropertyRows(
         }
         if (l2Name is null)
             return null;
-        if (!Collation.Default.Equals(l2Type, "COLUMN"))
+        if (!BuiltInToken.Equals(l2Type, "COLUMN"))
             throw new NotSupportedException($"fn_listextendedproperty level2type '{l2Type}' isn't modeled (only COLUMN).");
 
         f.ClassFilter = 1;
         if (l1Obj is HeapTable table)
         {
             f.MajorIdFilter = table.ObjectId;
-            if (!Collation.Default.Equals(l2Name, "default"))
+            if (!BuiltInToken.Equals(l2Name, "default"))
             {
                 for (var i = 0; i < table.Columns.Length; i++)
                 {
diff --git a/SqlServerSimulator/Simulation/Simulation.ExtendedProperties.cs b/SqlServerSimulator/Simulation/Simulation.ExtendedProperties.cs
@@ -65,29 +65,29 @@ private static IEnumerable<SimulatedStatementOutcome> InvokeSpExtendedProperty(B
                 throw SimulatedSqlException.InvalidExtendedPropertyParameter(procLabel);
             switch (arg.Name)
             {
-                case var n when Collation.Default.Equals(n, "name"):
+                case var n when BuiltInToken.Equals(n, "name"):
                     name = ExpectStringArg(arg.Value);
                     break;
-                case var n when Collation.Default.Equals(n, "value"):
+                case var n when BuiltInToken.Equals(n, "value"):
                     value = arg.Value;
                     hasValueArg = true;
                     break;
-                case var n when Collation.Default.Equals(n, "level0type"):
+                case var n when BuiltInToken.Equals(n, "level0type"):
                     level0Type = ExpectStringArgOrNull(arg.Value);
                     break;
-                case var n when Collation.Default.Equals(n, "level0name"):
+                case var n when BuiltInToken.Equals(n, "level0name"):
                     level0Name = ExpectStringArgOrNull(arg.Value);
                     break;
-                case var n when Collation.Default.Equals(n, "level1type"):
+                case var n when BuiltInToken.Equals(n, "level1type"):
                     level1Type = ExpectStringArgOrNull(arg.Value);
                     break;
-                case var n when Collation.Default.Equals(n, "level1name"):
+                case var n when BuiltInToken.Equals(n, "level1name"):
                     level1Name = ExpectStringArgOrNull(arg.Value);
                     break;
-                case var n when Collation.Default.Equals(n, "level2type"):
+                case var n when BuiltInToken.Equals(n, "level2type"):
                     level2Type = ExpectStringArgOrNull(arg.Value);
                     break;
-                case var n when Collation.Default.Equals(n, "level2name"):
+                case var n when BuiltInToken.Equals(n, "level2name"):
                     level2Name = ExpectStringArgOrNull(arg.Value);
                     break;
                 default:
@@ -161,7 +161,7 @@ private static (ExtendedPropertyKey Key, string TargetLabel) ResolveExtendedProp
             // call with all 6 level args absent).
             return (new ExtendedPropertyKey(0, 0, 0, propertyName), "object specified");
         }
-        if (!Collation.Default.Equals(level0Type, "SCHEMA"))
+        if (!BuiltInToken.Equals(level0Type, "SCHEMA"))
             throw SimulatedSqlException.InvalidExtendedPropertyParameter(procLabel);
         if (level0Name is null)
             throw SimulatedSqlException.InvalidExtendedPropertyParameter(procLabel);
@@ -179,23 +179,23 @@ private static (ExtendedPropertyKey Key, string TargetLabel) ResolveExtendedProp
         // level1 kinds — anything else raises Msg 15600 (real SQL Server's
         // grammar accepts more but AW only uses these five).
         SchemaObject? obj = null;
-        if (Collation.Default.Equals(level1Type, "TABLE"))
+        if (BuiltInToken.Equals(level1Type, "TABLE"))
         {
             if (schema.HeapTables.TryGetValue(level1Name, out var t)) obj = t;
         }
-        else if (Collation.Default.Equals(level1Type, "VIEW"))
+        else if (BuiltInToken.Equals(level1Type, "VIEW"))
         {
             if (schema.Views.TryGetValue(level1Name, out var v)) obj = v;
         }
-        else if (Collation.Default.Equals(level1Type, "PROCEDURE"))
+        else if (BuiltInToken.Equals(level1Type, "PROCEDURE"))
         {
             if (schema.Procedures.TryGetValue(level1Name, out var p)) obj = p;
         }
-        else if (Collation.Default.Equals(level1Type, "FUNCTION"))
+        else if (BuiltInToken.Equals(level1Type, "FUNCTION"))
         {
             if (schema.Functions.TryGetValue(level1Name, out var f)) obj = f;
         }
-        else if (Collation.Default.Equals(level1Type, "TYPE"))
+        else if (BuiltInToken.Equals(level1Type, "TYPE"))
         {
             // TYPE-level extended properties target alias or table types.
             // The object_id is the table-type's, alias types don't carry one.
@@ -219,7 +219,7 @@ private static (ExtendedPropertyKey Key, string TargetLabel) ResolveExtendedProp
         if (obj is not HeapTable table)
             throw SimulatedSqlException.ExtendedPropertyTargetMissing($"{schema.Name}.{obj.Name}.{level2Name}");
 
-        if (Collation.Default.Equals(level2Type, "COLUMN"))
+        if (BuiltInToken.Equals(level2Type, "COLUMN"))
         {
             // 1-based column ordinal (real SQL Server's minor_id convention).
             for (var i = 0; i < table.Columns.Length; i++)
@@ -230,7 +230,7 @@ private static (ExtendedPropertyKey Key, string TargetLabel) ResolveExtendedProp
             throw SimulatedSqlException.ExtendedPropertyTargetMissing($"{schema.Name}.{obj.Name}.{level2Name}");
         }
 
-        if (Collation.Default.Equals(level2Type, "CONSTRAINT"))
+        if (BuiltInToken.Equals(level2Type, "CONSTRAINT"))
         {
             // Constraints (PK / UQ / FK / CHECK / DEFAULT) all carry their own
             // object_id and reuse class=1 (OBJECT_OR_COLUMN) like every other
@@ -258,7 +258,7 @@ private static (ExtendedPropertyKey Key, string TargetLabel) ResolveExtendedProp
             throw SimulatedSqlException.ExtendedPropertyTargetMissing($"{schema.Name}.{obj.Name}.{level2Name}");
         }
 
-        if (Collation.Default.Equals(level2Type, "INDEX"))
+        if (BuiltInToken.Equals(level2Type, "INDEX"))
         {
             // INDEX-level uses class=7. major_id=table.object_id, minor_id=
             // index_id (matches real SQL Server's sys.extended_properties).
diff --git a/SqlServerSimulator/Simulation/Simulation.LinkedServers.cs b/SqlServerSimulator/Simulation/Simulation.LinkedServers.cs
@@ -47,21 +47,21 @@ private static IEnumerable<SimulatedStatementOutcome> InvokeSpAddLinkedServer(Ba
             positionalIndex++;
             switch (name)
             {
-                case var n when Collation.Default.Equals(n, "server"):
+                case var n when BuiltInToken.Equals(n, "server"):
                     server = arg.Value.IsNull ? null : arg.Value.CoerceTo(SqlType.SystemName).AsString;
                     break;
-                case var n when Collation.Default.Equals(n, "srvproduct"):
+                case var n when BuiltInToken.Equals(n, "srvproduct"):
                     srvProduct = arg.Value.IsNull ? string.Empty : arg.Value.CoerceTo(SqlType.SystemName).AsString;
                     break;
-                case var n when Collation.Default.Equals(n, "provider"):
+                case var n when BuiltInToken.Equals(n, "provider"):
                     provider = arg.Value.IsNull ? "SQLNCLI" : arg.Value.CoerceTo(SqlType.SystemName).AsString;
                     break;
-                case var n when Collation.Default.Equals(n, "datasrc"):
+                case var n when BuiltInToken.Equals(n, "datasrc"):
                     dataSource = arg.Value.IsNull ? null : arg.Value.CoerceTo(SqlType.SystemName).AsString;
                     break;
-                case var n when Collation.Default.Equals(n, "location"):
-                case var n2 when Collation.Default.Equals(n2, "provider_string"):
-                case var n3 when Collation.Default.Equals(n3, "catalog"):
+                case var n when BuiltInToken.Equals(n, "location"):
+                case var n2 when BuiltInToken.Equals(n2, "provider_string"):
+                case var n3 when BuiltInToken.Equals(n3, "catalog"):
                     break;
                 default:
                     throw SimulatedSqlException.InvalidLinkedServerParameter("sp_addlinkedserver");
@@ -106,10 +106,10 @@ private static IEnumerable<SimulatedStatementOutcome> InvokeSpDropServer(BatchCo
             positionalIndex++;
             switch (name)
             {
-                case var n when Collation.Default.Equals(n, "server"):
+                case var n when BuiltInToken.Equals(n, "server"):
                     server = arg.Value.IsNull ? null : arg.Value.CoerceTo(SqlType.SystemName).AsString;
                     break;
-                case var n when Collation.Default.Equals(n, "droplogins"):
+                case var n when BuiltInToken.Equals(n, "droplogins"):
                     break;
                 default:
                     throw SimulatedSqlException.InvalidLinkedServerParameter("sp_dropserver");
diff --git a/SqlServerSimulator/Simulation/Simulation.Merge.cs b/SqlServerSimulator/Simulation/Simulation.Merge.cs
diff --git a/SqlServerSimulator/Simulation/Simulation.Output.cs b/SqlServerSimulator/Simulation/Simulation.Output.cs

Original file line number	Diff line number	Diff line change
`@@ -1204,12 +1204,12 @@ public bool TryResolveTable(MultiPartName name, [System.Diagnostics.CodeAnalysis`
`1204`	`1204`	`// (no DDL can target them).`
`1205`	`1205`	`if (this.TriggerFrame is { } triggerFrame && name.Count == 1)`
`1206`	`1206`	`{`
`1207`		`- if (Collation.Default.Equals(name.Leaf, "inserted") && triggerFrame.Inserted is { } ins)`
	`1207`	`+ if (BuiltInToken.Equals(name.Leaf, "inserted") && triggerFrame.Inserted is { } ins)`
`1208`	`1208`	`{`
`1209`	`1209`	`table = ins;`
`1210`	`1210`	`return true;`
`1211`	`1211`	`}`
`1212`		`- if (Collation.Default.Equals(name.Leaf, "deleted") && triggerFrame.Deleted is { } del)`
	`1212`	`+ if (BuiltInToken.Equals(name.Leaf, "deleted") && triggerFrame.Deleted is { } del)`
`1213`	`1213`	`{`
`1214`	`1214`	`table = del;`
`1215`	`1215`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -152,12 +152,12 @@ private static IEnumerable<byte[]> EnumerateListExtendedPropertyRows(`
`152`	`152`	`f.ClassFilter = 0;`
`153`	`153`	`return f;`
`154`	`154`	`}`
`155`		`- if (!Collation.Default.Equals(l0Type, "SCHEMA"))`
	`155`	`+ if (!BuiltInToken.Equals(l0Type, "SCHEMA"))`
`156`	`156`	`throw new NotSupportedException($"fn_listextendedproperty level0type '{l0Type}' isn't modeled (only SCHEMA / NULL).");`
`157`	`157`	`if (l0Name is null)`
`158`	`158`	`return null;`
`159`	`159`	`if (!batch.CurrentDatabase.Schemas.TryGetValue(l0Name, out var schema)`
`160`		`- && !Collation.Default.Equals(l0Name, "default"))`
	`160`	`+ && !BuiltInToken.Equals(l0Name, "default"))`
`161`	`161`	`{`
`162`	`162`	`return null;`
`163`	`163`	`}`
`@@ -176,7 +176,7 @@ private static IEnumerable<byte[]> EnumerateListExtendedPropertyRows(`
`176`	`176`	`// 'default' wildcard fans out across every object of that kind in`
`177`	`177`	`// the parent schema.`
`178`	`178`	`SchemaObject? l1Obj = null;`
`179`		`- if (schema is not null && !Collation.Default.Equals(l1Name, "default"))`
	`179`	`+ if (schema is not null && !BuiltInToken.Equals(l1Name, "default"))`
`180`	`180`	`{`
`181`	`181`	`Span<char> l1Kind = stackalloc char[l1Type.Length];`
`182`	`182`	`_ = l1Type.ToUpperInvariant(l1Kind);`
`@@ -203,14 +203,14 @@ private static IEnumerable<byte[]> EnumerateListExtendedPropertyRows(`
`203`	`203`	`}`
`204`	`204`	`if (l2Name is null)`
`205`	`205`	`return null;`
`206`		`- if (!Collation.Default.Equals(l2Type, "COLUMN"))`
	`206`	`+ if (!BuiltInToken.Equals(l2Type, "COLUMN"))`
`207`	`207`	`throw new NotSupportedException($"fn_listextendedproperty level2type '{l2Type}' isn't modeled (only COLUMN).");`
`208`	`208`
`209`	`209`	`f.ClassFilter = 1;`
`210`	`210`	`if (l1Obj is HeapTable table)`
`211`	`211`	`{`
`212`	`212`	`f.MajorIdFilter = table.ObjectId;`
`213`		`- if (!Collation.Default.Equals(l2Name, "default"))`
	`213`	`+ if (!BuiltInToken.Equals(l2Name, "default"))`
`214`	`214`	`{`
`215`	`215`	`for (var i = 0; i < table.Columns.Length; i++)`
`216`	`216`	`{`