Reserved keywords are now tokenized separately from unquoted strings.

Author: RyanLamansky

SqlServerSimulator/Parser/Expression.cs

@@ -31,29 +31,28 @@ public static Expression Parse(Simulation simulation, IEnumerator<Token> tokens,
                 case DoubleAtPrefixedString doubleAtPrefixedString:
                     expression = new Value(doubleAtPrefixedString);
                     break;
-                case Name name:
-                    if (name is UnquotedString && name.TryParse(out var keyword))
+                case ReservedKeyword reservedKeyword:
+                    switch (reservedKeyword.Keyword)
                     {
-                        switch (keyword)
-                        {
-                            case Keyword.As:
-                                if (expression is null || !tokens.TryMoveNext(out token) || token is not Name alias)
-                                    throw SimulatedSqlException.SyntaxErrorNear(name);
-
-                                expression = new NamedExpression(expression, alias.Value);
-                                _ = tokens.TryMoveNext(out token);
-                                return expression;
-                            case Keyword.From:
-                                if (expression is null)
-                                    throw SimulatedSqlException.SyntaxErrorNear(name);
-
-                                return expression;
-                            case Keyword.Null:
-                                expression = new Value();
-                                continue;
-                        }
+                        case Keyword.As:
+                            if (expression is null || !tokens.TryMoveNext(out token) || token is not Name alias)
+                                throw SimulatedSqlException.SyntaxErrorNearKeyword(reservedKeyword);
+
+                            expression = new NamedExpression(expression, alias.Value);
+                            _ = tokens.TryMoveNext(out token);
+                            return expression;
+                        case Keyword.From:
+                            if (expression is null)
+                                throw SimulatedSqlException.SyntaxErrorNearKeyword(reservedKeyword);
+
+                            return expression;
+                        case Keyword.Null:
+                            expression = new Value();
+                            continue;
                     }
 
+                    throw SimulatedSqlException.SyntaxErrorNearKeyword(reservedKeyword);
+                case Name name:
                     expression = new Reference(name);
                     break;
                 case Plus:

SqlServerSimulator/Parser/Selection.cs

@@ -35,8 +35,8 @@ public static Selection Parse(Simulation simulation, IEnumerator<Token> tokens,
                         [[.. expressions.Select(x => x.Run(column => throw SimulatedSqlException.InvalidColumnName(column)))]]
                         ));
 
-                case UnquotedString unquotedString:
-                    if (!unquotedString.TryParse(out var keyword) || keyword != Keyword.From)
+                case ReservedKeyword expectFrom:
+                    if (expectFrom.Keyword != Keyword.From)
                         throw new NotSupportedException("Simulated selection processor expected a `from`.");
 
                     switch (token = tokens.RequireNext())
