Implemented bitwise and, or, exclusive or.

Author: RyanLamansky

SqlServerSimulator.Tests/SelectTests.cs

@@ -58,6 +58,9 @@ public void SelectParameterValue(string commandText, string name, object value)
     [DataRow("2 * 2", 4)]
     [DataRow("2 / 2", 1)]
     [DataRow("2 / 1", 2)]
+    [DataRow("1 & 3", 1)]
+    [DataRow("1 | 3", 3)]
+    [DataRow("1 ^ 3", 2)]
     public void Expression(string commandText, object value)
     {
         using var reader = new Simulation().ExecuteReader($"select {commandText}");

SqlServerSimulator/Parser/Expression.cs

@@ -82,6 +82,18 @@ public static Expression Parse(ParserContext context)
                     context.MoveNextRequired();
                     expression = new Divide(expression, Parse(context));
                     break;
+                case Operator { Character: '&' }:
+                    context.MoveNextRequired();
+                    expression = new BitwiseAnd(expression, Parse(context));
+                    break;
+                case Operator { Character: '|' }:
+                    context.MoveNextRequired();
+                    expression = new BitwiseOr(expression, Parse(context));
+                    break;
+                case Operator { Character: '^' }:
+                    context.MoveNextRequired();
+                    expression = new BitwiseExclusiveOr(expression, Parse(context));
+                    break;
 
                 case Operator { Character: '.' }:
                     {
@@ -225,71 +237,82 @@ public Value(DoubleAtPrefixedString doubleAtPrefixedString)
 #endif
     }
 
-    public sealed class Add(Expression left, Expression right) : Expression
+    public abstract class TwoSidedExpression(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);
+        public sealed override object? Run(Func<List<string>, object?> getColumnValue)
+            => Run(left.Run(getColumnValue), right.Run(getColumnValue));
 
-            return (int)leftValue! + (int)rightValue!; // TODO: Handle varied input types here.
-        }
+        protected abstract object? Run(object? left, object? right);
 
 #if DEBUG
-        public override string ToString() => $"{left} + {right}";
+        protected abstract char Operator { get; }
+
+        public sealed override string ToString() => $"{left} {Operator} {right}";
 #endif
     }
 
-    public sealed class Subtract(Expression left, Expression right) : Expression
+    public sealed class Add(Expression left, Expression right) : TwoSidedExpression(left, right)
     {
-        private readonly Expression left = left, right = right;
+        protected override object? Run(object? left, object? right) => (int)left! + (int)right!;
 
-        public override object? Run(Func<List<string>, object?> getColumnValue)
-        {
-            var leftValue = left.Run(getColumnValue);
-            var rightValue = right.Run(getColumnValue);
+#if DEBUG
+        protected override char Operator => '+';
+#endif
+    }
 
-            return (int)leftValue! - (int)rightValue!; // TODO: Handle varied input types here.
-        }
+    public sealed class Subtract(Expression left, Expression right) : TwoSidedExpression(left, right)
+    {
+        protected override object? Run(object? left, object? right) => (int)left! - (int)right!;
 
 #if DEBUG
-        public override string ToString() => $"{left} + {right}";
+        protected override char Operator => '-';
 #endif
     }
 
-    public sealed class Multiply(Expression left, Expression right) : Expression
+    public sealed class Multiply(Expression left, Expression right) : TwoSidedExpression(left, right)
     {
-        private readonly Expression left = left, right = right;
+        protected override object? Run(object? left, object? right) => (int)left! * (int)right!;
 
-        public override object? Run(Func<List<string>, object?> getColumnValue)
-        {
-            var leftValue = left.Run(getColumnValue);
-            var rightValue = right.Run(getColumnValue);
+#if DEBUG
+        protected override char Operator => '*';
+#endif
+    }
 
-            return (int)leftValue! * (int)rightValue!; // TODO: Handle varied input types here.
-        }
+    public sealed class Divide(Expression left, Expression right) : TwoSidedExpression(left, right)
+    {
+        protected override object? Run(object? left, object? right) => (int)left! / (int)right!;
 
 #if DEBUG
-        public override string ToString() => $"{left} + {right}";
+        protected override char Operator => '/';
 #endif
     }
 
-    public sealed class Divide(Expression left, Expression right) : Expression
+    public sealed class BitwiseAnd(Expression left, Expression right) : TwoSidedExpression(left, right)
     {
-        private readonly Expression left = left, right = right;
+        protected override object? Run(object? left, object? right) => (int)left! & (int)right!;
 
-        public override object? Run(Func<List<string>, object?> getColumnValue)
-        {
-            var leftValue = left.Run(getColumnValue);
-            var rightValue = right.Run(getColumnValue);
+#if DEBUG
+        protected override char Operator => '&';
+#endif
+    }
 
-            return (int)leftValue! / (int)rightValue!; // TODO: Handle varied input types here.
-        }
+    public sealed class BitwiseOr(Expression left, Expression right) : TwoSidedExpression(left, right)
+    {
+        protected override object? Run(object? left, object? right) => (int)left! | (int)right!;
+
+#if DEBUG
+        protected override char Operator => '|';
+#endif
+    }
+
+    public sealed class BitwiseExclusiveOr(Expression left, Expression right) : TwoSidedExpression(left, right)
+    {
+        protected override object? Run(object? left, object? right) => (int)left! ^ (int)right!;
 
 #if DEBUG
-        public override string ToString() => $"{left} + {right}";
+        protected override char Operator => '^';
 #endif
     }
 

SqlServerSimulator/Parser/Tokenizer.cs

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