Moved nested Expression types to their own files.

Author: RyanLamansky

SqlServerSimulator/Parser/Expression.cs

@@ -1,4 +1,5 @@
-using SqlServerSimulator.Parser.Tokens;
+using SqlServerSimulator.Parser.Expressions;
+using SqlServerSimulator.Parser.Tokens;
 
 namespace SqlServerSimulator.Parser;
 
@@ -150,20 +151,6 @@ 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 DataValue Run(Func<List<string>, DataValue> 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];
@@ -182,220 +169,4 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
             _ => (Expression?)null
         } ?? throw SimulatedSqlException.UnrecognizedBuiltInFunction(name);
     }
-
-    /// <summary>
-    /// An expression that has been given a name, such as with `as`.
-    /// </summary>
-    /// <param name="expression">The expression to be named.</param>
-    /// <param name="name">The name of the expression, exposed via the <see cref="Name"/> property.</param>
-    private sealed class NamedExpression(Expression expression, string name) : Expression
-    {
-        private readonly Expression expression = expression;
-        private readonly string name = name;
-
-        public override string Name => this.name;
-
-        public override byte Precedence => expression.Precedence;
-
-        public override DataValue Run(Func<List<string>, DataValue> getColumnValue) => this.expression.Run(getColumnValue);
-
-#if DEBUG
-        public override string ToString() => $"{expression} {name}";
-#endif
-    }
-
-    /// <summary>
-    /// Values are resolved at parse time.
-    /// </summary>
-    private sealed class Value : Expression
-    {
-        private readonly DataValue value;
-
-        public Value()
-        {
-        }
-
-        public Value(DataValue value) => this.value = value;
-
-        public Value(AtPrefixedString atPrefixed, ParserContext context)
-        {
-            this.value = context.GetVariableValue(atPrefixed.Value);
-        }
-
-        public Value(DoubleAtPrefixedString doubleAtPrefixedString)
-        {
-            switch (doubleAtPrefixedString.Parse())
-            {
-                case AtAtKeyword.Version:
-                    this.value = new("SQL Server Simulator", DataType.BuiltInDbString);
-                    return;
-            }
-
-            throw new NotSupportedException($"Simulator doesn't recognize {doubleAtPrefixedString}.");
-        }
-
-        public override DataValue Run(Func<List<string>, DataValue> getColumnValue) => value;
-
-#if DEBUG
-        public override string ToString() => value.Value?.ToString() ?? "null";
-#endif
-    }
-
-    private abstract class TwoSidedExpression(Expression left, Expression right) : Expression
-    {
-        private Expression right = right, left = left;
-
-        public TwoSidedExpression AdjustForPrecedence()
-        {
-            if (this.right is not TwoSidedExpression rightTwo || rightTwo.Precedence < this.Precedence)
-                return this;
-
-            (rightTwo.left, this.right) = (this, rightTwo.left);
-            return rightTwo;
-        }
-
-        public sealed override DataValue Run(Func<List<string>, DataValue> getColumnValue)
-            => Run(left.Run(getColumnValue), right.Run(getColumnValue));
-
-        protected abstract DataValue Run(DataValue left, DataValue right);
-        protected abstract char Operator { get; }
-
-#if DEBUG
-        public sealed override string ToString() => $"{left} {Operator} {right}";
-#endif
-    }
-
-    private abstract class MathExpression(Expression left, Expression right) : TwoSidedExpression(left, right)
-    {
-        protected abstract DataValue Run(DataType.NumericCompatibleDataType common, DataValue left, DataValue right);
-
-        protected sealed override DataValue Run(DataValue left, DataValue right) => Run(DataType.CommonNumeric(left, right, this.Operator), left, right);
-    }
-
-    private sealed class Add(Expression left, Expression right) : MathExpression(left, right)
-    {
-        public override byte Precedence => 3;
-
-        protected override DataValue Run(DataType.NumericCompatibleDataType common, DataValue left, DataValue right) => common.Add(left, right);
-
-        protected override char Operator => '+';
-    }
-
-    private sealed class Subtract(Expression left, Expression right) : MathExpression(left, right)
-    {
-        public override byte Precedence => 3;
-
-        protected override DataValue Run(DataType.NumericCompatibleDataType common, DataValue left, DataValue right) => common.Subtract(left, right);
-
-        protected override char Operator => '-';
-    }
-
-    private sealed class Multiply(Expression left, Expression right) : MathExpression(left, right)
-    {
-        public override byte Precedence => 2;
-
-        protected override DataValue Run(DataType.NumericCompatibleDataType common, DataValue left, DataValue right) => common.Multiply(left, right);
-
-        protected override char Operator => '*';
-    }
-
-    private sealed class Divide(Expression left, Expression right) : MathExpression(left, right)
-    {
-        public override byte Precedence => 2;
-
-        protected override DataValue Run(DataType.NumericCompatibleDataType common, DataValue left, DataValue right) => common.Divide(left, right);
-
-        protected override char Operator => '/';
-    }
-
-    private abstract class BitwiseExpression(Expression left, Expression right) : TwoSidedExpression(left, right)
-    {
-        protected abstract DataValue Run(DataType.BitwiseCompatibleDataType common, DataValue left, DataValue right);
-
-        protected sealed override DataValue Run(DataValue left, DataValue right) => Run(DataType.CommonInteger(left, right, this.Operator), left, right);
-    }
-
-    private sealed class BitwiseAnd(Expression left, Expression right) : BitwiseExpression(left, right)
-    {
-        public override byte Precedence => 3;
-
-        protected override DataValue Run(DataType.BitwiseCompatibleDataType common, DataValue left, DataValue right) => common.BitwiseAnd(left, right);
-
-        protected override char Operator => '&';
-    }
-
-    private sealed class BitwiseOr(Expression left, Expression right) : BitwiseExpression(left, right)
-    {
-        public override byte Precedence => 3;
-
-        protected override DataValue Run(DataType.BitwiseCompatibleDataType common, DataValue left, DataValue right) => common.BitwiseOr(left, right);
-
-        protected override char Operator => '|';
-    }
-
-    private sealed class BitwiseExclusiveOr(Expression left, Expression right) : BitwiseExpression(left, right)
-    {
-        public override byte Precedence => 3;
-
-        protected override DataValue Run(DataType.BitwiseCompatibleDataType common, DataValue left, DataValue right) => common.BitwiseExclusiveOr(left, right);
-
-        protected override char Operator => '^';
-    }
-
-    private sealed class Reference(Name name) : Expression
-    {
-        private readonly List<string> name = [name.Value];
-
-        public override string Name => this.name[^1];
-
-        public void AddMultiPartComponent(Name name) => this.name.Add(name.Value);
-
-        public override DataValue Run(Func<List<string>, DataValue> getColumnValue) => getColumnValue(this.name);
-
-#if DEBUG
-        public override string ToString() => string.Join('.', name);
-#endif
-    }
-
-    /// <summary>
-    /// Encapsulates the SQL DATALENGTH command: https://learn.microsoft.com/en-us/sql/t-sql/functions/datalength-transact-sql
-    /// </summary>
-    private sealed class DataLength(ParserContext context) : Expression
-    {
-        private readonly Expression source = Parse(context);
-
-        public override DataValue Run(Func<List<string>, DataValue> getColumnValue)
-        {
-            var value = source.Run(getColumnValue);
-            return value.Value is null ? default : new(value.Type.DataLength(value));
-        }
-
-#if DEBUG
-        public override string ToString() => $"DATALENGTH({source})";
-#endif
-    }
-
-    /// <summary>
-    /// Encapsulates the SQL ABS command: https://learn.microsoft.com/en-us/sql/t-sql/functions/abs-transact-sql
-    /// </summary>
-    private sealed class AbsoluteValue(ParserContext context) : Expression
-    {
-        private readonly Expression source = Parse(context);
-
-        public override DataValue Run(Func<List<string>, DataValue> getColumnValue)
-        {
-            var value = source.Run(getColumnValue);
-
-            return new(value.Value switch
-            {
-                null => value.Value,
-                int v => Math.Abs(v),
-                _ => throw new NotSupportedException($"Simulation unable to to run ABS function on the provided expression."),
-            }, value.Type);
-        }
-
-#if DEBUG
-        public override string ToString() => $"ABS({source})";
-#endif
-    }
 }

