Introduced contextual keywords to simplify parsing.

Author: RyanLamansky

SqlServerSimulator.Tests/CreateTableTests.cs

@@ -352,4 +352,31 @@ public void CreateTableDateTimeOffset_PrecisionOutOfRange(int precision)
         var x = Assert.Throws<DbException>(() => command.ExecuteNonQuery());
         Assert.AreEqual($"Line 1: Specified scale {precision} is invalid.", x.Message);
     }
+
+    /// <summary>
+    /// Identifiers that match contextual keywords (the parser-side enum
+    /// covering OUTPUT, USING, MATCHED, MAX, etc.) must still work as column
+    /// names — the architecture classifies contextual keywords at parse time
+    /// in keyword-expecting positions only, so identifier positions are
+    /// unaffected. <c>Output</c>, <c>Using</c>, <c>Matched</c>, and <c>Max</c>
+    /// are the most likely real-world collisions.
+    /// </summary>
+    [TestMethod]
+    [DataRow("Output")]
+    [DataRow("Using")]
+    [DataRow("Matched")]
+    [DataRow("Max")]
+    [DataRow("Configuration")]
+    public void ContextualKeywordsAsColumnNames_RoundTrip(string columnName)
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery($"create table t ( {columnName} int )");
+        _ = simulation.ExecuteNonQuery($"insert into t ({columnName}) values (42)");
+
+        using var reader = simulation
+            .CreateCommand($"select {columnName} from t where {columnName} = 42")
+            .ExecuteReader();
+        Assert.IsTrue(reader.Read());
+        Assert.AreEqual(42, reader.GetInt32(0));
+    }
 }

SqlServerSimulator/Parser/ContextualKeyword.cs

@@ -0,0 +1,33 @@
+namespace SqlServerSimulator.Parser;
+
+/// <summary>
+/// Identifiers the parser treats as keywords in specific positions but that
+/// aren't on SQL Server's official reserved-keyword list (see
+/// <see cref="Keyword"/>, sourced verbatim from MS docs). Kept in a separate
+/// enum so the reserved set stays tied to documentation while parser sites
+/// still get typed dispatch — the alternative was scattered case-insensitive
+/// span comparisons against string literals at every call site.
+/// </summary>
+/// <remarks>
+/// Recognition happens at parse time, not tokenization time: tokenizer keeps
+/// emitting <see cref="Tokens.UnquotedString"/> for any unquoted identifier,
+/// and <see cref="ParserContext.MatchContextual"/> /
+/// <see cref="ParserContext.AsContextual"/> classify on demand. This keeps
+/// column references whose names happen to match a contextual keyword
+/// (e.g. <c>create table t (Output int)</c>) working without special casing
+/// — identifier positions never invoke the contextual lookup.
+/// </remarks>
+enum ContextualKeyword
+{
+    _ = 0, // Default — current token isn't a contextual keyword.
+    Compatibility_Level,
+    Configuration,
+    Matched,
+    Max,
+    Output,
+    Scoped,
+    TraceOff,
+    TraceOn,
+    Using,
+    Verbose_Truncation_Warnings,
+}

SqlServerSimulator/Parser/ParserContext.cs

@@ -132,6 +132,30 @@ public ParserContext MoveNextRequiredReturnSelf()
         return this;
     }
 
+    /// <summary>
+    /// Classifies the current <see cref="Token"/> as a
+    /// <see cref="ContextualKeyword"/>: returns the matching value if
+    /// <see cref="Token"/> is an unquoted identifier whose text matches one
+    /// of the contextual-keyword names case-insensitively, otherwise
+    /// returns <see cref="ContextualKeyword._"/> (zero / default). Useful
+    /// for switch-style dispatch on positions that accept several optional
+    /// keywords (e.g. DBCC <c>TRACEON</c>/<c>TRACEOFF</c>).
+    /// </summary>
+    public ContextualKeyword AsContextual() =>
+        this.Token is UnquotedString u
+        && Enum.TryParse<ContextualKeyword>(u.Span, ignoreCase: true, out var keyword)
+        && keyword != ContextualKeyword._
+        ? keyword
+        : ContextualKeyword._;
+
+    /// <summary>
+    /// Returns true when <see cref="Token"/> is an unquoted identifier that
+    /// matches the given <paramref name="expected"/> contextual keyword
+    /// (case-insensitive). Use for required-keyword guards in parser flows;
+    /// for switch-on-classification, see <see cref="AsContextual"/>.
+    /// </summary>
+    public bool MatchContextual(ContextualKeyword expected) => AsContextual() == expected;
+
     /// <summary>
     /// Advances <see cref="Token"/> to the next token in the enumeration, throwing an exception if the end was reached instead.
     /// </summary>

SqlServerSimulator/Simulation.cs

@@ -188,7 +188,7 @@ private bool TryParseCreate(ParserContext context)
                 {
                     declaredMaxLength = numericValue.AsInt32;
                 }
-                else if (lengthToken is UnquotedString unquoted && unquoted.Span.Equals("MAX", StringComparison.OrdinalIgnoreCase))
+                else if (context.MatchContextual(ContextualKeyword.Max))
                 {
                     throw new NotSupportedException($"{type}(MAX) and other LOB types aren't modeled yet.");
                 }
