Add SELECT * projection: bare * expands to all columns from all FROM sources in order, t.* filters to one source. StarProjection placeholder lands in the projection list at parse time and ExpandStars replaces it with per-column Reference expressions (qualified by each source's alias) after FROM is parsed, so multi-source * keeps duplicates without tripping Msg 209. Unbound qualifier raises Msg 4104; the * multiplication operator and count(*) paths are untouched.

Author: RyanLamansky

CLAUDE.md

@@ -165,6 +165,9 @@ APPLY is the lateral form: the right side is a derived-table SELECT re-executed
 
 `JoinDriver`'s lateral branch handles both APPLY (CrossApply / OuterApply, no ON predicate) and ordinary derived tables in INNER / LEFT / CROSS join slots — the latter apply their `ON` predicate after the inner row materializes, and LEFT joins null-fill on no-match the same way OUTER APPLY does. Leftmost-source lateral plans run from the surrounding `outerResolver` directly (no per-tuple feedback at level 0).
 
+### `SELECT *` projection
+Bare `*` and qualified `<source>.*` both work. `*` expands to every column of every FROM source in source order; `t.*` filters to one source. Multi-source `*` keeps duplicate column names (e.g. a join on a same-named key emits the key twice). Expansion happens after FROM is parsed via `ExpandStars` in `Selection.cs`, replacing the placeholder `StarProjection` in the projection list with per-column `Reference` expressions qualified by each source's alias / table name — qualifying is what lets duplicates land without tripping Msg 209's ambiguous-column check. Unbound `<qualifier>.*` raises Msg 4104. The `*` *operator* (multiplication) is unchanged: it's only intercepted as star when it appears at projection-element-start position, so `select 5 * 3` still parses as multiplication and `count(*)` continues through its own AggregateExpression path.
+
 ### CASE
 Searched (`CASE WHEN cond THEN ... [ELSE ...] END`) and simple (`CASE input WHEN val ...`). Branches evaluate in order; first true predicate wins. UNKNOWN excludes (matches WHERE); simple-form `CASE NULL WHEN NULL` falls through. Result type computed via `SqlType.Promote` across all THEN/ELSE, cached on first `GetSqlType`; `Run` coerces matched values to the common type. No-match-no-ELSE → typed NULL.
 

SqlServerSimulator.Tests.EFCore/EFCoreFromSql.cs

@@ -39,7 +39,7 @@ public void FromSqlInterpolated_StringParameterAgainstIntColumn_PromotesAndMatch
         using var context = SeededContext();
         var idAsString = "2";
         var customer = context.Customers
-            .FromSqlInterpolated($"select Id, Name from Customers where Id = {idAsString}")
+            .FromSqlInterpolated($"select * from Customers where Id = {idAsString}")
             .Single();
         Assert.AreEqual(2, customer.Id);
         Assert.AreEqual("beta", customer.Name);

SqlServerSimulator.Tests/SelectTests.cs

@@ -364,4 +364,97 @@ public void UnaryMinusInProjection_PreservesAlias()
         Assert.AreEqual(-1, reader[0]);
         Assert.AreEqual("n", reader.GetName(0));
     }