@@ -47,9 +47,9 @@ public static Selection Parse(Simulation simulation, IEnumerator<Token> tokens,
 
                             if (tokens.TryMoveNext(out token))
                             {
-                                if (token is UnquotedString maybeAs && maybeAs.Parse() == Keyword.As)
+                                if (token is ReservedKeyword { Keyword: Keyword.As })
                                 {
-                                    if (token is not UnquotedString)
+                                    if (token is not ReservedKeyword)
                                         break;
                                 }
                                 else
@@ -68,15 +68,15 @@ public static Selection Parse(Simulation simulation, IEnumerator<Token> tokens,
                                 ));
 
                         case OpenParentheses:
-                            if ((token = tokens.RequireNext()) is not UnquotedString maybeSelect || maybeSelect.Parse() != Keyword.Select)
+                            if ((token = tokens.RequireNext()) is not ReservedKeyword { Keyword: Keyword.Select })
                                 throw SimulatedSqlException.SyntaxErrorNear(token);
 
                             {
                                 var derived = Selection.Parse(simulation, tokens, ref token, getVariableValue, depth + 1).Results;
 
-                                if ((token = tokens.RequireNext()) is UnquotedString maybeAs && maybeAs.Parse() == Keyword.As)
+                                if ((token = tokens.RequireNext()) is ReservedKeyword { Keyword: Keyword.As })
                                 {
-                                    if (token is not UnquotedString)
+                                    if (token is not ReservedKeyword)
                                         break;
                                 }
                                 else

SqlServerSimulator/Parser/Tokenizer.cs

@@ -99,7 +99,7 @@ public static IEnumerable<Token> Tokenize(string? command)
                     {
                         if (buffer.Length != 0)
                         {
-                            yield return new UnquotedString(buffer);
+                            yield return UnquotedString.CheckReserved(buffer);
                             state = State.None;
                         }
 
@@ -116,7 +116,7 @@ public static IEnumerable<Token> Tokenize(string? command)
                         switch (state)
                         {
                             case State.UnquotedString:
-                                yield return new UnquotedString(buffer);
+                                yield return UnquotedString.CheckReserved(buffer);
                                 break;
                             case State.AtPrefixedString:
                                 yield return new AtPrefixedString(buffer);
@@ -134,7 +134,7 @@ public static IEnumerable<Token> Tokenize(string? command)
                     switch (state)
                     {
                         case State.UnquotedString:
-                            yield return new UnquotedString(buffer);
+                            yield return UnquotedString.CheckReserved(buffer);
                             state = State.None;
                             break;
                         case State.Numeric:
@@ -152,7 +152,7 @@ public static IEnumerable<Token> Tokenize(string? command)
                     switch (state)
                     {
                         case State.UnquotedString:
-                            yield return new UnquotedString(buffer);
+                            yield return UnquotedString.CheckReserved(buffer);
                             state = State.None;
                             break;
                         case State.AtPrefixedString:
@@ -205,7 +205,7 @@ public static IEnumerable<Token> Tokenize(string? command)
                     switch (state)
                     {
                         case State.UnquotedString:
-                            yield return new UnquotedString(buffer);
+                            yield return UnquotedString.CheckReserved(buffer);
                             break;
                         case State.AtPrefixedString:
                             yield return new AtPrefixedString(buffer);
@@ -229,7 +229,7 @@ public static IEnumerable<Token> Tokenize(string? command)
                             yield return new Numeric(buffer);
                             break;
                         case State.UnquotedString:
-                            yield return new UnquotedString(buffer);
+                            yield return UnquotedString.CheckReserved(buffer);
                             break;
                     }
 
@@ -245,7 +245,7 @@ public static IEnumerable<Token> Tokenize(string? command)
         switch (state)
         {
             case State.UnquotedString:
-                yield return new UnquotedString(buffer);
+                yield return UnquotedString.CheckReserved(buffer);
                 break;
             case State.AtPrefixedString:
                 yield return new AtPrefixedString(buffer);

SqlServerSimulator/Parser/Tokens/Name.cs

@@ -4,14 +4,21 @@ namespace SqlServerSimulator.Parser.Tokens;
 
 abstract class Name : StringToken
 {
+    /// <summary>
+    /// Creates a <see cref="Name"/> from a plain string.
+    /// </summary>
+    /// <param name="value">Transfers to <see cref="StringToken.Value"/>.</param>
+    private protected Name(string value)
+        : base(value)
+    {
+    }
+
+    /// <summary>
+    /// Creates a <see cref="Name"/> from the provided <paramref name="buffer"/> and then <see cref="StringBuilder.Clear"/>s it.
+    /// </summary>
+    /// <param name="buffer">The source of the string.</param>
     private protected Name(StringBuilder buffer)
         : base(buffer)
     {
     }
-
-    public bool TryParse(out Keyword keyword) => Enum.TryParse(Value, true, out keyword);
-
-    public Keyword Parse() => !Enum.TryParse<Keyword>(Value, true, out var result)
-        ? throw new NotSupportedException($"Simulated command processor doesn't know what to do with `{Value}`.")
-        : result;
 }

SqlServerSimulator/Parser/Tokens/ReservedKeyword.cs

@@ -0,0 +1,14 @@
+namespace SqlServerSimulator.Parser.Tokens;
+
+internal sealed class ReservedKeyword(Keyword keyword, string value) : Token
+{
+    public readonly Keyword Keyword = keyword;
+
+    /// <summary>
+    /// The original value as provided in the command.
+    /// </summary>
+    /// <remarks>This preserves input casing for potential error messages.</remarks>
+    public readonly string Value = value;
+
+    public override string ToString() => this.Value;
+}

SqlServerSimulator/Parser/Tokens/StringToken.cs

@@ -6,9 +6,19 @@ abstract class StringToken : Token
 {
     public readonly string Value;
 
+    /// <summary>
+    /// Creates a <see cref="StringToken"/> from a plain string.
+    /// </summary>
+    /// <param name="value">Transfers to <see cref="Value"/>.</param>
+    private protected StringToken(string value) => this.Value = value;
+
+    /// <summary>
+    /// Creates a <see cref="StringToken"/> from the provided <paramref name="buffer"/> and then <see cref="StringBuilder.Clear"/>s it.
+    /// </summary>
+    /// <param name="buffer">The source of the string.</param>
     private protected StringToken(StringBuilder buffer)
+        : this(buffer.ToString())
     {
-        this.Value = buffer.ToString();
         _ = buffer.Clear();
     }
 }

SqlServerSimulator/Parser/Tokens/UnquotedString.cs

@@ -2,7 +2,26 @@
 
 namespace SqlServerSimulator.Parser.Tokens;
 
-sealed class UnquotedString(StringBuilder buffer) : Name(buffer)
+sealed class UnquotedString : Name
 {
+    private UnquotedString(string value) : base(value)
+    {
+    }
+
+    /// <summary>
+    /// Returns either an <see cref="UnquotedString"/> or <see cref="ReservedKeyword"/> depending on input.
+    /// </summary>
+    /// <param name="buffer">The string to consider. <see cref="StringBuilder.Clear"/> is called.</param>
+    /// <returns></returns>
+    public static Token CheckReserved(StringBuilder buffer)
+    {
+        var value = buffer.ToString();
+        _ = buffer.Clear();
+
+        return Enum.TryParse<Keyword>(value, true, out var keyword) ?
+            new ReservedKeyword(keyword, value) :
+            new UnquotedString(value);
+    }
+
     public override string ToString() => Value;
 }

SqlServerSimulator/SimulatedSqlException.cs

@@ -98,6 +98,8 @@ private SimulatedSqlException(string? message, params ReadOnlySpan<SimulatedSqlE
 
     internal static SimulatedSqlException InvalidObjectName(StringToken name) => new($"Invalid object name {name}.", 208, 16, 1);
 
+    internal static SimulatedSqlException SyntaxErrorNearKeyword(ReservedKeyword token) => new($"Incorrect syntax near the keyword '{token}'.", 156, 15, 1);
+
     internal static SimulatedSqlException SyntaxErrorNear(Token token) => new($"Incorrect syntax near '{token}'.", 102, 15, 1);
 
     internal static SimulatedSqlException ThereIsAlreadyAnObject(string name) => new($"There is already an object named '{name}' in the database.", 2714, 16, 6);

SqlServerSimulator/Simulation.cs

@@ -137,8 +137,8 @@ internal IEnumerable<SimulatedStatementOutcome> CreateResultSetsForCommand(Simul
                 case StatementTerminator:
                     continue;
 
-                case UnquotedString unquotedString:
-                    switch (unquotedString.Parse())
+                case ReservedKeyword reserved:
+                    switch (reserved.Keyword)
                     {
                         case Keyword.Set:
                             switch (token = tokens.RequireNext())
@@ -150,8 +150,8 @@ internal IEnumerable<SimulatedStatementOutcome> CreateResultSetsForCommand(Simul
                                         case "NOCOUNT":
                                             switch (token = tokens.RequireNext())
                                             {
-                                                case UnquotedString onOff:
-                                                    switch (onOff.Parse())
+                                                case ReservedKeyword onOff:
+                                                    switch (onOff.Keyword)
                                                     {
                                                         case Keyword.On:
                                                         case Keyword.Off:
@@ -168,8 +168,8 @@ internal IEnumerable<SimulatedStatementOutcome> CreateResultSetsForCommand(Simul
                         case Keyword.Create:
                             switch (token = tokens.RequireNext())
                             {
-                                case UnquotedString whatToCreate:
-                                    switch (whatToCreate.Parse())
+                                case ReservedKeyword whatToCreate:
+                                    switch (whatToCreate.Keyword)
                                     {
                                         case Keyword.Table:
                                             if (tokens.RequireNext() is not Name tableName)
@@ -194,12 +194,12 @@ internal IEnumerable<SimulatedStatementOutcome> CreateResultSetsForCommand(Simul
                                                 var nullable = true;
 
                                                 token = tokens.RequireNext();
-                                                if (token is UnquotedString next)
+                                                if (token is ReservedKeyword next)
                                                 {
-                                                    switch (next.Parse())
+                                                    switch (next.Keyword)
                                                     {
                                                         case Keyword.Not:
-                                                            if ((token = tokens.RequireNext()) is not UnquotedString mustBeNull || mustBeNull.Parse() != Keyword.Null)
+                                                            if ((token = tokens.RequireNext()) is not ReservedKeyword { Keyword: Keyword.Null })
                                                                 throw new NotSupportedException($"Simulated command processor doesn't know how to handle column definition token {token}.");
 
                                                             nullable = false;
@@ -237,7 +237,7 @@ internal IEnumerable<SimulatedStatementOutcome> CreateResultSetsForCommand(Simul
                             break;
 
                         case Keyword.Insert:
-                            if ((token = tokens.RequireNext()) is UnquotedString maybeInto && maybeInto.TryParse(out var keyword) && keyword == Keyword.Into)
+                            if ((token = tokens.RequireNext()) is ReservedKeyword { Keyword: Keyword.Into })
                                 token = tokens.RequireNext();
 
                             if (token is not StringToken destinationTableToken)
@@ -270,7 +270,7 @@ internal IEnumerable<SimulatedStatementOutcome> CreateResultSetsForCommand(Simul
                                 destinationColumns = [.. destinationTable.Columns];
                             }
 
-                            if (token is not UnquotedString expectValues || expectValues.Parse() != Keyword.Values)
+                            if (token is not ReservedKeyword { Keyword: Keyword.Values })
                                 break;
 
                             if ((token = tokens.RequireNext()) is not OpenParentheses)