@@ -492,7 +492,7 @@ private static SimulatedStatementOutcome ProcessHeapInsert(HeapTable destination
     /// <param name="sourceColumnNames">For MERGE only: the source alias's column names. <see langword="null"/> for plain INSERT.</param>
     private static OutputProjection? TryParseOutputClause(ParserContext context, HeapTable destinationTable, (string SourceAlias, string[] SourceColumns, SqlType[] SourceTypes)? sourceColumnNames)
     {
-        if (context.Token is not UnquotedString unquoted || !unquoted.Span.Equals("OUTPUT", StringComparison.OrdinalIgnoreCase))
+        if (!context.MatchContextual(ContextualKeyword.Output))
             return null;
 
         var expressions = new List<Expression>();
@@ -628,7 +628,8 @@ private static SimulatedStatementOutcome ParseMerge(ParserContext context)
             ? table
             : throw SimulatedSqlException.InvalidObjectName(destinationTableToken);
 
-        if (context.GetNextRequired() is not UnquotedString usingKw || !usingKw.Span.Equals("USING", StringComparison.OrdinalIgnoreCase))
+        context.MoveNextRequired();
+        if (!context.MatchContextual(ContextualKeyword.Using))
             throw SimulatedSqlException.SyntaxErrorNear(context);
 
         if (context.GetNextRequired() is not Operator { Character: '(' })
@@ -694,7 +695,7 @@ private static SimulatedStatementOutcome ParseMerge(ParserContext context)
             if (context.Token is ReservedKeyword { Keyword: Keyword.Not })
             {
                 context.MoveNextRequired();
-                if (context.Token is not UnquotedString matchedKw || !matchedKw.Span.Equals("MATCHED", StringComparison.OrdinalIgnoreCase))
+                if (!context.MatchContextual(ContextualKeyword.Matched))
                     throw SimulatedSqlException.SyntaxErrorNear(context);
                 if (context.GetNextRequired() is not ReservedKeyword { Keyword: Keyword.Then })
                     throw SimulatedSqlException.SyntaxErrorNear(context);
@@ -750,7 +751,7 @@ private static SimulatedStatementOutcome ParseMerge(ParserContext context)
                 {
                     context.MoveNextOptional();
                 }
-                if (context.Token is UnquotedString tail && !tail.Span.Equals("OUTPUT", StringComparison.OrdinalIgnoreCase))
+                if (context.Token is UnquotedString && !context.MatchContextual(ContextualKeyword.Output))
                     context.MoveNextOptional();
             }
         }
@@ -1080,7 +1081,7 @@ private bool TryParseAlter(ParserContext context)
             return false;
 
         var afterDatabase = context.GetNextRequired();
-        if (afterDatabase is UnquotedString unquoted && unquoted.Span.Equals("SCOPED", StringComparison.OrdinalIgnoreCase))
+        if (context.MatchContextual(ContextualKeyword.Scoped))
             return TryParseAlterDatabaseScopedConfiguration(context);
 
         // Otherwise a database name (or CURRENT). The simulator has one
@@ -1094,10 +1095,8 @@ private bool TryParseAlterDatabaseSet(ParserContext context)
         if (context.GetNextRequired() is not ReservedKeyword { Keyword: Keyword.Set })
             return false;
 
-        if (context.GetNextRequired() is not UnquotedString option)
-            return false;
-
-        if (!option.Span.Equals("COMPATIBILITY_LEVEL", StringComparison.OrdinalIgnoreCase))
+        context.MoveNextRequired();
+        if (!context.MatchContextual(ContextualKeyword.Compatibility_Level))
             return false;
 
         if (context.GetNextRequired() is not Operator { Character: '=' })
@@ -1116,19 +1115,15 @@ private bool TryParseAlterDatabaseSet(ParserContext context)
 
     private bool TryParseAlterDatabaseScopedConfiguration(ParserContext context)
     {
-        if (context.GetNextRequired() is not UnquotedString configToken
-            || !configToken.Span.Equals("CONFIGURATION", StringComparison.OrdinalIgnoreCase))
-        {
+        context.MoveNextRequired();
+        if (!context.MatchContextual(ContextualKeyword.Configuration))
             return false;
-        }
 
         if (context.GetNextRequired() is not ReservedKeyword { Keyword: Keyword.Set })
             return false;
 
-        if (context.GetNextRequired() is not UnquotedString option)
-            return false;
-
-        if (!option.Span.Equals("VERBOSE_TRUNCATION_WARNINGS", StringComparison.OrdinalIgnoreCase))
+        context.MoveNextRequired();
+        if (!context.MatchContextual(ContextualKeyword.Verbose_Truncation_Warnings))
             return false;
 
         if (context.GetNextRequired() is not Operator { Character: '=' })
@@ -1149,16 +1144,14 @@ private bool TryParseAlterDatabaseScopedConfiguration(ParserContext context)
     /// </summary>
     private bool TryParseDbcc(ParserContext context)
     {
-        if (context.GetNextRequired() is not UnquotedString action)
-            return false;
-
+        context.MoveNextRequired();
         bool turningOn;
-        if (action.Span.Equals("TRACEON", StringComparison.OrdinalIgnoreCase))
-            turningOn = true;
-        else if (action.Span.Equals("TRACEOFF", StringComparison.OrdinalIgnoreCase))
-            turningOn = false;
-        else
-            return false;
+        switch (context.AsContextual())
+        {
+            case ContextualKeyword.TraceOn: turningOn = true; break;
+            case ContextualKeyword.TraceOff: turningOn = false; break;
+            default: return false;
+        }
 
         if (context.GetNextRequired() is not Operator { Character: '(' })
             return false;