Integrated the official reserved keyword list. Updated how type names are parsed since they're not reserved keywords.

Author: RyanLamansky

SqlServerSimulator.Tests/CreateTableTests.cs

@@ -1,4 +1,6 @@
-namespace SqlServerSimulator;
+using System.Data.Common;
+
+namespace SqlServerSimulator;
 
 [TestClass]
 public class CreateTableTests
@@ -15,6 +17,19 @@ public void CreateTableMinimal()
         Assert.AreEqual(-1, command.ExecuteNonQuery());
     }
 
+    [TestMethod]
+    public void InvalidTypeName()
+    {
+        var simulation = new Simulation();
+
+        using var connection = simulation.CreateDbConnection();
+        using var command = connection.CreateCommand("create table t ( v intz )");
+
+        connection.Open();
+        var x = Assert.Throws<DbException>(() => command.ExecuteNonQuery());
+        Assert.AreEqual("Column, parameter, or variable #1: Cannot find data type intz.", x.Message);
+    }
+
     [TestMethod]
     public void CreateTableNull()
     {

SqlServerSimulator/DataType.cs

@@ -1,5 +1,4 @@
-using SqlServerSimulator.Parser;
-using SqlServerSimulator.Parser.Tokens;
+using SqlServerSimulator.Parser.Tokens;
 using System.Data;
 using System.Globalization;
 
@@ -31,17 +30,36 @@ private protected DataType()
 
     public static readonly DataType BuiltInDbSystemName = new DbSystemName();
 
-    public static DataType GetByName(Name name)
+    /// <summary>
+    /// Looks up the <see cref="DataType"/> for the provided type name.
+    /// </summary>
+    /// <param name="name">The name of the type.</param>
+    /// <param name="index">The 1-based index of the type, used for an error message.</param>
+    /// <returns>The matching data type.</returns>
+    /// <exception cref="SimulatedSqlException">Column, parameter, or variable #<paramref name="index"/>: Cannot find data type <paramref name="name"/>.</exception>
+    public static DataType GetByName(Name name, int index)
     {
-        var keyword = name.Parse();
-        return keyword switch
+        Span<char> upper = stackalloc char[name.Value.Length];
+        return name.Value.ToUpperInvariant(upper) switch
         {
-            Keyword.Bit => BuiltInDbBoolean,
-            Keyword.TinyInt => BuiltInDbByte,
-            Keyword.SmallInt => BuiltInDbInt16,
-            Keyword.Int => BuiltInDbInt32,
-            _ => throw new NotSupportedException($"Simulated data type parser doesn't recognize {keyword}"),
-        };
+            3 => upper switch
+            {
+                "BIT" => BuiltInDbBoolean,
+                "INT" => BuiltInDbInt32,
+                _ => null
+            },
+            7 => upper switch
+            {
+                "TINYINT" => BuiltInDbByte,
+                _ => null
+            },
+            8 => upper switch
+            {
+                "SMALLINT" => BuiltInDbInt16,
+                _ => null
+            },
+            _ => null,
+        } ?? throw SimulatedSqlException.CannotFindDataType(name.Value, index);
     }
 
     public static DataType GetByDbType(DbType dbType) => dbType switch

SqlServerSimulator/Parser/Keyword.cs

@@ -1,62 +1,196 @@
 namespace SqlServerSimulator.Parser;
 
