Keep table qualifiers for sql fields referencing other tables

[ATOM00blue]

Fixes #5734

Problem

When a raw sql expression is used as a selected field in a single-table
select, Drizzle strips the table qualifier from every column inside that
expression. For a bare reference to the queried table that is harmless,
but it also rewrites columns that belong to another table — e.g. a
correlated subquery written directly in the field list. The condition

`b`.`c_id` = `a`.`c_id`

is emitted as

`c_id` = `c_id`

which is always true, so the query compiles and runs but silently returns
wrong results. The same sql chunk renders correctly when used in
.where(...).

const raw = sql`select ${tableB.label} from ${tableB} where ${tableB.cId} = ${tableA.cId} limit 1`;

db.select({ id: tableA.id, bRaw: raw }).from(tableA).toSQL().sql;
// before: select `id`, select `label` from `b` where `c_id` = `c_id` limit 1 from `a`
// after:  select `id`, select `b`.`label` from `b` where `b`.`c_id` = `a`.`c_id` limit 1 from `a`

Root cause

buildSelection applies the single-table optimization by walking the
expression's top-level queryChunks and replacing every column chunk
with an unqualified identifier. When a column written inline references a
different table, that qualifier is required and must not be dropped.

Fix

Only strip the qualifier when the expression does not reference another
table, i.e. its usedTables is empty. A bare same-table column reference
keeps the optimization (select id from a), while an expression that
pulls in another table is left untouched and renders with qualifiers,
matching how the same chunk already renders in where.

The same buggy branch existed in the pg, mysql, sqlite and singlestore
dialects, so the change is applied to all four. gel-core already disables
this optimization and is unaffected.

Tests

Added a build query regression test to the pg, mysql and sqlite common
suites asserting that a correlated subquery in a single-table select's
field list keeps its table qualifiers. The test fails before the change
and passes after it. The existing build query test (which covers the
plain-column optimization) still passes.

[Copilot]

Pull request overview

Note

Copilot was unable to run its full agentic suite in this review.

This PR adjusts dialect query building to avoid stripping table qualifiers inside SQL expressions when building single-table selects, and adds integration tests to cover correlated-subquery scenarios.

Changes:

• Update SQL field handling in SQLite/Pg/MySQL/SingleStore dialects to only drop table prefixes when the SQL expression does not reference any tables.
• Add integration tests for SQLite/Pg/MySQL asserting table qualifiers are preserved in a correlated subquery embedded in a select field.

Reviewed changes

Copilot reviewed 7 out of 7 changed files in this pull request and generated 5 comments.

Show a summary per file

File	Description
integration-tests/tests/sqlite/sqlite-common.ts	Adds a regression test for correlated subquery qualifier preservation in sql select fields.
integration-tests/tests/pg/pg-common.ts	Adds the same regression test for Postgres.
integration-tests/tests/mysql/mysql-common.ts	Adds the same regression test for MySQL.
drizzle-orm/src/sqlite-core/dialect.ts	Changes when table prefixes are dropped for SQL/SQL.Aliased fields in single-table selects.
drizzle-orm/src/pg-core/dialect.ts	Same logic change for Postgres dialect.
drizzle-orm/src/mysql-core/dialect.ts	Same logic change for MySQL dialect.
drizzle-orm/src/singlestore-core/dialect.ts	Same logic change for SingleStore dialect.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.