Added support for the DATALENGTH built-in function.

Author: RyanLamansky

SqlServerSimulator.Tests/BuiltInFunctionTests.cs

@@ -0,0 +1,23 @@
+using System.Data.Common;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+[TestClass]
+public sealed class BuiltInFunctionTests
+{
+    private static T ExecuteScalar<T>(string commandText) where T : struct => new Simulation().ExecuteScalar<T>(commandText);
+
+    [TestMethod]
+    public void UnrecognizedBuiltInFunction()
+    {
+        var exception = Throws<DbException>(() => ExecuteScalar<int>("select frog()"));
+        AreEqual("'frog' is not a recognized built-in function name.", exception.Message);
+    }
+
+    [TestMethod]
+    public void DataLength() => AreEqual(4, ExecuteScalar<int>("select datalength(1)"));
+
+    [TestMethod]
+    public void DataLengthAllCaps() => AreEqual(4, ExecuteScalar<int>("select DATALENGTH(1)"));
+}

SqlServerSimulator.Tests/Extensions.cs

@@ -39,10 +39,28 @@ public static DbConnection CreateOpenConnection(this Simulation simulation)
     }
 
     public static int ExecuteNonQuery(this Simulation simulation, string commandText)
-        => simulation.CreateCommand(commandText).ExecuteNonQuery();
+    {
+        using var connection = simulation.CreateOpenConnection();
+        using var command = connection.CreateCommand(commandText);
+        return command.ExecuteNonQuery();
+    }
 
     public static object? ExecuteScalar(this Simulation simulation, string commandText)
-        => simulation.CreateCommand(commandText).ExecuteScalar();
+    {
+        using var connection = simulation.CreateOpenConnection();
+        using var command = connection.CreateCommand(commandText);
+        return command.ExecuteScalar();
+    }
+
+    public static T ExecuteScalar<T>(this Simulation simulation, string commandText)
+        where T : struct
+    {
+        using var connection = simulation.CreateOpenConnection();
+        using var command = connection.CreateCommand(commandText);
+        var result = command.ExecuteScalar();
+        Assert.IsNotNull(result);
+        return Assert.IsInstanceOfType<T>(result);
+    }
 
     public static void ValidateSyntaxError(this Simulation simulation, string commandText, string nearSyntax)
     {

SqlServerSimulator/Parser/Expression.cs

@@ -1,4 +1,5 @@
 using SqlServerSimulator.Parser.Tokens;
+using System.Collections.Frozen;
 
 namespace SqlServerSimulator.Parser;
 
@@ -69,16 +70,30 @@ public static Expression Parse(Simulation simulation, IEnumerator<Token> tokens,
                     if (expression is null)
                         throw new NotSupportedException("Simulated expression parser doesn't know how to handle '.' at the start of an expression.");
 
-                    if (expression is not Reference reference)
-                        throw new NotSupportedException("Simulated expression parser doesn't know how to handle '.' here.");
+                    {
+                        if (expression is not Reference reference)
+                            throw new NotSupportedException("Simulated expression parser doesn't know how to handle '.' here.");
 
-                    reference.AddMultiPartComponent(tokens.RequireNext<Name>());
+                        reference.AddMultiPartComponent(tokens.RequireNext<Name>());
+                    }
                     break;
                 case Comma:
                 case CloseParentheses:
                     if (expression is null)
                         throw SimulatedSqlException.SyntaxErrorNear(token);
                     return expression;
+                case OpenParentheses:
+                    {
+                        if (expression is not Reference reference)
+                            throw SimulatedSqlException.SyntaxErrorNear(token);
+                        if (!BuiltInFunctions.TryGetValue(reference.Name, out var builtInFunction))
+                            throw SimulatedSqlException.UnrecognizedBuiltInFunction(reference.Name);
+
+                        token = tokens.RequireNext(); // Move past (
+                        expression = builtInFunction(simulation, tokens, ref token, getVariableValue);
+                        _ = tokens.TryMoveNext(out token); // Move past )
+                        return expression;
+                    }
                 default:
                     throw new NotSupportedException($"Simulated expression parser doesn't know how to handle '{token}'.");
             }
@@ -93,6 +108,12 @@ public static Expression Parse(Simulation simulation, IEnumerator<Token> tokens,
     public abstract override string ToString();
 #endif
 
+    private delegate Expression FunctionResolver(Simulation simulation, IEnumerator<Token> tokens, ref Token? token, Func<string, object?> getVariableValue);
+
+    private static readonly FrozenDictionary<string, FunctionResolver> BuiltInFunctions = FrozenDictionary.Create<string, FunctionResolver>(Collation.Default, [
+        new("datalength", (simulation, tokens, ref token, getVariableValue) => new DataLength(Expression.Parse(simulation, tokens, ref token, getVariableValue)))
+        ]);
+
     private sealed class NamedExpression(Expression expression, string name) : Expression
     {
         private readonly Expression expression = expression;
@@ -179,29 +200,34 @@ public sealed class Add(Expression left, Expression right) : Expression
 #endif
     }
 
-    public sealed class Reference : Expression
+    public sealed class Reference(Name name) : Expression
     {
-        private readonly List<string> name = [];
-
-        public Reference(Name name)
-        {
-            this.name.Add(name.Value);
-        }
+        private readonly List<string> name = [name.Value];
 
         public override string Name => this.name.Last();
 
-        public void AddMultiPartComponent(Name name)
-        {
-            this.name.Add(name.Value);
-        }
+        public void AddMultiPartComponent(Name name) => this.name.Add(name.Value);
 
-        public override object? Run(Func<List<string>, object?> getColumnValue)
-        {
-            return getColumnValue(this.name);
-        }
+        public override object? Run(Func<List<string>, object?> getColumnValue) => getColumnValue(this.name);
 
 #if DEBUG
         public override string ToString() => string.Join('.', name);
+#endif
+    }
+
+    public sealed class DataLength(Expression source) : Expression
+    {
+        private readonly Expression source = source;
+
+        public override object? Run(Func<List<string>, object?> getColumnValue) => source.Run(getColumnValue) switch
+        {
+            null => null,
+            int => 4,
+            _ => throw new NotSupportedException($"Simulation unable to to run DATALENGTH function on the provided expression."),
+        };
+
+#if DEBUG
+        public override string ToString() => $"DATALENGTH({source})";
 #endif
     }
 }

SqlServerSimulator/Parser/Tokenizer.cs

@@ -91,9 +91,19 @@ public static IEnumerable<Token> Tokenize(string? command)
 
                 case '(':
                     if (state.IsQuotedString())
+                    {
                         _ = buffer.Append(c);
+                    }
                     else
+                    {
+                        if (buffer.Length != 0)
+                        {
+                            yield return new UnquotedString(buffer);
+                            state = State.None;
+                        }
+
                         yield return new OpenParentheses();
+                    }
                     continue;
                 case ')':
                     if (state.IsQuotedString())
@@ -110,6 +120,9 @@ public static IEnumerable<Token> Tokenize(string? command)
                             case State.AtPrefixedString:
                                 yield return new AtPrefixedString(buffer);
                                 break;
+                            case State.Numeric:
+                                yield return new Numeric(buffer);
+                                break;
                         }
                         yield return new CloseParentheses();
                         state = State.None;