+
+    // ─── SELECT * projection ───────────────────────────────────────────────
+
+    [TestMethod]
+    public void SelectStar_SingleSource_ProjectsAllColumnsInDeclaredOrder()
+    {
+        using var connection = new Simulation().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 * from t").ExecuteReader();
+        Assert.IsTrue(reader.Read());
+        Assert.AreEqual(3, reader.FieldCount);
+        Assert.AreEqual("a", reader.GetName(0));
+        Assert.AreEqual("b", reader.GetName(1));
+        Assert.AreEqual("c", reader.GetName(2));
+        Assert.AreEqual(1, reader[0]);
+        Assert.AreEqual(2, reader[1]);
+        Assert.AreEqual(3, reader[2]);
+    }
+
+    [TestMethod]
+    public void SelectStar_WithWhereClause_FiltersRows()
+    {
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t (a int, b int)").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert t values (1, 10), (2, 20), (3, 30)").ExecuteNonQuery();
+        using var reader = connection.CreateCommand("select * from t where a >= 2").ExecuteReader();
+        var values = new List<int>();
+        while (reader.Read())
+            values.Add(reader.GetInt32(1));
+        CollectionAssert.AreEqual(new[] { 20, 30 }, values);
+    }
+
+    [TestMethod]
+    public void SelectStar_TwoSourceJoin_IncludesDuplicateColumnNames()
+    {
+        // Multi-source `*` includes same-named columns from each source —
+        // SQL Server keeps the duplicate (no auto-disambiguation), and the
+        // qualified per-source References emitted by star-expansion let
+        // the resolver bind each duplicate without raising Msg 209.
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t (a int, b int)").ExecuteNonQuery();
+        _ = connection.CreateCommand("create table u (a int, c int)").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert t values (1, 2)").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert u values (1, 9)").ExecuteNonQuery();
+        using var reader = connection.CreateCommand("select * from t inner join u on t.a = u.a").ExecuteReader();
+        Assert.IsTrue(reader.Read());
+        Assert.AreEqual(4, reader.FieldCount);
+        Assert.AreEqual("a", reader.GetName(0));
+        Assert.AreEqual("b", reader.GetName(1));
+        Assert.AreEqual("a", reader.GetName(2));
+        Assert.AreEqual("c", reader.GetName(3));
+    }
+
+    [TestMethod]
+    public void SelectQualifiedStar_RestrictsToNamedSource()
+    {
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t (a int, b int)").ExecuteNonQuery();
+        _ = connection.CreateCommand("create table u (a int, c int)").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert t values (1, 2)").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert u values (1, 9)").ExecuteNonQuery();
+        using var reader = connection.CreateCommand("select t.* from t inner join u on t.a = u.a").ExecuteReader();
+        Assert.IsTrue(reader.Read());
+        Assert.AreEqual(2, reader.FieldCount);
+        Assert.AreEqual("a", reader.GetName(0));
+        Assert.AreEqual("b", reader.GetName(1));
+    }
+
+    [TestMethod]
+    public void SelectStar_InsideDerivedTable_OuterReferencesProjectedColumns()
+    {
+        // The inner `select *` expands against the inner FROM's columns,
+        // and the outer query then references those columns through the
+        // derived-table alias — the FromSqlInterpolated wrap shape EF Core
+        // emits.
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t (a int, b int)").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert t values (1, 2), (3, 4)").ExecuteNonQuery();
+        using var reader = connection.CreateCommand("select x.a from (select * from t) as x where x.a = 3").ExecuteReader();
+        Assert.IsTrue(reader.Read());
+        Assert.AreEqual(3, reader[0]);
+        Assert.IsFalse(reader.Read());
+    }
+
+    [TestMethod]
+    public void SelectQualifiedStar_UnboundQualifier_RaisesMsg4104()
+    {
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t (a int)").ExecuteNonQuery();
+        var ex = Assert.Throws<DbException>(() => connection.CreateCommand("select notbound.* from t").ExecuteReader().Read());
+        Assert.AreEqual("The multi-part identifier \"notbound.*\" could not be bound.", ex.Message);
+    }
 }

SqlServerSimulator/Parser/Expression.cs

@@ -113,7 +113,25 @@ public static Expression Parse(ParserContext context)
                         if (expression is not Reference reference)
                             throw SimulatedSqlException.SyntaxErrorNear(context);
 
-                        reference.AddMultiPartComponent(context.GetNextRequired<Name>());
+                        var afterDot = context.GetNextRequired();
+                        if (afterDot is Operator { Character: '*' })
+                        {
+                            // <qualifier>.* — convert the Reference into a
+                            // StarProjection placeholder. Selection.ParseInner
+                            // expands it once the FROM sources are known; if
+                            // it survives into a non-projection context, the
+                            // placeholder's Run / GetSqlType raise the
+                            // surface-not-supported error.
+                            expression = new StarProjection(reference.Name);
+                        }
+                        else if (afterDot is Name name)
+                        {
+                            reference.AddMultiPartComponent(name);
+                        }
+                        else
+                        {
+                            throw SimulatedSqlException.SyntaxErrorNear(context);
+                        }
                     }
                     continue;
                 case Operator { Character: ')' }:

SqlServerSimulator/Parser/Expressions/Reference.cs

@@ -22,6 +22,18 @@ public Reference(string name)
         this.name = new MultiPartName(name);
     }
 
+    /// <summary>
+    /// Two-part reference (<c>qualifier.column</c>). Used by star-expansion
+    /// in <see cref="Selection"/> to emit per-column references qualified by
+    /// the FROM source's alias / table name, so multi-source <c>SELECT *</c>
+    /// includes same-named columns from different sources without triggering
+    /// Msg 209.
+    /// </summary>
+    public Reference(string qualifier, string column)
+    {
+        this.name = new MultiPartName(qualifier).WithAddedPart(column);
+    }
+
     public override string Name => this.name.Leaf;
 
     public void AddMultiPartComponent(Name next) => this.name = this.name.WithAddedPart(next.Value);

SqlServerSimulator/Parser/Expressions/StarProjection.cs

