Parentheses in expressions are now handled directly.

RyanLamansky · RyanLamansky · commit 2f5e4c2ca4eb · 2025-12-28T09:06:20.000-06:00
diff --git a/SqlServerSimulator.Tests.EFCore/EFCoreBasics.cs b/SqlServerSimulator.Tests.EFCore/EFCoreBasics.cs
@@ -13,21 +13,29 @@ public static async Task HotPath(TestContext context)
 
         // Triggers JIT compilation of the most common path among all tests, improving the accuracy of their timings.
         // Also functions as a sanity check against the simulator being completely broken.
-        using var dbContext = new TestDbContext();
-
-        Assert.IsEmpty(dbContext.Rows.Select(x => x.Id).AsEnumerable());
-
-        Assert.AreEqual(0, await dbContext.SaveChangesAsync(context.CancellationToken));
+        using var dbContext = new TestDbContext(1);
+        _ = await dbContext.Rows.Select(x => x.Id).FirstOrDefaultAsync(context.CancellationToken);
     }
 
-    public static Simulation CreateDefaultSimulation()
+    public static Simulation CreateDefaultSimulation(params ReadOnlySpan<int> values)
     {
         var simulation = new Simulation();
         _ = simulation
             .CreateOpenConnection()
             .CreateCommand("create table Rows ( Id int )")
             .ExecuteNonQuery();
 
+        if (values.Length != 0)
+        {
+            using var context = new TestDbContext(simulation);
+            foreach (var value in values)
+            {
+                var row = new TestRow { Id = value };
+                _ = context.Rows.Add(row);
+                _ = context.SaveChanges();
+            }
+        }
+
         return simulation;
     }
 
@@ -40,8 +48,8 @@ class TestDbContext(Simulation simulation) : DbContext
     {
         public Simulation Simulation { get; set; } = simulation;
 
-        public TestDbContext()
-            : this(CreateDefaultSimulation())
+        public TestDbContext(params ReadOnlySpan<int> values)
+            : this(CreateDefaultSimulation(values))
         {
         }
 
@@ -56,13 +64,7 @@ protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
     [TestMethod]
     public void InsertRowSync()
     {
-        using var context = new TestDbContext();
-
-        var row = new TestRow { Id = 1 };
-
-        _ = context.Rows.Add(row);
-
-        _ = context.SaveChanges();
+        using var context = new TestDbContext(1);
     }
 
     /// <summary>
@@ -84,69 +86,48 @@ public async Task InsertRowAsync()
     [TestMethod]
     public void RoundTrip()
     {
-        var simulation = CreateDefaultSimulation();
         const int storedValue = 3;
+        using var context = new TestDbContext(storedValue);
+        var receivedValue = context.Rows.Select(x => x.Id).AsEnumerable();
 
-        using (var context = new TestDbContext(simulation))
-        {
-            var row = new TestRow { Id = storedValue };
-
-            _ = context.Rows.Add(row);
-
-            _ = context.SaveChanges();
-        }
-
-        using (var context = new TestDbContext(simulation))
-        {
-            var receivedValue = context.Rows.Select(x => x.Id).AsEnumerable();
-
-            Assert.AreEqual(storedValue, receivedValue.FirstOrDefault());
-        }
+        Assert.AreEqual(storedValue, receivedValue.FirstOrDefault());
     }
 
     [TestMethod]
     public void SeparateInserts()
     {
-        var simulation = CreateDefaultSimulation();
         int[] storedValues = [2, 3];
-
-        using (var context = new TestDbContext(simulation))
-        {
-            foreach (var value in storedValues)
-            {
-                var row = new TestRow { Id = value };
-                _ = context.Rows.Add(row);
-                _ = context.SaveChanges();
-            }
-        }
-
-        using (var context = new TestDbContext(simulation))
-        {
-            CollectionAssert.AreEquivalent(storedValues, context.Rows.Select(x => x.Id).ToArray());
-        }
+        using var context = new TestDbContext(storedValues);
+        CollectionAssert.AreEquivalent(storedValues, context.Rows.Select(x => x.Id).ToArray());
     }
 
     [TestMethod]
     public void FirstOrDefault()
     {
-        var simulation = CreateDefaultSimulation();
         int[] storedValues = [4, 5];
+        using var context = new TestDbContext(storedValues);
+        var receivedValue = context.Rows.Select(x => x.Id);
+        // Without an OrderBy, we can't guarantee which of the two possibilities is returned.
+        CollectionAssert.Contains(storedValues, receivedValue.FirstOrDefault());
+    }
 
-        using (var context = new TestDbContext(simulation))
-        {
-            foreach (var value in storedValues)
-            {
-                var row = new TestRow { Id = value };
-                _ = context.Rows.Add(row);
-                _ = context.SaveChanges();
-            }
-        }
+    [TestMethod]
+    public void SingleOrDefault()
+    {
+        const int storedValue = 6;
+        using var context = new TestDbContext(storedValue);
+        var receivedValue = context.Rows.Select(x => x.Id);
+        // Without an OrderBy, we can't guarantee which of the two possibilities is returned.
+        Assert.AreEqual(storedValue, receivedValue.SingleOrDefault());
+    }
 
-        using (var context = new TestDbContext(simulation))
-        {
-            var receivedValue = context.Rows.Select(x => x.Id);
-            // Without an OrderBy, we can't guarantee which of the two possibilities is returned.
-            CollectionAssert.Contains(storedValues, receivedValue.FirstOrDefault());
-        }
+    [TestMethod]
+    public void Take()
+    {
+        int[] storedValues = [4, 5];
+        using var context = new TestDbContext(storedValues);
+        var receivedValue = context.Rows.Select(x => x.Id);
+        // Without an OrderBy, we can't guarantee which of the two possibilities is returned.
+        CollectionAssert.Contains(storedValues, receivedValue.Take(1).AsEnumerable().First());
     }
 }
