Select statements can now contain both expressions and tables.

Author: RyanLamansky

SqlServerSimulator.Tests/SelectTests.cs

@@ -67,6 +67,7 @@ public void Expression(string commandText, string name, object value)
     [DataRow("select 1 from systypes", 34, 1, 1)]
     [DataRow("select 1 from systypes as s", 34, 1, 1)]
     [DataRow("select name from systypes", 34, 34, "image")]
+    [DataRow("select 1 + 1 from systypes", 34, 1, 2)]
     public void ExpressionFromTable(string commandText, int minimumRows, int uniqueRows, object value)
     {
         using var reader = new Simulation().ExecuteReader(commandText);
@@ -87,6 +88,7 @@ public void ExpressionFromTable(string commandText, int minimumRows, int uniqueR
     [DataRow("select name as c from systypes as s", 34, 34, "c", "image")]
     [DataRow("select systypes.name from systypes", 34, 34, "name", "image")]
     [DataRow("select s.name from systypes as s", 34, 34, "name", "image")]
+    [DataRow("select 1 + 1 as c from systypes", 34, 1, "c", 2)]
     public void NamedExpressionFromTable(string commandText, int minimumRows, int uniqueRows, string name, object value)
     {
         using var reader = new Simulation().ExecuteReader(commandText);
@@ -106,6 +108,29 @@ public void NamedExpressionFromTable(string commandText, int minimumRows, int un
         Assert.AreEqual(value, results[0]);
     }
 
+    [TestMethod]
+    [DataRow("select 1 + 1 as x, name as c from systypes", 34, "x", 2, "c", "image")]
+    [DataRow("select 1 + 1, name as c from systypes", 34, "", 2, "c", "image")]
+    public void NamedExpressionAndColumnFromTable(string commandText, int minimumRows, string name0, object value0, string name1, object value1)
+    {
+        using var reader = new Simulation().ExecuteReader(commandText);
+
+        var results = reader
+            .EnumerateRecords()
+            .Take(minimumRows) // There might be more someday, but there won't be less.
+            .Select(reader =>
+            {
+                Assert.AreEqual(name0, reader.GetName(0));
+                Assert.AreEqual(name1, reader.GetName(1));
+                return (C0: reader[0], C1: reader[1]);
+            })
+            .ToArray();
+
+        Assert.HasCount(minimumRows, results);
+        Assert.AreEqual(value0, results[0].C0);
+        Assert.AreEqual(value1, results[0].C1);
+    }
+
     [TestMethod]
     public void Select1Comma2()
     {
@@ -147,6 +172,21 @@ public void SelectSyntaxErrorsAreCorrect(string commandText, string nearSyntax)
         new Simulation().ValidateSyntaxError(commandText, nearSyntax);
 
     [TestMethod]
-    public void SelectFromDerivedTable() =>
-        Assert.AreEqual(1, new Simulation().ExecuteScalar("select x from ( select 1 as x ) as x"));
+    [DataRow("select x from ( select 1 as x ) as x", "x", 1)]
+    [DataRow("select x from ( select 1 + 1 as x ) as x", "x", 2)]
+    public void DerivedTable(string commandText, string name, object value)
+    {
+        using var reader = new Simulation().ExecuteReader(commandText);
+
+        var result = reader
+            .EnumerateRecords()
+            .Select(reader =>
+            {
+                Assert.AreEqual(name, reader.GetName(0));
+                return reader[0];
+            })
+            .SingleOrDefault();
+
+        Assert.AreEqual(value, result);
+    }
 }

SqlServerSimulator/Parser/Expression.cs

@@ -13,9 +13,12 @@ private protected Expression()
     public static Expression Parse(Simulation simulation, IEnumerator<Token> tokens, ref Token? token, Func<string, object?> getVariableValue)
     {
         Expression? expression = null;
+        bool tokenWasRead;
 
         do
         {
+            tokenWasRead = false;
+
             switch (token)
             {
                 case Numeric number:
@@ -59,6 +62,8 @@ public static Expression Parse(Simulation simulation, IEnumerator<Token> tokens,
                     expression = new Add(expression, parsed);
                     if (parsed is NamedExpression named)
                         expression = named.TransferName(expression);
+
+                    tokenWasRead = true;
                     break;
                 case Period:
                     if (expression is null)
@@ -70,13 +75,14 @@ public static Expression Parse(Simulation simulation, IEnumerator<Token> tokens,
                     reference.AddMultiPartComponent(tokens.RequireNext<Name>());
                     break;
                 case Comma:
+                case CloseParentheses:
                     if (expression is null)
                         throw SimulatedSqlException.SyntaxErrorNear(token);
                     return expression;
                 default:
                     throw new NotSupportedException($"Simulated expression parser doesn't know how to handle '{token}'.");
             }
-        } while (tokens.TryMoveNext(out token));
+        } while ((tokenWasRead && token is not null) || tokens.TryMoveNext(out token));
 
         return expression;
     }

SqlServerSimulator/Parser/Selection.cs

@@ -12,15 +12,11 @@ public static Selection Parse(Simulation simulation, IEnumerator<Token> tokens,
     {
         token = tokens.RequireNext();
 
-        Dictionary<string, int> columnIndexes = [];
         List<Expression> expressions = [];
 
         do
         {
-            var expression = Expression.Parse(simulation, tokens, ref token, getVariableValue);
-            if (expression.Name.Length > 0)
-                columnIndexes.Add(expression.Name, columnIndexes.Count);
-            expressions.Add(expression);
+            expressions.Add(Expression.Parse(simulation, tokens, ref token, getVariableValue));
 
             switch (token)
             {
@@ -35,7 +31,7 @@ public static Selection Parse(Simulation simulation, IEnumerator<Token> tokens,
 
                 case null: // "Select" with no "From".
                     return new(new(
-                        columnIndexes,
+                        expressions,
                         [[.. expressions.Select(x => x.Run(column => throw SimulatedSqlException.InvalidColumnName(column)))]]
                         ));
 
@@ -63,7 +59,7 @@ public static Selection Parse(Simulation simulation, IEnumerator<Token> tokens,
                             }
 
                             return new(new(
-                                columnIndexes,
+                                expressions,
                                 table.Rows.Select<object?[], object?[]>(row => [..expressions.Select(x => x.Run(columnName =>
                                 {
                                     var columnIndex = table.Columns.FindIndex(column => Collation.Default.Equals(column.Name, columnName.Last()));
@@ -89,7 +85,7 @@ public static Selection Parse(Simulation simulation, IEnumerator<Token> tokens,
                                 }
 
                                 return new(new(
-                                    columnIndexes,
+                                    expressions,
                                     derived.Select<object?[], object?[]>(row => [..expressions.Select(x => x.Run(columnName =>
                                     {
                                         var columnIndex = Array.FindIndex(derived.columnNames, name => Collation.Default.Equals(name, columnName.Last()));

SqlServerSimulator/SimulatedResultSet.cs

@@ -1,14 +1,17 @@
-using System.Collections;
+using SqlServerSimulator.Parser;
+using System.Collections;
+using System.Collections.Frozen;
 
 namespace SqlServerSimulator;
 
-sealed class SimulatedResultSet(Dictionary<string, int> columnIndexes, IEnumerable<object?[]> records) : SimulatedStatementOutcome(-1), IEnumerable<object?[]>
+sealed class SimulatedResultSet(List<Expression> expressions, IEnumerable<object?[]> records) : SimulatedStatementOutcome(-1), IEnumerable<object?[]>
 {
     internal readonly IEnumerable<object?[]> records = records;
-    internal readonly Dictionary<string, int> columnIndexes = columnIndexes;
-    internal readonly string[] columnNames = [.. columnIndexes
-        .OrderBy(kv => kv.Value)
-        .Select(kv => kv.Key)];
+    internal readonly FrozenDictionary<string, int> columnIndexes = expressions
+        .Select((x, i) => (x, i))
+        .Where(x => x.x.Name.Length > 0)
+        .ToFrozenDictionary(x => x.x.Name, x => x.i);
+    internal readonly string[] columnNames = [.. expressions.Select(x => x.Name)];
 
     public IEnumerator<object?[]> GetEnumerator() => this.records.GetEnumerator();