@@ -0,0 +1,25 @@
+using SqlServerSimulator.Storage;
+
+namespace SqlServerSimulator.Parser.Expressions;
+
+/// <summary>
+/// Placeholder expression for <c>*</c> (or <c>&lt;qualifier&gt;.*</c>) in a
+/// SELECT projection list. Replaced by per-column <see cref="Reference"/>
+/// expressions in <see cref="Selection"/> after the FROM clause is parsed and
+/// the source columns are known. The placeholder can't participate in any
+/// other expression context — <see cref="Run"/> / <see cref="GetSqlType"/>
+/// throw if it ever survives into evaluation (e.g. <c>WHERE *</c>,
+/// <c>SELECT * + 1</c>, or <c>SELECT *</c> with no FROM).
+/// </summary>
+internal sealed class StarProjection(string? qualifier) : Expression
+{
+    public readonly string? Qualifier = qualifier;
+
+    public override SqlValue Run(Func<MultiPartName, SqlValue> getColumnValue) =>
+        throw new NotSupportedException("'*' is only valid as a top-level SELECT projection element.");
+
+    public override SqlType GetSqlType(Func<MultiPartName, SqlType> resolveColumnType) =>
+        throw new NotSupportedException("'*' is only valid as a top-level SELECT projection element.");
+
+    internal override string DebugDisplay() => this.Qualifier is { } q ? $"{q}.*" : "*";
+}

SqlServerSimulator/Parser/Selection.cs

@@ -315,6 +315,15 @@ private static Selection ParseInner(ParserContext context, uint depth, List<Aggr
                         throw SimulatedSqlException.SyntaxErrorNear(context);
                     goto ExitWhileTokenLoop;
 
+                // Bare `*` as a projection element (the first thing after
+                // SELECT, or the first thing after a comma). Within a
+                // projected expression, `*` is the multiplication operator and
+                // is handled by Expression.Parse's binary loop instead.
+                case Operator { Character: '*' }:
+                    expressions.Add(new StarProjection(null));
+                    context.MoveNextOptional();
+                    break;
+
                 default:
                     expressions.Add(Expression.Parse(context));
                     break;
@@ -359,6 +368,7 @@ private static Selection ParseInner(ParserContext context, uint depth, List<Aggr
                     ParseFromSourceAndJoins(context, depth, sources, joins, fromClause, outerTypeResolver, allowOrderBy);
                     if (topCount is not null && fromClause.OffsetCount is not null)
                         throw SimulatedSqlException.TopAndOffsetMutuallyExclusive();
+                    ExpandStars(expressions, sources);
                     return BuildSqlProjection([.. sources], [.. joins], expressions, fromClause, distinct, topCount, aggregates, windows, outerTypeResolver);
 
                 case ReservedKeyword { Keyword: Keyword.Where }:
@@ -955,6 +965,59 @@ outerResolver is not null
             return [RowEncoder.EncodeRow(schema, values)];
         });
     }
+
+    /// <summary>
+    /// Expands any <see cref="StarProjection"/> markers in the projection
+    /// list into per-column <see cref="Reference"/> expressions, using each
+    /// FROM source's <see cref="FromSource.Qualifier"/> to disambiguate
+    /// same-named columns across sources (so multi-source <c>SELECT *</c>
+    /// doesn't trip Msg 209). Bare <c>*</c> emits every column from every
+    /// source in source order; <c>&lt;qualifier&gt;.*</c> filters to the
+    /// named source. An unbound qualifier raises Msg 4104.
+    /// </summary>
+    private static void ExpandStars(List<Expression> expressions, List<FromSource> sources)
+    {
+        for (var i = expressions.Count - 1; i >= 0; i--)
+        {
+            if (expressions[i] is not StarProjection star)
+                continue;
+
+            var expanded = new List<Expression>();
+            if (star.Qualifier is null)
+            {
+                foreach (var source in sources)
+                    AppendSourceColumns(expanded, source);
+            }
+            else
+            {
+                FromSource? matched = null;
+                foreach (var source in sources)
+                {
+                    if (source.Qualifier is { } q && Collation.Default.Equals(q, star.Qualifier))
+                    {
+                        matched = source;
+                        break;
+                    }
+                }
+                if (matched is null)
+                    throw SimulatedSqlException.MultiPartIdentifierCouldNotBeBound($"{star.Qualifier}.*");
+                AppendSourceColumns(expanded, matched);
+            }
+
+            expressions.RemoveAt(i);
+            expressions.InsertRange(i, expanded);
+        }
+
+        static void AppendSourceColumns(List<Expression> destination, FromSource source)
+        {
+            foreach (var col in source.ColumnNames)
+            {
+                destination.Add(source.Qualifier is { } q
+                    ? new Reference(q, col)
+                    : new Reference(col));
+            }
+        }
+    }
 }
 
 /// <summary>