Initial support for WHERE.

Author: RyanLamansky

.editorconfig

@@ -14,4 +14,5 @@ dotnet_diagnostic.IDE0010.severity = none # Add missing cases
 dotnet_diagnostic.IDE0021.severity = none # Use block body for constructor
 dotnet_diagnostic.IDE0022.severity = none # Use block body for method
 dotnet_diagnostic.IDE0040.severity = none # Add accessibility modifiers
+dotnet_diagnostic.IDE0061.severity = none # Use block body for local function
 dotnet_diagnostic.IDE0072.severity = none # Add missing cases

SqlServerSimulator.Tests/WhereTests.cs

@@ -0,0 +1,15 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+[TestClass]
+public class WhereTests
+{
+    [TestMethod]
+    [DataRow("1 = 0", 0)]
+    [DataRow("1 = 1", 1)]
+    public void PureExpressionFilter(string whereExpression, int expectedCount)
+    {
+        AreEqual(expectedCount, new Simulation().ExecuteReader($"select 1 where {whereExpression}").EnumerateRecords().Count());
+    }
+}

SqlServerSimulator/Parser/BooleanExpression.cs

@@ -0,0 +1,50 @@
+using SqlServerSimulator.Parser.Tokens;
+
+namespace SqlServerSimulator.Parser;
+
+/// <summary>
+/// A specific type of expression used in WHERE clauses and similar branching scenarios.
+/// </summary>
+internal abstract class BooleanExpression
+{
+    private protected BooleanExpression()
+    {
+    }
+
+    public static BooleanExpression Parse(ParserContext context)
+    {
+        var left = Expression.Parse(context);
+
+        switch (context.Token)
+        {
+            case null:
+                break;
+            case Operator { Character: '=' }:
+                context.MoveNextRequired();
+                return new EqualityExpression(left, Expression.Parse(context));
+        }
+
+        throw SimulatedSqlException.SyntaxErrorNear(context);
+    }
+
+    /// <summary>
+    /// Runs the expression, returning its result.
+    /// </summary>
+    /// <param name="getColumnValue">Provides the value for a column.</param>
+    /// <returns>The result of the expression.</returns>
+    public abstract bool Run(Func<List<string>, object?> getColumnValue);
+
+#if DEBUG
+    public abstract override string ToString();
+#endif
+
+    private sealed class EqualityExpression(Expression left, Expression right) : BooleanExpression
+    {
+        public override bool Run(Func<List<string>, object?> getColumnValue) =>
+            (left.Run(getColumnValue)?.Equals(right.Run(getColumnValue))).GetValueOrDefault();
+
+#if DEBUG
+        public override string ToString() => $"{left} = {right}";
+#endif
+    }
+}

SqlServerSimulator/Parser/Selection.cs

@@ -34,9 +34,23 @@ public static Selection Parse(ParserContext context, uint depth)
         }
 
         List<Expression> expressions = [];
+        List<BooleanExpression> excluders = [];
 
-        IEnumerable<object?[]> ApplyClauses(IEnumerable<object?[]> records)
+        IEnumerable<object?[]> ApplyClauses(IEnumerable<object?[]> records, Func<object?[], List<string>, object?> getColumnValueFromRow)
         {
+            records = records.Where(row =>
+            {
+                foreach (var excluder in excluders)
+                {
+                    if (!excluder.Run(columnName => getColumnValueFromRow(row, columnName)))
+                        return false;
+                }
+
+                return true;
+            }).Select<object?[], object?[]>(row =>
+                [.. expressions.Select(x => x.Run(columnName => getColumnValueFromRow(row, columnName)))]
+            );
+
             if (topCount is not null)
                 records = records.Take(topCount.GetValueOrDefault());
 
@@ -105,11 +119,11 @@ public static Selection Parse(ParserContext context, uint depth)
 
                             return new(new(
                                 expressions,
-                                ApplyClauses(table.Rows.Select<object?[], object?[]>(row => [..expressions.Select(x => x.Run(columnName =>
+                                ApplyClauses(table.Rows, (row, columnName) =>
                                 {
                                     var columnIndex = table.Columns.FindIndex(column => Collation.Default.Equals(column.Name, columnName.Last()));
                                     return columnIndex == -1 ? throw SimulatedSqlException.InvalidColumnName(columnName) : row[columnIndex];
-                                }))]))
+                                })
                                 ));
 
                         case Operator { Character: '(' }:
@@ -131,16 +145,21 @@ public static Selection Parse(ParserContext context, uint depth)
 
                                 return new(new(
                                     expressions,
-                                    ApplyClauses(derived.Select<object?[], object?[]>(row => [..expressions.Select(x => x.Run(columnName =>
+                                    ApplyClauses(derived.records, (row, columnName) =>
                                     {
                                         var columnIndex = Array.FindIndex(derived.columnNames, name => Collation.Default.Equals(name, columnName.Last()));
                                         return columnIndex == -1 ? throw SimulatedSqlException.InvalidColumnName(columnName) : row[columnIndex];
-                                    }))]))
+                                    })
                                     ));
                             }
                     }
 
                     throw SimulatedSqlException.SyntaxErrorNear(context);
+
+                case ReservedKeyword { Keyword: Keyword.Where }:
+                    context.MoveNextRequired();
+                    excluders.Add(BooleanExpression.Parse(context));
+                    continue;
             }
 
             throw SimulatedSqlException.SyntaxErrorNear(context);
@@ -149,7 +168,7 @@ public static Selection Parse(ParserContext context, uint depth)
 
         return new(new(
             expressions,
-            ApplyClauses([[.. expressions.Select(x => x.Run(column => throw SimulatedSqlException.InvalidColumnName(column)))]])
+            ApplyClauses([[.. expressions.Select(x => x.Run(column => throw SimulatedSqlException.InvalidColumnName(column)))]], (row, columnName) => throw new NotSupportedException())
             ));
     }
 }

SqlServerSimulator/Parser/Tokenizer.cs

@@ -24,7 +24,7 @@ static class Tokenizer
             '@' => ParseAtOrDoubleAtPrefixedString(command, ref index),
             '-' => ParseMinusOrComment(command, ref index),
             '[' => ParseBracketDelimitedString(command, ref index),
-            '+' or '*' or '(' or ')' or ',' or '.' or ';' => new Operator(command, index),
+            '+' or '*' or '(' or ')' or ',' or '.' or ';' or '=' => new Operator(command, index),
             var c => throw SimulatedSqlException.SyntaxErrorNear(c) // Might throw on valid-but-unsupported syntax.
         };