SqlServerSimulator/Parser/Expressions/AbsoluteValue.cs

@@ -0,0 +1,25 @@
+namespace SqlServerSimulator.Parser.Expressions;
+
+/// <summary>
+/// Encapsulates the SQL ABS command: https://learn.microsoft.com/en-us/sql/t-sql/functions/abs-transact-sql
+/// </summary>
+internal sealed class AbsoluteValue(ParserContext context) : Expression
+{
+    private readonly Expression source = Parse(context);
+
+    public override DataValue Run(Func<List<string>, DataValue> getColumnValue)
+    {
+        var value = source.Run(getColumnValue);
+
+        return new(value.Value switch
+        {
+            null => value.Value,
+            int v => Math.Abs(v),
+            _ => throw new NotSupportedException($"Simulation unable to to run ABS function on the provided expression."),
+        }, value.Type);
+    }
+
+#if DEBUG
+    public override string ToString() => $"ABS({source})";
+#endif
+}

SqlServerSimulator/Parser/Expressions/Add.cs

@@ -0,0 +1,10 @@
+namespace SqlServerSimulator.Parser.Expressions;
+
+internal sealed class Add(Expression left, Expression right) : MathExpression(left, right)
+{
+    public override byte Precedence => 3;
+
+    protected override DataValue Run(DataType.NumericCompatibleDataType common, DataValue left, DataValue right) => common.Add(left, right);
+
+    protected override char Operator => '+';
+}