diff --git a/SqlServerSimulator.Tests/SelectTests.cs b/SqlServerSimulator.Tests/SelectTests.cs
@@ -33,6 +33,7 @@ public void Select1ViaExecuteReaderGetInt32()
     [TestMethod]
     [DataRow("select @p0", "p0", 5)]
     [DataRow("select @p0", "@p0", 6)]
+    [DataRow("select (@p0)", "p0", 7)]
     public void SelectParameterValue(string commandText, string name, object value)
     {
         var result = new Simulation()
@@ -44,6 +45,10 @@ public void SelectParameterValue(string commandText, string name, object value)
     }
 
     [TestMethod]
+    [DataRow("1", 1)]
+    [DataRow("(1)", 1)]
+    [DataRow("(1) + 1", 2)]
+    [DataRow("(1) + (1)", 2)]
     [DataRow("1 + 1", 2)]
     [DataRow("1 - 1", 0)]
     [DataRow("-1", -1)]
@@ -73,7 +78,7 @@ public void BareAs()
     [DataRow("select 1 as [c]]d]", "c]d", 1)]
     [DataRow("select 1 as [e f]", "e f", 1)]
     [DataRow("select 1 + 1 as c", "c", 2)]
-    public void Expression(string commandText, string name, object value)
+    public void NamedExpression(string commandText, string name, object value)
     {
         using var reader = new Simulation().ExecuteReader(commandText);
 
@@ -229,15 +234,29 @@ public void DerivedTable(string commandText, string name, object value)
     }
 
     [TestMethod]
