Wired CREATE/INSERT/SELECT through the page-storage backend end-to-end.

Author: RyanLamansky

SqlServerSimulator.Tests/PagesBackendIntegrationTests.cs

@@ -170,4 +170,122 @@ public void TypedNullParameter_ReturnsDBNull(DbType dbType)
 
         AreEqual(DBNull.Value, command.ExecuteScalar());
     }
+
+    [TestMethod]
+    public void CreateInsertSelect_IntegerConstant_RoundTripsThroughHeapTable()
+    {
+        using var connection = new Simulation(StorageBackend.Pages).CreateOpenConnection();
+
+        AreEqual(-1, connection.CreateCommand("create table t ( v int )").ExecuteNonQuery());
+        AreEqual(1, connection.CreateCommand("insert t values ( 42 )").ExecuteNonQuery());
+
+        using var reader = connection.CreateCommand("select v from t").ExecuteReader();
+        IsTrue(reader.Read());
+        AreEqual("v", reader.GetName(0));
+        AreEqual(42, reader[0]);
+        IsFalse(reader.Read());
+    }
+
+    [TestMethod]
+    public void CreateInsertSelect_MultipleRowsAndColumns()
+    {
+        using var connection = new Simulation(StorageBackend.Pages).CreateOpenConnection();
+
+        _ = connection.CreateCommand("create table t ( a int, b int )").ExecuteNonQuery();
+        AreEqual(3, connection.CreateCommand("insert t values ( 1, 10 ), ( 2, 20 ), ( 3, 30 )").ExecuteNonQuery());
+
+        using var reader = connection.CreateCommand("select a, b from t").ExecuteReader();
+
+        IsTrue(reader.Read());
+        AreEqual(1, reader[0]);
+        AreEqual(10, reader[1]);
+
+        IsTrue(reader.Read());
+        AreEqual(2, reader[0]);
+        AreEqual(20, reader[1]);
+
+        IsTrue(reader.Read());
+        AreEqual(3, reader[0]);
+        AreEqual(30, reader[1]);
+
+        IsFalse(reader.Read());
+    }
+
+    [TestMethod]
+    public void Insert_PartialColumnList_LeavesUnspecifiedColumnsNull()
+    {
+        using var connection = new Simulation(StorageBackend.Pages).CreateOpenConnection();
+
+        _ = connection.CreateCommand("create table t ( a int, b int )").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert t ( a ) values ( 7 )").ExecuteNonQuery();
+
+        using var reader = connection.CreateCommand("select a, b from t").ExecuteReader();
+        IsTrue(reader.Read());
+        AreEqual(7, reader[0]);
+        AreEqual(DBNull.Value, reader[1]);
+        IsFalse(reader.Read());
+    }
+
+    [TestMethod]
+    public void Select_FromEmptyTable_ReturnsNoRows()
+    {
+        using var connection = new Simulation(StorageBackend.Pages).CreateOpenConnection();
+
+        _ = connection.CreateCommand("create table t ( v int )").ExecuteNonQuery();
+
+        using var reader = connection.CreateCommand("select v from t").ExecuteReader();
+        IsFalse(reader.Read());
+    }
+
+    [TestMethod]
+    public void CreateInsertSelect_AllSupportedColumnTypes_ViaParameters()
+    {
+        using var connection = new Simulation(StorageBackend.Pages).CreateOpenConnection();
+
+        _ = connection.CreateCommand("create table t ( b bit, ti tinyint, si smallint, i int )").ExecuteNonQuery();
+
+        using (var insert = connection.CreateCommand())
+        {
+            insert.CommandText = "insert t values ( @b, @ti, @si, @i )";
+            AddTypedParameter(insert, "b", DbType.Boolean, true);
+            AddTypedParameter(insert, "ti", DbType.Byte, (byte)200);
+            AddTypedParameter(insert, "si", DbType.Int16, (short)-1);
+            AddTypedParameter(insert, "i", DbType.Int32, 12345);
+            AreEqual(1, insert.ExecuteNonQuery());
+        }
+
+        using var reader = connection.CreateCommand("select b, ti, si, i from t").ExecuteReader();
+        IsTrue(reader.Read());
+        AreEqual(true, reader[0]);
+        AreEqual((byte)200, reader[1]);
+        AreEqual((short)-1, reader[2]);
+        AreEqual(12345, reader[3]);
+        IsFalse(reader.Read());
+    }
+
+    [TestMethod]
+    public void SelectFromTable_ProjectionReorderingAndSubsetting()
+    {
+        using var connection = new Simulation(StorageBackend.Pages).CreateOpenConnection();
+
+        _ = connection.CreateCommand("create table t ( a int, b int, c int )").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert t values ( 1, 2, 3 )").ExecuteNonQuery();
+
+        using var reader = connection.CreateCommand("select c, a from t").ExecuteReader();
+        IsTrue(reader.Read());
+        AreEqual(2, reader.FieldCount);
+        AreEqual("c", reader.GetName(0));
+        AreEqual("a", reader.GetName(1));
+        AreEqual(3, reader[0]);
+        AreEqual(1, reader[1]);
+    }
+
+    private static void AddTypedParameter(System.Data.Common.DbCommand command, string name, DbType dbType, object value)
+    {
+        var parameter = command.CreateParameter();
+        parameter.ParameterName = name;
+        parameter.DbType = dbType;
+        parameter.Value = value;
+        _ = command.Parameters.Add(parameter);
+    }
 }

