ast: Preserve FROM clause ordering for mixed join/comma syntax

Fix table expression ordering when parsing mixed join/comma syntax like
`FROM t1 INNER JOIN t2, t3`. Previously, Readyset split table
expressions into separate `tables` and `join` fields without preserving
left-to-right order, breaking correlated subqueries (e.g., LATERAL)
that depend on earlier table expressions.

Solution: After encountering the first explicit join, convert subsequent
comma-separated tables to CROSS JOIN operators, preserving the
left-to-right evaluation order required by SQL semantics.

Example that now works:
  FROM t1 INNER JOIN t2 AS TABLE2, LATERAL (SELECT ... FROM TABLE2)

Previously, LATERAL couldn't find TABLE2 because it was processed before
the joined table. Now the order is preserved: t1 → t2 → LATERAL.

Adds comprehensive logictests in `sqlparser/psql/from_clause_ordering.test`
to prevent regression.

Release-Note-Core: Correlated subquery resolution in mixed join/comma
  syntax.
AI-Use: level:3
Change-Id: I7cb724b5451c371840647ca9c689883afac76f1b
Reviewed-on: https://gerrit.readyset.name/c/readyset/+/11063
Reviewed-by: Vassili Zarouba <vassili@readyset.io>
Tested-by: Buildkite CI

Author: jasobrown-rs

logictests/sqlparser/psql/from_clause_ordering.test

@@ -0,0 +1,45 @@
+# Tests for FROM clause ordering with mixed join/comma syntax
+# These tests ensure that sqlparser's FROM clause parsing maintains correct
+# left-to-right ordering when converting to ReadySet's AST
+
+statement ok
+create table t1 (id int, x int)
+
+statement ok
+create table t2 (id int, y int)
+
+statement ok
+create table t3 (id int, z int)
+
+statement ok
+insert into t1 (id, x) values (1, 10), (2, 20)
+
+statement ok
+insert into t2 (id, y) values (1, 100), (2, 200)
+
+statement ok
+insert into t3 (id, z) values (1, 1000), (2, 2000)
+
+# Test the original bug: mixed join/comma syntax with LATERAL correlated subquery
+# This ensures that table ordering is preserved so LATERAL can reference earlier tables
+query I rowsort
+SELECT count(*) 
+FROM t1 AS T1 
+INNER JOIN t2 AS TABLE2 ON T1.id = TABLE2.id, 
+LATERAL (SELECT T3.z FROM t3 T3 WHERE T3.id = TABLE2.id LIMIT 1) TT
+WHERE T1.id = 1;
+----
+1
+
+# Test that comma-after-join preserves correct ordering (non-LATERAL case)
+query III rowsort
+SELECT t1.id, t2.y, t3.z 
+FROM t1 
+INNER JOIN t2 ON t1.id = t2.id, 
+t3 
+WHERE t1.id = t3.id AND t1.id = 1;
+----
+1
+100
+1000
+

readyset-sql/src/ast/select.rs

@@ -509,8 +509,27 @@ impl TryFromDialect<sqlparser::ast::Select> for SelectStatement {
             let (new_tables, new_joins) = from_clause
                 .into_tables_and_joins()
                 .map_err(|e| failed_err!("couldn't convert FROM clause: {e}"))?;
-            tables.extend(new_tables);
-            join.extend(new_joins);
+
+            // After we've encountered the first explicit join, all subsequent table expressions
+            // should be added as CROSS JOINs to preserve left-to-right ordering.
+            // This is important for correlated subqueries (e.g., LATERAL) that depend on
+            // earlier table expressions.
+            if join.is_empty() {
+                // No joins yet, add tables normally
+                tables.extend(new_tables);
+                join.extend(new_joins);
+            } else {
+                // We've already seen a join, so convert remaining tables to CROSS JOINs
+                debug_assert!(!tables.is_empty());
+                for table in new_tables {
+                    join.push(JoinClause {
+                        operator: JoinOperator::CrossJoin,
+                        right: JoinRightSide::Table(table),
+                        constraint: JoinConstraint::Empty,
+                    });
+                }
+                join.extend(new_joins);
+            }
         }
         Ok(SelectStatement {
             distinct: matches!(value.distinct, Some(sqlparser::ast::Distinct::Distinct)),