SqlServerSimulator/Parser/Expressions/BitwiseAnd.cs

@@ -0,0 +1,10 @@
+namespace SqlServerSimulator.Parser.Expressions;
+
+internal sealed class BitwiseAnd(Expression left, Expression right) : BitwiseExpression(left, right)
+{
+    public override byte Precedence => 3;
+
+    protected override DataValue Run(DataType.BitwiseCompatibleDataType common, DataValue left, DataValue right) => common.BitwiseAnd(left, right);
+
+    protected override char Operator => '&';
+}

SqlServerSimulator/Parser/Expressions/BitwiseExclusiveOr.cs

@@ -0,0 +1,10 @@
+namespace SqlServerSimulator.Parser.Expressions;
+
+internal sealed class BitwiseExclusiveOr(Expression left, Expression right) : BitwiseExpression(left, right)
+{
+    public override byte Precedence => 3;
+
+    protected override DataValue Run(DataType.BitwiseCompatibleDataType common, DataValue left, DataValue right) => common.BitwiseExclusiveOr(left, right);
+
+    protected override char Operator => '^';
+}

SqlServerSimulator/Parser/Expressions/BitwiseExpression.cs

@@ -0,0 +1,8 @@
+namespace SqlServerSimulator.Parser.Expressions;
+
+internal abstract class BitwiseExpression(Expression left, Expression right) : TwoSidedExpression(left, right)
+{
+    protected abstract DataValue Run(DataType.BitwiseCompatibleDataType common, DataValue left, DataValue right);
+
+    protected sealed override DataValue Run(DataValue left, DataValue right) => Run(DataType.CommonInteger(left, right, this.Operator), left, right);
+}

SqlServerSimulator/Parser/Expressions/BitwiseOr.cs

@@ -0,0 +1,10 @@
+namespace SqlServerSimulator.Parser.Expressions;
+
+internal sealed class BitwiseOr(Expression left, Expression right) : BitwiseExpression(left, right)
+{
+    public override byte Precedence => 3;
+
+    protected override DataValue Run(DataType.BitwiseCompatibleDataType common, DataValue left, DataValue right) => common.BitwiseOr(left, right);
+
+    protected override char Operator => '|';
+}

SqlServerSimulator/Parser/Expressions/DataLength.cs

@@ -0,0 +1,19 @@
+namespace SqlServerSimulator.Parser.Expressions;
+
+/// <summary>
+/// Encapsulates the SQL DATALENGTH command: https://learn.microsoft.com/en-us/sql/t-sql/functions/datalength-transact-sql
+/// </summary>
+internal sealed class DataLength(ParserContext context) : Expression
+{
+    private readonly Expression source = Parse(context);
+
+    public override DataValue Run(Func<List<string>, DataValue> getColumnValue)
+    {
+        var value = source.Run(getColumnValue);
+        return value.Value is null ? default : new(value.Type.DataLength(value));
+    }
+
+#if DEBUG
+    public override string ToString() => $"DATALENGTH({source})";
+#endif
+}

SqlServerSimulator/Parser/Expressions/Divide.cs

@@ -0,0 +1,10 @@
+namespace SqlServerSimulator.Parser.Expressions;
+
+internal sealed class Divide(Expression left, Expression right) : MathExpression(left, right)
+{
+    public override byte Precedence => 2;
+
+    protected override DataValue Run(DataType.NumericCompatibleDataType common, DataValue left, DataValue right) => common.Divide(left, right);
+
+    protected override char Operator => '/';
+}

SqlServerSimulator/Parser/Expressions/MathExpression.cs

@@ -0,0 +1,8 @@
+namespace SqlServerSimulator.Parser.Expressions;
+
+internal abstract class MathExpression(Expression left, Expression right) : TwoSidedExpression(left, right)
+{
+    protected abstract DataValue Run(DataType.NumericCompatibleDataType common, DataValue left, DataValue right);
+
+    protected sealed override DataValue Run(DataValue left, DataValue right) => Run(DataType.CommonNumeric(left, right, this.Operator), left, right);
+}