+/// <summary>
+/// Reserved keywords from https://learn.microsoft.com/en-us/sql/t-sql/language-elements/reserved-keywords-transact-sql
+/// </summary>
 enum Keyword
 {
     _ = 0, // "Default" value for the enum, indicating not a keyword.
+    Add,
+    All,
+    Alter,
+    And,
+    Any,
     As,
     Asc,
-    BigInt,
-    Binary,
-    Bit,
+    Authorization,
+    Backup,
+    Begin,
+    Between,
+    Break,
+    Browse,
+    Bulk,
     By,
-    Char,
-    Count,
-    CountBig,
+    Cascade,
+    Case,
+    Check,
+    Checkpoint,
+    Close,
+    Clustered,
+    Coalesce,
+    Collate,
+    Column,
+    Commit,
+    Compute,
+    Constraint,
+    Contains,
+    ContainsTable,
+    Continue,
+    Convert,
     Create,
-    Date,
-    DateTime,
-    DateTime2,
-    DateTimeOffset,
-    Decimal,
+    Cross,
+    Current_Date,
+    Current_Time,
+    Current_Timestamp,
+    Current_User,
+    Current,
+    Cursor,
+    Database,
+    Dbcc,
+    Deallocate,
+    Declare,
+    Default,
+    Delete,
+    Deny,
     Desc,
+    Disk,
+    Distinct,
+    Distributed,
+    Double,
+    Drop,
+    Dump,
+    Else,
+    End,
+    ErrLvl,
+    Escape,
+    Except,
+    Exec,
+    Execute,
     Exists,
-    Float,
+    Exit,
+    External,
+    Fetch,
+    File,
+    FillFactor,
+    For,
+    Foreign,
+    FreeText,
+    FreeTextTable,
     From,
-    Implicit_Transactions,
+    Full,
+    Function,
+    Goto,
+    Grant,
+    Group,
+    Having,
+    HoldLock,
+    Identity_Insert,
+    Identity,
+    IdentityCol,
+    If,
     In,
+    Index,
     Inner,
     Insert,
-    Int,
+    Intersect,
     Into,
+    Is,
     Join,
     Key,
+    Kill,
     Left,
-    Money,
-    NChar,
-    NoCount,
+    Like,
+    LineNo,
+    Load,
+    Merge,
+    National,
+    NoCheck,
+    NonClustered,
     Not,
     Null,
-    Numeric,
-    NVarChar,
+    NullIf,
+    Of,
     Off,
+    Offsets,
     On,
+    Open,
+    OpenDataSource,
+    OpenQuery,
+    OpenRowSet,
+    OpenXml,
+    Option,
+    Or,
     Order,
     Outer,
+    Over,
+    Percent,
+    Pivot,
+    Plan,
+    Precision,
     Primary,
-    Real,
+    Print,
+    Proc,
+    Procedure,
+    Public,
+    RaisError, // Alternative casing is RaiseRror, which is even weirder.
+    Read,
+    ReadText,
+    Reconfigure,
+    References,
+    Replication,
+    Restore,
+    Restrict,
+    Return,
+    Revert,
+    Revoke,
     Right,
+    Rollback,
+    RowCount,
+    RowGuidCol,
+    Rule,
+    Save,
+    Schema,
+    SecurityAudit,
     Select,
+    SemanticKeyPhraseTable,
+    SemanticSimilarityDetailsTable,
+    SemanticSimilarityTable,
+    Session_User,
     Set,
-    SmallDateTime,
-    SmallInt,
-    SmallMoney,
+    SetUser,
+    Shutdown,
+    Some,
+    Statistics,
+    System_user,
     Table,
-    Time,
-    TinyInt,
-    UniqueIdentifier,
+    TableSample,
+    TextSize,
+    Then,
+    To,
+    Top,
+    Tran,
+    Transaction,
+    Trigger,
+    Truncate,
+    Try_Convert,
+    TSequal,
+    Union,
+    Unique,
+    Unpivot,
+    Update,
+    UpdateText,
+    Use,
+    User,
     Values,
-    VarBinary,
-    VarChar,
+    Varying,
+    View,
+    WaitFor,
+    When,
     Where,
-    Xml,
+    While,
+    With,
+    // "WITHIN GROUP", including the space, is in the list linked above for some unknown reason.
+    // "WITHIN" alone doesn't seem to be enforced as a reserved keyword in my testing, and "GROUP" is already covered.
+    // These factors combine to make it functionally irrelevant as a reserved keyword.
+    WriteText,
 }

SqlServerSimulator/SimulatedSqlException.cs

@@ -84,6 +84,14 @@ private SimulatedSqlException(string? message, params ReadOnlySpan<SimulatedSqlE
 
     public IReadOnlyList<SimulatedSqlError> Errors { get; }
 
+    /// <summary>
+    /// Mimics the SqlException that occurs when an unknown type is referenced.
+    /// </summary>
+    /// <param name="name">The name of the type.</param>
+    /// <param name="index">The 1-based index of the reference.</param>
+    /// <returns>The exception.</returns>
+    internal static SimulatedSqlException CannotFindDataType(string name, int index) => new($"Column, parameter, or variable #{index}: Cannot find data type {name}.", 2715, 16, 6);
+
     internal static SimulatedSqlException InvalidColumnName(string name) => new($"Invalid column name '{name}'.", 207, 16, 1);
 
     internal static SimulatedSqlException InvalidColumnName(IEnumerable<string> name) => InvalidColumnName(string.Join('.', name));

SqlServerSimulator/Simulation.cs

@@ -144,10 +144,10 @@ internal IEnumerable<SimulatedStatementOutcome> CreateResultSetsForCommand(Simul
                             switch (token = tokens.RequireNext())
                             {
                                 case UnquotedString setTarget:
-                                    switch (setTarget.Parse())
+                                    switch (setTarget.Value.ToUpperInvariant())
                                     {
-                                        case Keyword.Implicit_Transactions:
-                                        case Keyword.NoCount:
+                                        case "IMPLICIT_TRANSACTIONS":
+                                        case "NOCOUNT":
                                             switch (token = tokens.RequireNext())
                                             {
                                                 case UnquotedString onOff:
@@ -217,7 +217,7 @@ internal IEnumerable<SimulatedStatementOutcome> CreateResultSetsForCommand(Simul
                                                     nullable = true;
                                                 }
 
-                                                columns.Add(new Column(columnName.Value, DataType.GetByName(type), nullable));
+                                                columns.Add(new(columnName.Value, DataType.GetByName(type, columns.Count + 1), nullable));
                                             } while ((suppressAdvanceToken ? token : token = tokens.RequireNext()) is Comma);
 
                                             if (token is not CloseParentheses)