-    public void TopParenthesizedConstantUnsorted()
+    [DataRow("1", new[] { 1 })]
+    [DataRow("0", new int[] { })]
+    [DataRow("(1)", new[] { 1 })]
+    [DataRow("(0)", new int[] { })]
+    public void TopConstantUnsorted(string topExpression, int[] expectedValues)
     {
-        CollectionAssert.AreEquivalent([1], [.. new Simulation()
-            .ExecuteReader("select top (1) 1")
+        CollectionAssert.AreEquivalent(expectedValues, [.. new Simulation()
+            .ExecuteReader($"select top {topExpression} 1")
             .EnumerateRecords()
             .Select(reader => (int)reader[0])], EqualityComparer<int>.Default);
+    }
 
-        CollectionAssert.AreEquivalent([], [.. new Simulation()
-            .ExecuteReader("select top (0) 1")
+    [TestMethod]
+    [DataRow("@p0", 1, new[] { 1 })]
+    [DataRow("(@p0)", 1, new[] { 1 })]
+    [DataRow("@p0", 0, new int[] { })]
+    [DataRow("(@p0)", 0, new int[] { })]
+    public void TopParameterizedUnsorted(string parameterExpression, int parameterValue, int[] expectedValues)
+    {
+        CollectionAssert.AreEquivalent(expectedValues, [.. new Simulation()
+            .CreateOpenConnection()
+            .CreateCommand($"select top {parameterExpression} 1", ("p0", parameterValue))
+            .ExecuteReader()
             .EnumerateRecords()
             .Select(reader => (int)reader[0])], EqualityComparer<int>.Default);
     }
diff --git a/SqlServerSimulator/Parser/Expression.cs b/SqlServerSimulator/Parser/Expression.cs
@@ -54,6 +54,10 @@ public static Expression Parse(ParserContext context)
                 expression = Parse(context);
                 expression = new Subtract(new Value(0), expression);
                 break;
+            case Operator { Character: '(' }:
+                context.MoveNextRequired();
+                expression = new Parenthesized(Parse(context));
+                break;
             default:
                 throw SimulatedSqlException.SyntaxErrorNear(context.Token);
         }
@@ -84,7 +88,11 @@ public static Expression Parse(ParserContext context)
                 case Operator { Character: '(' }:
                     {
                         if (expression is not Reference reference)
-                            throw SimulatedSqlException.SyntaxErrorNear(context.Token);
+                        {
+                            expression = new Parenthesized(Parse(context));
+                            break;
+                        }
+
                         context.MoveNextRequired(); // Move past (
                         expression = ResolveBuiltIn(reference.Name, context);
                         context.MoveNextOptional(); // Move past )
@@ -115,6 +123,20 @@ public static Expression Parse(ParserContext context)
     public abstract override string ToString();
 #endif
 
+    /// <summary>
+    /// An expression that's wrapped in parentheses, potentially affecting the order of operations.
+    /// </summary>
+    private sealed class Parenthesized(Expression wrapped) : Expression
+    {
+        private readonly Expression wrapped = wrapped;
+
+        public override object? Run(Func<List<string>, object?> getColumnValue) => wrapped.Run(getColumnValue);
+
+#if DEBUG
+        public override string ToString() => $"( {wrapped} )";
+#endif
+    }
+
     private static Expression ResolveBuiltIn(string name, ParserContext context)
     {
         Span<char> uppercaseName = stackalloc char[name.Length];
diff --git a/SqlServerSimulator/Parser/Selection.cs b/SqlServerSimulator/Parser/Selection.cs
@@ -27,19 +27,10 @@ public static Selection Parse(ParserContext context, uint depth)
 
         if (context.Token is ReservedKeyword { Keyword: Keyword.Top })
         {
-            // SQL Server doesn't require outer parentheses.
-            // When Expression.Parse supports them, the checks for them here should be removed.
-            if (context.GetNextRequired<Operator>() is not { Character: '(' })
-                throw SimulatedSqlException.SyntaxErrorNear(context.Token);
             context.MoveNextRequired();
 
             var resolvedExpression = Expression.Parse(context).Run(name => throw SimulatedSqlException.ColumnReferenceNotAllowed(name));
             topCount = resolvedExpression is int unboxed ? unboxed : throw SimulatedSqlException.TopFetchRequiresInteger();
-
-            if (context.Token is not null and not Operator { Character: ')' })
-                throw SimulatedSqlException.SyntaxErrorNear(context.Token);
-
-            context.MoveNextRequired();
         }
 
         List<Expression> expressions = [];
