Added subtraction and number sign indicator support.

Author: RyanLamansky

SqlServerSimulator.Tests/SelectTests.cs

@@ -44,11 +44,18 @@ public void SelectParameterValue(string commandText, string name, object value)
     }
 
     [TestMethod]
-    public void Select1Plus1()
+    [DataRow("1 + 1", 2)]
+    [DataRow("1 - 1", 0)]
+    [DataRow("-1", -1)]
+    [DataRow("- 1", -1)]
+    [DataRow("+1", 1)]
+    [DataRow("+ 1", 1)]
+    public void Expression(string commandText, object value)
     {
-        var result = new Simulation().ExecuteScalar("select 1 + 1");
+        using var reader = new Simulation().ExecuteReader($"select {commandText}");
 
-        Assert.AreEqual(2, result);
+        Assert.IsTrue(reader.Read());
+        Assert.AreEqual(value, reader[0]);
     }
 
     [TestMethod]

SqlServerSimulator/Parser/Expression.cs

@@ -58,17 +58,44 @@ public static Expression Parse(Simulation simulation, IEnumerator<Token> tokens,
                     break;
                 case Plus:
                     if (expression is null)
-                        throw new NotSupportedException("Simulated expression parser doesn't know how to handle + at the start of an expression.");
+                    {
+                        token = tokens.RequireNext();
+                        expression = Expression.Parse(simulation, tokens, ref token, getVariableValue);
+                        break;
+                    }
+
+                    token = tokens.RequireNext();
+
+                    {
+                        var parsed = Parse(simulation, tokens, ref token, getVariableValue);
+                        expression = new Add(expression, parsed);
+                        if (parsed is NamedExpression named)
+                            expression = named.TransferName(expression);
+                    }
+
+                    tokenWasRead = true;
+                    break;
+                case Minus:
+                    if (expression is null)
+                    {
+                        token = tokens.RequireNext();
+                        expression = Expression.Parse(simulation, tokens, ref token, getVariableValue);
+                        expression = new Subtract(new Value(0), expression);
+                        break;
+                    }
 
                     token = tokens.RequireNext();
 
-                    var parsed = Parse(simulation, tokens, ref token, getVariableValue);
-                    expression = new Add(expression, parsed);
-                    if (parsed is NamedExpression named)
-                        expression = named.TransferName(expression);
+                    {
+                        var parsed = Parse(simulation, tokens, ref token, getVariableValue);
+                        expression = new Subtract(expression, parsed);
+                        if (parsed is NamedExpression named)
+                            expression = named.TransferName(expression);
+                    }
 
                     tokenWasRead = true;
                     break;
+
                 case Period:
                     if (expression is null)
                         throw new NotSupportedException("Simulated expression parser doesn't know how to handle '.' at the start of an expression.");
@@ -161,9 +188,11 @@ public Value()
         {
         }
 
+        public Value(object? value) => this.value = value;
+
         public Value(Numeric value)
+            : this(value.Value)
         {
-            this.value = value.Value;
         }
 
         public Value(AtPrefixedString atPrefixed, Func<string, object?> getVariableValue)
@@ -202,6 +231,23 @@ public sealed class Add(Expression left, Expression right) : Expression
             return (int)leftValue! + (int)rightValue!; // TODO: Handle varied input types here.
         }
 
+#if DEBUG
+        public override string ToString() => $"{left} + {right}";
+#endif
+    }
+
+    public sealed class Subtract(Expression left, Expression right) : Expression
+    {
+        private readonly Expression left = left, right = right;
+
+        public override object? Run(Func<List<string>, object?> getColumnValue)
+        {
+            var leftValue = left.Run(getColumnValue);
+            var rightValue = right.Run(getColumnValue);
+
+            return (int)leftValue! - (int)rightValue!; // TODO: Handle varied input types here.
+        }
+
 #if DEBUG
         public override string ToString() => $"{left} + {right}";
 #endif

SqlServerSimulator/Parser/Tokenizer.cs

@@ -30,6 +30,7 @@ public static IEnumerable<Token> Tokenize(string? command)
 
         while (commandEnumerator.TryGetNext(out var c, ref index))
         {
+        Switch:
             switch (c)
             {
                 default:
@@ -178,22 +179,23 @@ public static IEnumerable<Token> Tokenize(string? command)
                         continue;
                     }
 
-                    switch (c)
+                    if (c == '-')
                     {
-                        case '-':
-                            while (commandEnumerator.TryGetNext(out c, ref index))
+                        while (commandEnumerator.TryGetNext(out c, ref index))
+                        {
+                            switch (c)
                             {
-                                switch (c)
-                                {
-                                    case '\r':
-                                    case '\n':
-                                        yield return new Comment();
-                                        continue;
-                                }
+                                case '\r':
+                                case '\n':
+                                    yield return new Comment();
+                                    continue;
                             }
-                            continue;
+                        }
+                        continue;
                     }
-                    break;
+
+                    yield return new Minus();
+                    goto Switch; // Can't immediately think of a better way to do this that doesn't involve new variables.
 
                 case '*':
                     yield return new Asterisk();