@@ -159,7 +172,12 @@ public static IEnumerable<Token> Tokenize(string? command)
                     continue;
 
                 case '-':
-                    c = commandEnumerator.GetNext(ref index);
+                    if (!commandEnumerator.TryGetNext(out c, ref index))
+                    {
+                        yield return new Minus();
+                        continue;
+                    }
+
                     switch (c)
                     {
                         case '-':
@@ -177,6 +195,10 @@ public static IEnumerable<Token> Tokenize(string? command)
                     }
                     break;
 
+                case '*':
+                    yield return new Asterisk();
+                    continue;
+
                 case '.':
                     switch (state)
                     {
@@ -248,10 +270,6 @@ static bool TryGetNext(this CharEnumerator enumerator, out char c, ref int index
         return false;
     }
 
-    static char GetNext(this CharEnumerator enumerator, ref int index) => !enumerator.TryGetNext(out var c, ref index)
-        ? throw new SimulatedSqlException($"Simulated syntax error at index {index}.")
-        : c;
-
     static bool IsQuotedString(this State state) => state switch
     {
         State.BracketDelimitedString or State.SingleQuotedString or State.DoubleQuotedString => true,

SqlServerSimulator/Parser/Tokens/Asterisk.cs

@@ -0,0 +1,6 @@
+namespace SqlServerSimulator.Parser.Tokens;
+
+sealed class Asterisk : Token
+{
+    public override string ToString() => "*";
+}

SqlServerSimulator/Parser/Tokens/Minus.cs

@@ -0,0 +1,6 @@
+namespace SqlServerSimulator.Parser.Tokens;
+
+sealed class Minus : Token
+{
+    public override string ToString() => "-";
+}

SqlServerSimulator/SimulatedSqlException.cs

@@ -93,4 +93,6 @@ private SimulatedSqlException(string? message, params ReadOnlySpan<SimulatedSqlE
     internal static SimulatedSqlException SyntaxErrorNear(Token token) => new($"Incorrect syntax near '{token}'.", 102, 15, 1);
 
     internal static SimulatedSqlException ThereIsAlreadyAnObject(string name) => new($"There is already an object named '{name}' in the database.", 2714, 16, 6);
+
+    internal static SimulatedSqlException UnrecognizedBuiltInFunction(string name) => new($"'{name}' is not a recognized built-in function name.", 195, 15, 10);
 }

SqlServerSimulator/Simulation.cs

@@ -291,9 +291,10 @@ internal IEnumerable<SimulatedStatementOutcome> CreateResultSetsForCommand(Simul
                             continue;
                     }
                     break;
-            }
 
-            throw new NotSupportedException($"Simulated command processor doesn't know what to do with {token}.");
-        }
+                default:
+                    throw SimulatedSqlException.SyntaxErrorNear(token);
+            }
+        } // while (tokens.TryMoveNext(out var token))
     }
 }