SqlServerSimulator.Tests/PagesBackendTests.cs

@@ -36,18 +36,6 @@ public void Reader_RoundsTripsRowAndExposesScalar()
         IsFalse(reader.Read());
     }
 
-    [TestMethod]
-    public void ColumnReference_NotYetSupported_OnPages()
-    {
-        // Reference.RunSql isn't implemented yet, so a tableless `select x`
-        // surfaces NotSupportedException via the base Expression.RunSql.
-        // Demonstrates that the parallel evaluator surface is honest about its
-        // coverage; this lifts when Reference.RunSql arrives alongside Pages-
-        // backed tables.
-        var simulation = new Simulation(StorageBackend.Pages);
-        _ = Throws<NotSupportedException>(() => simulation.ExecuteScalar("select x"));
-    }
-
     [TestMethod]
     public void InMemoryBackend_StillHandlesArithmetic()
     {

SqlServerSimulator/Parser/DataValueShim.cs

@@ -0,0 +1,29 @@
+using SqlServerSimulator.Storage;
+
+namespace SqlServerSimulator.Parser;
+
+/// <summary>
+/// Transitional translation from <see cref="DataValue"/> to <see cref="SqlValue"/>,
+/// applied at parser boundaries where parser tokens still produce
+/// <see cref="DataValue"/>s but the page-storage execution path requires
+/// <see cref="SqlValue"/>s. Goes away when parser tokens are rewritten to
+/// produce <see cref="SqlValue"/> directly.
+/// </summary>
+/// <remarks>
+/// <c>BuiltInDbSystemName</c> isn't mapped: it's only used for system-table
+/// column definitions, never as a literal or parameter value that flows
+/// through this shim.
+/// </remarks>
+internal static class DataValueShim
+{
+    public static SqlValue ToSqlValue(DataValue dv) => dv.Type switch
+    {
+        var t when t == DataType.BuiltInDbInt32 => dv.Value is null ? SqlValue.Null(SqlType.Int32) : SqlValue.FromInt32((int)dv.Value),
+        var t when t == DataType.BuiltInDbInt16 => dv.Value is null ? SqlValue.Null(SqlType.SmallInt) : SqlValue.FromInt16((short)dv.Value),
+        var t when t == DataType.BuiltInDbByte => dv.Value is null ? SqlValue.Null(SqlType.TinyInt) : SqlValue.FromByte((byte)dv.Value),
+        var t when t == DataType.BuiltInDbBoolean => dv.Value is null ? SqlValue.Null(SqlType.Bit) : SqlValue.FromBoolean((bool)dv.Value),
+        var t when t == DataType.BuiltInDbAnsiString => dv.Value is null ? SqlValue.Null(SqlType.Varchar) : SqlValue.FromVarchar((string)dv.Value),
+        var t when t == DataType.BuiltInDbString => dv.Value is null ? SqlValue.Null(SqlType.NVarchar) : SqlValue.FromNVarchar((string)dv.Value),
+        _ => throw new NotSupportedException($"No SqlType mapping for value of type {dv.Type}."),
+    };
+}

SqlServerSimulator/Parser/Expressions/Reference.cs

@@ -1,4 +1,5 @@
 using SqlServerSimulator.Parser.Tokens;
+using SqlServerSimulator.Storage;
 
 namespace SqlServerSimulator.Parser.Expressions;
 
@@ -12,6 +13,8 @@ internal sealed class Reference(Name name) : Expression
 
     public override DataValue Run(Func<List<string>, DataValue> getColumnValue) => getColumnValue(this.name);
 
+    public override SqlValue RunSql(Func<List<string>, SqlValue> getColumnValue) => getColumnValue(this.name);
+
 #if DEBUG
     public override string ToString() => string.Join('.', name);
 #endif

SqlServerSimulator/Parser/Expressions/Value.cs

@@ -32,26 +32,7 @@ public Value(DoubleAtPrefixedString doubleAtPrefixedString)
 
     public override DataValue Run(Func<List<string>, DataValue> getColumnValue) => value;
 
-    public override SqlValue RunSql(Func<List<string>, SqlValue> getColumnValue) => ToSqlValue(this.value);
-
-    /// <remarks>
-    /// Transitional: parser tokens still produce <see cref="DataValue"/>, so a
-    /// literal <see cref="Value"/> expression has to translate at this seam.
-    /// When parser tokens are rewritten to produce <see cref="SqlValue"/>
-    /// directly, this helper goes away. <c>BuiltInDbSystemName</c> isn't
-    /// mapped: it's only used for system-table column definitions, never as a
-    /// literal that flows through this shim.
-    /// </remarks>
-    private static SqlValue ToSqlValue(DataValue dv) => dv.Type switch
-    {
-        var t when t == DataType.BuiltInDbInt32 => dv.Value is null ? SqlValue.Null(SqlType.Int32) : SqlValue.FromInt32((int)dv.Value),
-        var t when t == DataType.BuiltInDbInt16 => dv.Value is null ? SqlValue.Null(SqlType.SmallInt) : SqlValue.FromInt16((short)dv.Value),
-        var t when t == DataType.BuiltInDbByte => dv.Value is null ? SqlValue.Null(SqlType.TinyInt) : SqlValue.FromByte((byte)dv.Value),
-        var t when t == DataType.BuiltInDbBoolean => dv.Value is null ? SqlValue.Null(SqlType.Bit) : SqlValue.FromBoolean((bool)dv.Value),
-        var t when t == DataType.BuiltInDbAnsiString => dv.Value is null ? SqlValue.Null(SqlType.Varchar) : SqlValue.FromVarchar((string)dv.Value),
-        var t when t == DataType.BuiltInDbString => dv.Value is null ? SqlValue.Null(SqlType.NVarchar) : SqlValue.FromNVarchar((string)dv.Value),
-        _ => throw new NotSupportedException($"No SqlType mapping for literal of type {dv.Type}."),
-    };
+    public override SqlValue RunSql(Func<List<string>, SqlValue> getColumnValue) => DataValueShim.ToSqlValue(this.value);
 
 #if DEBUG
     public override string ToString() => value.Value?.ToString() ?? "null";

SqlServerSimulator/Parser/Selection.cs

@@ -1,4 +1,5 @@
-using SqlServerSimulator.Parser.Tokens;
+using SqlServerSimulator.Parser.Expressions;
+using SqlServerSimulator.Parser.Tokens;
 using SqlServerSimulator.Storage;
 
 namespace SqlServerSimulator.Parser;
@@ -100,6 +101,29 @@ [.. expressions.Select(x => x.Run(columnName => getColumnValueFromRow(row, colum
                     switch (context.GetNextRequired())
                     {
                         case Name tableName:
+                            if (context.Simulation.Backend == StorageBackend.Pages)
+                            {
+                                if (!context.Simulation.HeapTables.TryGetValue(tableName.Value, out var heapTable))
+                                    throw SimulatedSqlException.InvalidObjectName(tableName);
+
+                                if (context.GetNextOptional() is not null)
+                                {
+                                    if (context.Token is ReservedKeyword { Keyword: Keyword.As })
+                                    {
+                                        if (context.Token is not ReservedKeyword)
+                                            break;
+                                    }
+                                    else
+                                    {
+                                        break;
+                                    }
+                                }
+
+                                return excluders.Count > 0 ? throw new NotSupportedException("WHERE isn't supported on the page-storage backend yet.")
+                                    : topCount is not null ? throw new NotSupportedException("TOP isn't supported on the page-storage backend yet.")
+                                    : new(BuildHeapProjection(heapTable, expressions));
+                            }
+
                             if (!context.Simulation.Tables.TryGetValue(tableName.Value, out var table) && !context.Simulation.SystemTables.Value.TryGetValue(tableName.Value, out table))
                                 throw SimulatedSqlException.InvalidObjectName(tableName);
 
@@ -195,4 +219,69 @@ private static SimulatedSqlResultSet BuildSynthesizedSqlRow(List<Expression> exp
 
         return new SimulatedSqlResultSet(schema, columnNames, [RowEncoder.EncodeRow(schema, values)]);
     }
+
+    /// <summary>
+    /// Builds the page-backend result for a SELECT-FROM-table query. Each input
+    /// row is decoded column-by-column on demand via
+    /// <see cref="RowDecoder.DecodeColumn"/>; each projection expression is
+    /// evaluated against that row through <see cref="Expression.RunSql"/>; the
+    /// resulting values are re-encoded into a fresh output row.
+    /// </summary>
+    /// <remarks>
+    /// Output schema is determined statically from the projection list. Today
+    /// only bare <see cref="Reference"/> projections are supported (the output
+    /// type is the source column's type). Lifting this to arbitrary expressions
+    /// requires a static type-of resolver on <see cref="Expression"/> and is
+    /// deferred.
+    /// </remarks>
+    private static SimulatedSqlResultSet BuildHeapProjection(HeapTable heapTable, List<Expression> expressions)
+    {
+        var outputSchema = new SqlType[expressions.Count];
+        var outputColumnNames = new string[expressions.Count];
+
+        for (var i = 0; i < expressions.Count; i++)
+        {
+            if (expressions[i] is not Reference)
+                throw new NotSupportedException("Page-backend SELECT FROM table currently supports only column-reference projections.");
+
+            var sourceColumnName = expressions[i].Name;
+            var sourceColumn = heapTable.Columns.FirstOrDefault(c => Collation.Default.Equals(c.Name, sourceColumnName))
+                ?? throw SimulatedSqlException.InvalidColumnName([sourceColumnName]);
+
+            outputSchema[i] = sourceColumn.Type;
+            outputColumnNames[i] = expressions[i].Name;
+        }
+
+        return new SimulatedSqlResultSet(outputSchema, outputColumnNames, ProjectHeapRows(heapTable, expressions, outputSchema));
+    }
+
+    private static IEnumerable<byte[]> ProjectHeapRows(HeapTable heapTable, List<Expression> expressions, SqlType[] outputSchema)
+    {
+        foreach (var rowBytes in heapTable.Rows)
+        {
+            var bytes = rowBytes;
+            var projected = new SqlValue[expressions.Count];
+            for (var i = 0; i < expressions.Count; i++)
+            {
+                projected[i] = expressions[i].RunSql(name =>
+                {
+                    var columnIndex = -1;
+                    for (var j = 0; j < heapTable.Columns.Count; j++)
+                    {
+                        if (Collation.Default.Equals(heapTable.Columns[j].Name, name[^1]))
+                        {
+                            columnIndex = j;
+                            break;
+                        }
+                    }
+
+                    return columnIndex == -1
+                        ? throw SimulatedSqlException.InvalidColumnName(name)
+                        : RowDecoder.DecodeColumn(heapTable.Schema, bytes, columnIndex);
+                });
+            }
+
+            yield return RowEncoder.EncodeRow(outputSchema, projected);
+        }
+    }
 }