drizzle-orm 0.27.2 → 0.27.3-0ea6f8c

package/{alias-3e926a50.mjs → alias-340e2b86.mjs}

@@ -646,6 +646,25 @@ const tracer = {
     },
 };
 
+class DrizzleError extends Error {
+    static [entityKind] = 'DrizzleError';
+    constructor(message) {
+        super(message);
+        this.name = 'DrizzleError';
+    }
+    static wrap(error, message) {
+        return error instanceof Error // eslint-disable-line no-instanceof/no-instanceof
+            ? new DrizzleError(message ? `${message}: ${error.message}` : error.message)
+            : new DrizzleError(message ?? String(error));
+    }
+}
+class TransactionRollbackError extends DrizzleError {
+    static [entityKind] = 'TransactionRollbackError';
+    constructor() {
+        super('Rollback');
+    }
+}
+
 class PgDialect {
     static [entityKind] = 'PgDialect';
     async migrate(migrations, session) {
@@ -691,10 +710,10 @@ class PgDialect {
     buildUpdateSet(table, set) {
         const setEntries = Object.entries(set);
         const setSize = setEntries.length;
-        return sql.fromList(setEntries
+        return sql.join(setEntries
             .flatMap(([colName, value], i) => {
             const col = table[Table.Symbol.Columns][colName];
-            const res = sql `${name(col.name)} = ${value}`;
+            const res = sql `${sql.identifier(col.name)} = ${value}`;
             if (i < setSize - 1) {
                 return [res, sql.raw(', ')];
             }
@@ -733,7 +752,7 @@ class PgDialect {
                 if (isSingleTable) {
                     chunk.push(new SQL(query.queryChunks.map((c) => {
                         if (is(c, PgColumn)) {
-                            return name(c.name);
+                            return sql.identifier(c.name);
                         }
                         return c;
                     })));
@@ -758,7 +777,7 @@ class PgDialect {
             }
             return chunk;
         });
-        return sql.fromList(chunks);
+        return sql.join(chunks);
     }
     buildSelectQuery({ withList, fields, fieldsFlat, where, having, table, joins, orderBy, groupBy, limit, offset, lockingClauses, distinct, }) {
         const fieldsList = fieldsFlat ?? orderSelectedFields(fields);
@@ -772,23 +791,23 @@ class PgDialect {
                             : is(table, SQL)
                                 ? undefined
                                 : getTableName(table))
-                && !((table) => joins.some(({ alias }) => alias === (table[Table.Symbol.IsAlias] ? getTableName(table) : table[Table.Symbol.BaseName])))(f.field.table)) {
+                && !((table) => joins?.some(({ alias }) => alias === (table[Table.Symbol.IsAlias] ? getTableName(table) : table[Table.Symbol.BaseName])))(f.field.table)) {
                 const tableName = getTableName(f.field.table);
                 throw new Error(`Your "${f.path.join('->')}" field references a column "${tableName}"."${f.field.name}", but the table "${tableName}" is not part of the query! Did you forget to join it?`);
             }
         }
-        const isSingleTable = joins.length === 0;
+        const isSingleTable = !joins || joins.length === 0;
         let withSql;
         if (withList?.length) {
             const withSqlChunks = [sql `with `];
             for (const [i, w] of withList.entries()) {
-                withSqlChunks.push(sql `${name(w[SubqueryConfig].alias)} as (${w[SubqueryConfig].sql})`);
+                withSqlChunks.push(sql `${sql.identifier(w[SubqueryConfig].alias)} as (${w[SubqueryConfig].sql})`);
                 if (i < withList.length - 1) {
                     withSqlChunks.push(sql `, `);
                 }
             }
             withSqlChunks.push(sql ` `);
-            withSql = sql.fromList(withSqlChunks);
+            withSql = sql.join(withSqlChunks);
         }
         let distinctSql;
         if (distinct) {
@@ -806,59 +825,63 @@ class PgDialect {
             return table;
         })();
         const joinsArray = [];
-        for (const [index, joinMeta] of joins.entries()) {
-            if (index === 0) {
-                joinsArray.push(sql ` `);
-            }
-            const table = joinMeta.table;
-            if (is(table, PgTable)) {
-                const tableName = table[PgTable.Symbol.Name];
-                const tableSchema = table[PgTable.Symbol.Schema];
-                const origTableName = table[PgTable.Symbol.OriginalName];
-                const alias = tableName === origTableName ? undefined : joinMeta.alias;
-                joinsArray.push(sql `${sql.raw(joinMeta.joinType)} join ${tableSchema ? sql `${name(tableSchema)}.` : undefined}${sql.identifier(origTableName)}${alias && sql ` ${name(alias)}`} on ${joinMeta.on}`);
-            }
-            else {
-                joinsArray.push(sql `${sql.raw(joinMeta.joinType)} join ${table} on ${joinMeta.on}`);
-            }
-            if (index < joins.length - 1) {
-                joinsArray.push(sql ` `);
+        if (joins) {
+            for (const [index, joinMeta] of joins.entries()) {
+                if (index === 0) {
+                    joinsArray.push(sql ` `);
+                }
+                const table = joinMeta.table;
+                const lateralSql = joinMeta.lateral ? sql ` lateral` : undefined;
+                if (is(table, PgTable)) {
+                    const tableName = table[PgTable.Symbol.Name];
+                    const tableSchema = table[PgTable.Symbol.Schema];
+                    const origTableName = table[PgTable.Symbol.OriginalName];
+                    const alias = tableName === origTableName ? undefined : joinMeta.alias;
+                    joinsArray.push(sql `${sql.raw(joinMeta.joinType)} join${lateralSql} ${tableSchema ? sql `${sql.identifier(tableSchema)}.` : undefined}${sql.identifier(origTableName)}${alias && sql ` ${sql.identifier(alias)}`} on ${joinMeta.on}`);
+                }
+                else if (is(table, View)) {
+                    const viewName = table[ViewBaseConfig].name;
+                    const viewSchema = table[ViewBaseConfig].schema;
+                    const origViewName = table[ViewBaseConfig].originalName;
+                    const alias = viewName === origViewName ? undefined : joinMeta.alias;
+                    joinsArray.push(sql `${sql.raw(joinMeta.joinType)} join${lateralSql} ${viewSchema ? sql `${sql.identifier(viewSchema)}.` : undefined}${sql.identifier(origViewName)}${alias && sql ` ${sql.identifier(alias)}`} on ${joinMeta.on}`);
+                }
+                else {
+                    joinsArray.push(sql `${sql.raw(joinMeta.joinType)} join${lateralSql} ${table} on ${joinMeta.on}`);
+                }
+                if (index < joins.length - 1) {
+                    joinsArray.push(sql ` `);
+                }
             }
         }
-        const joinsSql = sql.fromList(joinsArray);
+        const joinsSql = sql.join(joinsArray);
         const whereSql = where ? sql ` where ${where}` : undefined;
         const havingSql = having ? sql ` having ${having}` : undefined;
-        const orderByList = [];
-        for (const [index, orderByValue] of orderBy.entries()) {
-            orderByList.push(orderByValue);
-            if (index < orderBy.length - 1) {
-                orderByList.push(sql `, `);
-            }
+        let orderBySql;
+        if (orderBy && orderBy.length > 0) {
+            orderBySql = sql ` order by ${sql.join(orderBy, sql `, `)}`;
         }
-        const orderBySql = orderByList.length > 0 ? sql ` order by ${sql.fromList(orderByList)}` : undefined;
-        const groupByList = [];
-        for (const [index, groupByValue] of groupBy.entries()) {
-            groupByList.push(groupByValue);
-            if (index < groupBy.length - 1) {
-                groupByList.push(sql `, `);
-            }
+        let groupBySql;
+        if (groupBy && groupBy.length > 0) {
+            groupBySql = sql ` group by ${sql.join(groupBy, sql `, `)}`;
         }
-        const groupBySql = groupByList.length > 0 ? sql ` group by ${sql.fromList(groupByList)}` : undefined;
         const limitSql = limit ? sql ` limit ${limit}` : undefined;
         const offsetSql = offset ? sql ` offset ${offset}` : undefined;
         const lockingClausesSql = sql.empty();
-        for (const { strength, config } of lockingClauses) {
-            const clauseSql = sql ` for ${sql.raw(strength)}`;
-            if (config.of) {
-                clauseSql.append(sql ` of ${config.of}`);
-            }
-            if (config.noWait) {
-                clauseSql.append(sql ` no wait`);
-            }
-            else if (config.skipLocked) {
-                clauseSql.append(sql ` skip locked`);
+        if (lockingClauses) {
+            for (const { strength, config } of lockingClauses) {
+                const clauseSql = sql ` for ${sql.raw(strength)}`;
+                if (config.of) {
+                    clauseSql.append(sql ` of ${config.of}`);
+                }
+                if (config.noWait) {
+                    clauseSql.append(sql ` no wait`);
+                }
+                else if (config.skipLocked) {
+                    clauseSql.append(sql ` skip locked`);
+                }
+                lockingClausesSql.append(clauseSql);
             }
-            lockingClausesSql.append(clauseSql);
         }
         return sql `${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}${lockingClausesSql}`;
     }
@@ -869,7 +892,7 @@ class PgDialect {
         const colEntries = isSingleValue
             ? Object.keys(values[0]).map((fieldName) => [fieldName, columns[fieldName]])
             : Object.entries(columns);
-        const insertOrder = colEntries.map(([, column]) => name(column.name));
+        const insertOrder = colEntries.map(([, column]) => sql.identifier(column.name));
         for (const [valueIndex, value] of values.entries()) {
             const valueList = [];
             for (const [fieldName] of colEntries) {
@@ -886,7 +909,7 @@ class PgDialect {
                 valuesSqlList.push(sql `, `);
             }
         }
-        const valuesSql = sql.fromList(valuesSqlList);
+        const valuesSql = sql.join(valuesSqlList);
         const returningSql = returning
             ? sql ` returning ${this.buildSelection(returning, { isSingleTable: true })}`
             : undefined;
@@ -929,273 +952,702 @@ class PgDialect {
             prepareTyping: this.prepareTyping,
         });
     }
-    buildRelationalQuery(fullSchema, schema, tableNamesMap, table, tableConfig, config, tableAlias, relationColumns, isRoot = false) {
+    // buildRelationalQueryWithPK({
+    // 	fullSchema,
+    // 	schema,
+    // 	tableNamesMap,
+    // 	table,
+    // 	tableConfig,
+    // 	queryConfig: config,
+    // 	tableAlias,
+    // 	isRoot = false,
+    // 	joinOn,
+    // }: {
+    // 	fullSchema: Record<string, unknown>;
+    // 	schema: TablesRelationalConfig;
+    // 	tableNamesMap: Record<string, string>;
+    // 	table: AnyPgTable;
+    // 	tableConfig: TableRelationalConfig;
+    // 	queryConfig: true | DBQueryConfig<'many', true>;
+    // 	tableAlias: string;
+    // 	isRoot?: boolean;
+    // 	joinOn?: SQL;
+    // }): BuildRelationalQueryResult<AnyPgTable, AnyPgColumn> {
+    // 	// For { "<relation>": true }, return a table with selection of all columns
+    // 	if (config === true) {
+    // 		const selectionEntries = Object.entries(tableConfig.columns);
+    // 		const selection: BuildRelationalQueryResult<AnyPgTable, AnyPgColumn>['selection'] = selectionEntries.map((
+    // 			[key, value],
+    // 		) => ({
+    // 			dbKey: value.name,
+    // 			tsKey: key,
+    // 			field: value as AnyPgColumn,
+    // 			relationTableTsKey: undefined,
+    // 			isJson: false,
+    // 			selection: [],
+    // 		}));
+    // 		return {
+    // 			tableTsKey: tableConfig.tsName,
+    // 			sql: table,
+    // 			selection,
+    // 		};
+    // 	}
+    // 	// let selection: BuildRelationalQueryResult<AnyPgTable, AnyPgColumn>['selection'] = [];
+    // 	// let selectionForBuild = selection;
+    // 	const aliasedColumns = Object.fromEntries(
+    // 		Object.entries(tableConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)]),
+    // 	);
+    // 	const aliasedRelations = Object.fromEntries(
+    // 		Object.entries(tableConfig.relations).map(([key, value]) => [key, aliasedRelation(value, tableAlias)]),
+    // 	);
+    // 	const aliasedFields = Object.assign({}, aliasedColumns, aliasedRelations);
+    // 	let where, hasUserDefinedWhere;
+    // 	if (config.where) {
+    // 		const whereSql = typeof config.where === 'function' ? config.where(aliasedFields, operators) : config.where;
+    // 		where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
+    // 		hasUserDefinedWhere = !!where;
+    // 	}
+    // 	where = and(joinOn, where);
+    // 	// const fieldsSelection: { tsKey: string; value: AnyPgColumn | SQL.Aliased; isExtra?: boolean }[] = [];
+    // 	let joins: Join[] = [];
+    // 	let selectedColumns: string[] = [];
+    // 	// Figure out which columns to select
+    // 	if (config.columns) {
+    // 		let isIncludeMode = false;
+    // 		for (const [field, value] of Object.entries(config.columns)) {
+    // 			if (value === undefined) {
+    // 				continue;
+    // 			}
+    // 			if (field in tableConfig.columns) {
+    // 				if (!isIncludeMode && value === true) {
+    // 					isIncludeMode = true;
+    // 				}
+    // 				selectedColumns.push(field);
+    // 			}
+    // 		}
+    // 		if (selectedColumns.length > 0) {
+    // 			selectedColumns = isIncludeMode
+    // 				? selectedColumns.filter((c) => config.columns?.[c] === true)
+    // 				: Object.keys(tableConfig.columns).filter((key) => !selectedColumns.includes(key));
+    // 		}
+    // 	} else {
+    // 		// Select all columns if selection is not specified
+    // 		selectedColumns = Object.keys(tableConfig.columns);
+    // 	}
+    // 	// for (const field of selectedColumns) {
+    // 	// 	const column = tableConfig.columns[field]! as AnyPgColumn;
+    // 	// 	fieldsSelection.push({ tsKey: field, value: column });
+    // 	// }
+    // 	let initiallySelectedRelations: {
+    // 		tsKey: string;
+    // 		queryConfig: true | DBQueryConfig<'many', false>;
+    // 		relation: Relation;
+    // 	}[] = [];
+    // 	// let selectedRelations: BuildRelationalQueryResult<AnyPgTable, AnyPgColumn>['selection'] = [];
+    // 	// Figure out which relations to select
+    // 	if (config.with) {
+    // 		initiallySelectedRelations = Object.entries(config.with)
+    // 			.filter((entry): entry is [typeof entry[0], NonNullable<typeof entry[1]>] => !!entry[1])
+    // 			.map(([tsKey, queryConfig]) => ({ tsKey, queryConfig, relation: tableConfig.relations[tsKey]! }));
+    // 	}
+    // 	const manyRelations = initiallySelectedRelations.filter((r) =>
+    // 		is(r.relation, Many)
+    // 		&& (schema[tableNamesMap[r.relation.referencedTable[Table.Symbol.Name]]!]?.primaryKey.length ?? 0) > 0
+    // 	);
+    // 	// If this is the last Many relation (or there are no Many relations), we are on the innermost subquery level
+    // 	const isInnermostQuery = manyRelations.length < 2;
+    // 	const selectedExtras: {
+    // 		tsKey: string;
+    // 		value: SQL.Aliased;
+    // 	}[] = [];
+    // 	// Figure out which extras to select
+    // 	if (isInnermostQuery && config.extras) {
+    // 		const extras = typeof config.extras === 'function'
+    // 			? config.extras(aliasedFields, { sql })
+    // 			: config.extras;
+    // 		for (const [tsKey, value] of Object.entries(extras)) {
+    // 			selectedExtras.push({
+    // 				tsKey,
+    // 				value: mapColumnsInAliasedSQLToAlias(value, tableAlias),
+    // 			});
+    // 		}
+    // 	}
+    // 	// Transform `fieldsSelection` into `selection`
+    // 	// `fieldsSelection` shouldn't be used after this point
+    // 	// for (const { tsKey, value, isExtra } of fieldsSelection) {
+    // 	// 	selection.push({
+    // 	// 		dbKey: is(value, SQL.Aliased) ? value.fieldAlias : tableConfig.columns[tsKey]!.name,
+    // 	// 		tsKey,
+    // 	// 		field: is(value, Column) ? aliasedTableColumn(value, tableAlias) : value,
+    // 	// 		relationTableTsKey: undefined,
+    // 	// 		isJson: false,
+    // 	// 		isExtra,
+    // 	// 		selection: [],
+    // 	// 	});
+    // 	// }
+    // 	let orderByOrig = typeof config.orderBy === 'function'
+    // 		? config.orderBy(aliasedFields, orderByOperators)
+    // 		: config.orderBy ?? [];
+    // 	if (!Array.isArray(orderByOrig)) {
+    // 		orderByOrig = [orderByOrig];
+    // 	}
+    // 	const orderBy = orderByOrig.map((orderByValue) => {
+    // 		if (is(orderByValue, Column)) {
+    // 			return aliasedTableColumn(orderByValue, tableAlias) as AnyPgColumn;
+    // 		}
+    // 		return mapColumnsInSQLToAlias(orderByValue, tableAlias);
+    // 	});
+    // 	const limit = isInnermostQuery ? config.limit : undefined;
+    // 	const offset = isInnermostQuery ? config.offset : undefined;
+    // 	// For non-root queries without additional config except columns, return a table with selection
+    // 	if (
+    // 		!isRoot
+    // 		&& initiallySelectedRelations.length === 0
+    // 		&& selectedExtras.length === 0
+    // 		&& !where
+    // 		&& orderBy.length === 0
+    // 		&& limit === undefined
+    // 		&& offset === undefined
+    // 	) {
+    // 		return {
+    // 			tableTsKey: tableConfig.tsName,
+    // 			sql: table,
+    // 			selection: selectedColumns.map((key) => ({
+    // 				dbKey: tableConfig.columns[key]!.name,
+    // 				tsKey: key,
+    // 				field: tableConfig.columns[key] as AnyPgColumn,
+    // 				relationTableTsKey: undefined,
+    // 				isJson: false,
+    // 				selection: [],
+    // 			})),
+    // 		};
+    // 	}
+    // 	const selectedRelationsWithoutPK:
+    // 	// Process all relations without primary keys, because they need to be joined differently and will all be on the same query level
+    // 	for (
+    // 		const {
+    // 			tsKey: selectedRelationTsKey,
+    // 			queryConfig: selectedRelationConfigValue,
+    // 			relation,
+    // 		} of initiallySelectedRelations
+    // 	) {
+    // 		const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
+    // 		const relationTableName = relation.referencedTable[Table.Symbol.Name];
+    // 		const relationTableTsName = tableNamesMap[relationTableName]!;
+    // 		const relationTable = schema[relationTableTsName]!;
+    // 		if (relationTable.primaryKey.length > 0) {
+    // 			continue;
+    // 		}
+    // 		const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
+    // 		const joinOn = and(
+    // 			...normalizedRelation.fields.map((field, i) =>
+    // 				eq(
+    // 					aliasedTableColumn(normalizedRelation.references[i]!, relationTableAlias),
+    // 					aliasedTableColumn(field, tableAlias),
+    // 				)
+    // 			),
+    // 		);
+    // 		const builtRelation = this.buildRelationalQueryWithoutPK({
+    // 			fullSchema,
+    // 			schema,
+    // 			tableNamesMap,
+    // 			table: fullSchema[relationTableTsName] as AnyPgTable,
+    // 			tableConfig: schema[relationTableTsName]!,
+    // 			queryConfig: selectedRelationConfigValue,
+    // 			tableAlias: relationTableAlias,
+    // 			joinOn,
+    // 			nestedQueryRelation: relation,
+    // 		});
+    // 		const field = sql`${sql.identifier(relationTableAlias)}.${sql.identifier('data')}`.as(selectedRelationTsKey);
+    // 		joins.push({
+    // 			on: sql`true`,
+    // 			table: new Subquery(builtRelation.sql as SQL, {}, relationTableAlias),
+    // 			alias: relationTableAlias,
+    // 			joinType: 'left',
+    // 			lateral: true,
+    // 		});
+    // 		selectedRelations.push({
+    // 			dbKey: selectedRelationTsKey,
+    // 			tsKey: selectedRelationTsKey,
+    // 			field,
+    // 			relationTableTsKey: relationTableTsName,
+    // 			isJson: true,
+    // 			selection: builtRelation.selection,
+    // 		});
+    // 	}
+    // 	const oneRelations = initiallySelectedRelations.filter((r): r is typeof r & { relation: One } =>
+    // 		is(r.relation, One)
+    // 	);
+    // 	// Process all One relations with PKs, because they can all be joined on the same level
+    // 	for (
+    // 		const {
+    // 			tsKey: selectedRelationTsKey,
+    // 			queryConfig: selectedRelationConfigValue,
+    // 			relation,
+    // 		} of oneRelations
+    // 	) {
+    // 		const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
+    // 		const relationTableName = relation.referencedTable[Table.Symbol.Name];
+    // 		const relationTableTsName = tableNamesMap[relationTableName]!;
+    // 		const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
+    // 		const relationTable = schema[relationTableTsName]!;
+    // 		if (relationTable.primaryKey.length === 0) {
+    // 			continue;
+    // 		}
+    // 		const joinOn = and(
+    // 			...normalizedRelation.fields.map((field, i) =>
+    // 				eq(
+    // 					aliasedTableColumn(normalizedRelation.references[i]!, relationTableAlias),
+    // 					aliasedTableColumn(field, tableAlias),
+    // 				)
+    // 			),
+    // 		);
+    // 		const builtRelation = this.buildRelationalQueryWithPK({
+    // 			fullSchema,
+    // 			schema,
+    // 			tableNamesMap,
+    // 			table: fullSchema[relationTableTsName] as AnyPgTable,
+    // 			tableConfig: schema[relationTableTsName]!,
+    // 			queryConfig: selectedRelationConfigValue,
+    // 			tableAlias: relationTableAlias,
+    // 			joinOn,
+    // 		});
+    // 		const field = sql`case when ${sql.identifier(relationTableAlias)} is null then null else json_build_array(${
+    // 			sql.join(
+    // 				builtRelation.selection.map(({ field }) =>
+    // 					is(field, SQL.Aliased)
+    // 						? sql`${sql.identifier(relationTableAlias)}.${sql.identifier(field.fieldAlias)}`
+    // 						: is(field, Column)
+    // 						? aliasedTableColumn(field, relationTableAlias)
+    // 						: field
+    // 				),
+    // 				sql`, `,
+    // 			)
+    // 		}) end`.as(selectedRelationTsKey);
+    // 		const isLateralJoin = is(builtRelation.sql, SQL);
+    // 		joins.push({
+    // 			on: isLateralJoin ? sql`true` : joinOn,
+    // 			table: is(builtRelation.sql, SQL)
+    // 				? new Subquery(builtRelation.sql, {}, relationTableAlias)
+    // 				: aliasedTable(builtRelation.sql, relationTableAlias),
+    // 			alias: relationTableAlias,
+    // 			joinType: 'left',
+    // 			lateral: is(builtRelation.sql, SQL),
+    // 		});
+    // 		selectedRelations.push({
+    // 			dbKey: selectedRelationTsKey,
+    // 			tsKey: selectedRelationTsKey,
+    // 			field,
+    // 			relationTableTsKey: relationTableTsName,
+    // 			isJson: true,
+    // 			selection: builtRelation.selection,
+    // 		});
+    // 	}
+    // 	let distinct: PgSelectConfig['distinct'];
+    // 	let tableFrom: AnyPgTable | Subquery = table;
+    // 	// Process first Many relation - each one requires a nested subquery
+    // 	const manyRelation = manyRelations[0];
+    // 	if (manyRelation) {
+    // 		const {
+    // 			tsKey: selectedRelationTsKey,
+    // 			queryConfig: selectedRelationQueryConfig,
+    // 			relation,
+    // 		} = manyRelation;
+    // 		distinct = {
+    // 			on: tableConfig.primaryKey.map((c) => aliasedTableColumn(c as AnyPgColumn, tableAlias)),
+    // 		};
+    // 		const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
+    // 		const relationTableName = relation.referencedTable[Table.Symbol.Name];
+    // 		const relationTableTsName = tableNamesMap[relationTableName]!;
+    // 		const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
+    // 		const joinOn = and(
+    // 			...normalizedRelation.fields.map((field, i) =>
+    // 				eq(
+    // 					aliasedTableColumn(normalizedRelation.references[i]!, relationTableAlias),
+    // 					aliasedTableColumn(field, tableAlias),
+    // 				)
+    // 			),
+    // 		);
+    // 		const builtRelationJoin = this.buildRelationalQueryWithPK({
+    // 			fullSchema,
+    // 			schema,
+    // 			tableNamesMap,
+    // 			table: fullSchema[relationTableTsName] as AnyPgTable,
+    // 			tableConfig: schema[relationTableTsName]!,
+    // 			queryConfig: selectedRelationQueryConfig,
+    // 			tableAlias: relationTableAlias,
+    // 			joinOn,
+    // 		});
+    // 		const builtRelationSelectionField = sql`case when ${
+    // 			sql.identifier(relationTableAlias)
+    // 		} is null then '[]' else json_agg(json_build_array(${
+    // 			sql.join(
+    // 				builtRelationJoin.selection.map(({ field }) =>
+    // 					is(field, SQL.Aliased)
+    // 						? sql`${sql.identifier(relationTableAlias)}.${sql.identifier(field.fieldAlias)}`
+    // 						: is(field, Column)
+    // 						? aliasedTableColumn(field, relationTableAlias)
+    // 						: field
+    // 				),
+    // 				sql`, `,
+    // 			)
+    // 		})) over (partition by ${sql.join(distinct.on, sql`, `)}) end`.as(selectedRelationTsKey);
+    // 		const isLateralJoin = is(builtRelationJoin.sql, SQL);
+    // 		joins.push({
+    // 			on: isLateralJoin ? sql`true` : joinOn,
+    // 			table: isLateralJoin
+    // 				? new Subquery(builtRelationJoin.sql as SQL, {}, relationTableAlias)
+    // 				: aliasedTable(builtRelationJoin.sql as AnyPgTable, relationTableAlias),
+    // 			alias: relationTableAlias,
+    // 			joinType: 'left',
+    // 			lateral: isLateralJoin,
+    // 		});
+    // 		// Build the "from" subquery with the remaining Many relations
+    // 		const builtTableFrom = this.buildRelationalQueryWithPK({
+    // 			fullSchema,
+    // 			schema,
+    // 			tableNamesMap,
+    // 			table,
+    // 			tableConfig,
+    // 			queryConfig: {
+    // 				...config,
+    // 				where: undefined,
+    // 				orderBy: undefined,
+    // 				limit: undefined,
+    // 				offset: undefined,
+    // 				with: manyRelations.slice(1).reduce<NonNullable<typeof config['with']>>(
+    // 					(result, { tsKey, queryConfig: configValue }) => {
+    // 						result[tsKey] = configValue;
+    // 						return result;
+    // 					},
+    // 					{},
+    // 				),
+    // 			},
+    // 			tableAlias,
+    // 		});
+    // 		selectedRelations.push({
+    // 			dbKey: selectedRelationTsKey,
+    // 			tsKey: selectedRelationTsKey,
+    // 			field: builtRelationSelectionField,
+    // 			relationTableTsKey: relationTableTsName,
+    // 			isJson: true,
+    // 			selection: builtRelationJoin.selection,
+    // 		});
+    // 		// selection = builtTableFrom.selection.map((item) =>
+    // 		// 	is(item.field, SQL.Aliased)
+    // 		// 		? { ...item, field: sql`${sql.identifier(tableAlias)}.${sql.identifier(item.field.fieldAlias)}` }
+    // 		// 		: item
+    // 		// );
+    // 		// selectionForBuild = [{
+    // 		// 	dbKey: '*',
+    // 		// 	tsKey: '*',
+    // 		// 	field: sql`${sql.identifier(tableAlias)}.*`,
+    // 		// 	selection: [],
+    // 		// 	isJson: false,
+    // 		// 	relationTableTsKey: undefined,
+    // 		// }];
+    // 		// const newSelectionItem: (typeof selection)[number] = {
+    // 		// 	dbKey: selectedRelationTsKey,
+    // 		// 	tsKey: selectedRelationTsKey,
+    // 		// 	field,
+    // 		// 	relationTableTsKey: relationTableTsName,
+    // 		// 	isJson: true,
+    // 		// 	selection: builtRelationJoin.selection,
+    // 		// };
+    // 		// selection.push(newSelectionItem);
+    // 		// selectionForBuild.push(newSelectionItem);
+    // 		tableFrom = is(builtTableFrom.sql, PgTable)
+    // 			? builtTableFrom.sql
+    // 			: new Subquery(builtTableFrom.sql, {}, tableAlias);
+    // 	}
+    // 	if (selectedColumns.length === 0 && selectedRelations.length === 0 && selectedExtras.length === 0) {
+    // 		throw new DrizzleError(`No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")`);
+    // 	}
+    // 	let selection: BuildRelationalQueryResult<AnyPgTable, AnyPgColumn>['selection'];
+    // 	function prepareSelectedColumns() {
+    // 		return selectedColumns.map((key) => ({
+    // 			dbKey: tableConfig.columns[key]!.name,
+    // 			tsKey: key,
+    // 			field: tableConfig.columns[key] as AnyPgColumn,
+    // 			relationTableTsKey: undefined,
+    // 			isJson: false,
+    // 			selection: [],
+    // 		}));
+    // 	}
+    // 	function prepareSelectedExtras() {
+    // 		return selectedExtras.map((item) => ({
+    // 			dbKey: item.value.fieldAlias,
+    // 			tsKey: item.tsKey,
+    // 			field: item.value,
+    // 			relationTableTsKey: undefined,
+    // 			isJson: false,
+    // 			selection: [],
+    // 		}));
+    // 	}
+    // 	if (isRoot) {
+    // 		selection = [
+    // 			...prepareSelectedColumns(),
+    // 			...prepareSelectedExtras(),
+    // 		];
+    // 	}
+    // 	if (hasUserDefinedWhere || orderBy.length > 0) {
+    // 		tableFrom = new Subquery(
+    // 			this.buildSelectQuery({
+    // 				table: is(tableFrom, PgTable) ? aliasedTable(tableFrom, tableAlias) : tableFrom,
+    // 				fields: {},
+    // 				fieldsFlat: selectionForBuild.map(({ field }) => ({
+    // 					path: [],
+    // 					field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
+    // 				})),
+    // 				joins,
+    // 				distinct,
+    // 			}),
+    // 			{},
+    // 			tableAlias,
+    // 		);
+    // 		selectionForBuild = selection.map((item) =>
+    // 			is(item.field, SQL.Aliased)
+    // 				? { ...item, field: sql`${sql.identifier(tableAlias)}.${sql.identifier(item.field.fieldAlias)}` }
+    // 				: item
+    // 		);
+    // 		joins = [];
+    // 		distinct = undefined;
+    // 	}
+    // 	const result = this.buildSelectQuery({
+    // 		table: is(tableFrom, PgTable) ? aliasedTable(tableFrom, tableAlias) : tableFrom,
+    // 		fields: {},
+    // 		fieldsFlat: selectionForBuild.map(({ field }) => ({
+    // 			path: [],
+    // 			field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
+    // 		})),
+    // 		where,
+    // 		limit,
+    // 		offset,
+    // 		joins,
+    // 		orderBy,
+    // 		distinct,
+    // 	});
+    // 	return {
+    // 		tableTsKey: tableConfig.tsName,
+    // 		sql: result,
+    // 		selection,
+    // 	};
+    // }
+    buildRelationalQueryWithoutPK({ fullSchema, schema, tableNamesMap, table, tableConfig, queryConfig: config, tableAlias, nestedQueryRelation, joinOn, }) {
+        let selection = [];
+        let limit, offset, orderBy = [], where;
+        const joins = [];
         if (config === true) {
             const selectionEntries = Object.entries(tableConfig.columns);
-            const selection = selectionEntries.map(([key, value]) => ({
+            selection = selectionEntries.map(([key, value]) => ({
                 dbKey: value.name,
                 tsKey: key,
-                field: value,
-                tableTsKey: undefined,
+                field: aliasedTableColumn(value, tableAlias),
+                relationTableTsKey: undefined,
                 isJson: false,
                 selection: [],
             }));
-            return {
-                tableTsKey: tableConfig.tsName,
-                sql: table,
-                selection,
-            };
         }
-        const aliasedColumns = Object.fromEntries(Object.entries(tableConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)]));
-        const aliasedRelations = Object.fromEntries(Object.entries(tableConfig.relations).map(([key, value]) => [key, aliasedRelation(value, tableAlias)]));
-        const aliasedFields = Object.assign({}, aliasedColumns, aliasedRelations);
-        const fieldsSelection = {};
-        let selectedColumns = [];
-        let selectedExtras = [];
-        let selectedRelations = [];
-        if (config.columns) {
-            let isIncludeMode = false;
-            for (const [field, value] of Object.entries(config.columns)) {
-                if (value === undefined) {
-                    continue;
-                }
-                if (field in tableConfig.columns) {
-                    if (!isIncludeMode && value === true) {
-                        isIncludeMode = true;
+        else {
+            const aliasedColumns = Object.fromEntries(Object.entries(tableConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)]));
+            if (config.where) {
+                const whereSql = typeof config.where === 'function' ? config.where(aliasedColumns, operators) : config.where;
+                where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
+            }
+            const fieldsSelection = [];
+            let selectedColumns = [];
+            // Figure out which columns to select
+            if (config.columns) {
+                let isIncludeMode = false;
+                for (const [field, value] of Object.entries(config.columns)) {
+                    if (value === undefined) {
+                        continue;
+                    }
+                    if (field in tableConfig.columns) {
+                        if (!isIncludeMode && value === true) {
+                            isIncludeMode = true;
+                        }
+                        selectedColumns.push(field);
                     }
-                    selectedColumns.push(field);
+                }
+                if (selectedColumns.length > 0) {
+                    selectedColumns = isIncludeMode
+                        ? selectedColumns.filter((c) => config.columns?.[c] === true)
+                        : Object.keys(tableConfig.columns).filter((key) => !selectedColumns.includes(key));
                 }
             }
-            if (selectedColumns.length > 0) {
-                selectedColumns = isIncludeMode
-                    ? selectedColumns.filter((c) => config.columns?.[c] === true)
-                    : Object.keys(tableConfig.columns).filter((key) => !selectedColumns.includes(key));
+            else {
+                // Select all columns if selection is not specified
+                selectedColumns = Object.keys(tableConfig.columns);
+            }
+            for (const field of selectedColumns) {
+                const column = tableConfig.columns[field];
+                fieldsSelection.push({ tsKey: field, value: column });
+            }
+            let selectedRelations = [];
+            // Figure out which relations to select
+            if (config.with) {
+                selectedRelations = Object.entries(config.with)
+                    .filter((entry) => !!entry[1])
+                    .map(([tsKey, queryConfig]) => ({ tsKey, queryConfig, relation: tableConfig.relations[tsKey] }));
+            }
+            let extras;
+            // Figure out which extras to select
+            if (config.extras) {
+                extras = typeof config.extras === 'function'
+                    ? config.extras(aliasedColumns, { sql })
+                    : config.extras;
+                for (const [tsKey, value] of Object.entries(extras)) {
+                    fieldsSelection.push({
+                        tsKey,
+                        value: mapColumnsInAliasedSQLToAlias(value, tableAlias),
+                    });
+                }
             }
-        }
-        if (config.with) {
-            selectedRelations = Object.entries(config.with)
-                .filter((entry) => !!entry[1])
-                .map(([key, value]) => ({ key, value }));
-        }
-        if (!config.columns) {
-            selectedColumns = Object.keys(tableConfig.columns);
-        }
-        if (config.extras) {
-            const extrasOrig = typeof config.extras === 'function'
-                ? config.extras(aliasedFields, { sql })
-                : config.extras;
-            selectedExtras = Object.entries(extrasOrig).map(([key, value]) => ({
-                key,
-                value: mapColumnsInAliasedSQLToAlias(value, tableAlias),
-            }));
-        }
-        for (const field of selectedColumns) {
-            const column = tableConfig.columns[field];
-            fieldsSelection[field] = column;
-        }
-        for (const { key, value } of selectedExtras) {
-            fieldsSelection[key] = value;
-        }
-        let where;
-        if (config.where) {
-            const whereSql = typeof config.where === 'function' ? config.where(aliasedFields, operators) : config.where;
-            where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
-        }
-        const groupBy = ((tableConfig.primaryKey.length > 0 && selectedRelations.length < 2)
-            ? tableConfig.primaryKey
-            : Object.values(tableConfig.columns)).map((c) => aliasedTableColumn(c, tableAlias));
-        let orderByOrig = typeof config.orderBy === 'function'
-            ? config.orderBy(aliasedFields, orderByOperators)
-            : config.orderBy ?? [];
-        if (!Array.isArray(orderByOrig)) {
-            orderByOrig = [orderByOrig];
-        }
-        const orderBy = orderByOrig.map((orderByValue) => {
-            if (is(orderByValue, Column)) {
-                return aliasedTableColumn(orderByValue, tableAlias);
+            // Transform `fieldsSelection` into `selection`
+            // `fieldsSelection` shouldn't be used after this point
+            for (const { tsKey, value } of fieldsSelection) {
+                selection.push({
+                    dbKey: is(value, SQL.Aliased) ? value.fieldAlias : tableConfig.columns[tsKey].name,
+                    tsKey,
+                    field: is(value, Column) ? aliasedTableColumn(value, tableAlias) : value,
+                    relationTableTsKey: undefined,
+                    isJson: false,
+                    selection: [],
+                });
             }
-            return mapColumnsInSQLToAlias(orderByValue, tableAlias);
-        });
-        const builtRelations = [];
-        const builtRelationFields = [];
-        let result;
-        let selectedRelationIndex = 0;
-        for (const { key: selectedRelationKey, value: selectedRelationValue } of selectedRelations) {
-            let relation;
-            for (const [relationKey, relationValue] of Object.entries(tableConfig.relations)) {
-                if (is(relationValue, Relation) && relationKey === selectedRelationKey) {
-                    relation = relationValue;
-                    break;
-                }
+            let orderByOrig = typeof config.orderBy === 'function'
+                ? config.orderBy(aliasedColumns, orderByOperators)
+                : config.orderBy ?? [];
+            if (!Array.isArray(orderByOrig)) {
+                orderByOrig = [orderByOrig];
             }
-            if (!relation) {
-                throw new Error(`Relation ${selectedRelationKey} not found`);
-            }
-            const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
-            const relationAlias = `${tableAlias}_${selectedRelationKey}`;
-            const relationConfig = schema[tableNamesMap[relation.referencedTable[Table.Symbol.Name]]];
-            const builtRelation = this.buildRelationalQuery(fullSchema, schema, tableNamesMap, fullSchema[tableNamesMap[relation.referencedTable[Table.Symbol.Name]]], schema[tableNamesMap[relation.referencedTable[Table.Symbol.Name]]], selectedRelationValue, relationAlias, normalizedRelation.references);
-            builtRelations.push({ key: selectedRelationKey, value: builtRelation });
-            let relationWhere;
-            if (typeof selectedRelationValue === 'object' && selectedRelationValue.limit) {
-                const field = sql `${sql.identifier(relationAlias)}.${sql.identifier('__drizzle_row_number')}`;
-                relationWhere = and(relationWhere, or(and(sql `${field} <= ${selectedRelationValue.limit}`), sql `(${field} is null)`));
-            }
-            const join = {
-                table: is(builtRelation.sql, Table)
-                    ? aliasedTable(builtRelation.sql, relationAlias)
-                    : new Subquery(builtRelation.sql, {}, relationAlias),
-                alias: relationAlias,
-                on: and(...normalizedRelation.fields.map((field, i) => eq(aliasedTableColumn(field, tableAlias), aliasedTableColumn(normalizedRelation.references[i], relationAlias)))),
-                joinType: 'left',
-            };
-            const relationAliasedColumns = Object.fromEntries(Object.entries(relationConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)]));
-            const relationAliasedRelations = Object.fromEntries(Object.entries(relationConfig.relations).map(([key, value]) => [key, aliasedRelation(value, tableAlias)]));
-            const relationAliasedFields = Object.assign({}, relationAliasedColumns, relationAliasedRelations);
-            let relationOrderBy;
-            if (typeof selectedRelationValue === 'object') {
-                let orderByOrig = typeof selectedRelationValue.orderBy === 'function'
-                    ? selectedRelationValue.orderBy(relationAliasedFields, orderByOperators)
-                    : selectedRelationValue.orderBy ?? [];
-                if (!Array.isArray(orderByOrig)) {
-                    orderByOrig = [orderByOrig];
+            orderBy = orderByOrig.map((orderByValue) => {
+                if (is(orderByValue, Column)) {
+                    return aliasedTableColumn(orderByValue, tableAlias);
                 }
-                relationOrderBy = orderByOrig.map((orderByValue) => {
-                    if (is(orderByValue, Column)) {
-                        return aliasedTableColumn(orderByValue, relationAlias);
-                    }
-                    return mapColumnsInSQLToAlias(orderByValue, relationAlias);
+                return mapColumnsInSQLToAlias(orderByValue, tableAlias);
+            });
+            limit = config.limit;
+            offset = config.offset;
+            // Process all relations
+            for (const { tsKey: selectedRelationTsKey, queryConfig: selectedRelationConfigValue, relation, } of selectedRelations) {
+                const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
+                const relationTableName = relation.referencedTable[Table.Symbol.Name];
+                const relationTableTsName = tableNamesMap[relationTableName];
+                const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
+                const joinOn = and(...normalizedRelation.fields.map((field, i) => eq(aliasedTableColumn(normalizedRelation.references[i], relationTableAlias), aliasedTableColumn(field, tableAlias))));
+                const builtRelation = this.buildRelationalQueryWithoutPK({
+                    fullSchema,
+                    schema,
+                    tableNamesMap,
+                    table: fullSchema[relationTableTsName],
+                    tableConfig: schema[relationTableTsName],
+                    queryConfig: is(relation, One)
+                        ? (selectedRelationConfigValue === true
+                            ? { limit: 1 }
+                            : { ...selectedRelationConfigValue, limit: 1 })
+                        : selectedRelationConfigValue,
+                    tableAlias: relationTableAlias,
+                    joinOn,
+                    nestedQueryRelation: relation,
+                });
+                const field = sql `${sql.identifier(relationTableAlias)}.${sql.identifier('data')}`.as(selectedRelationTsKey);
+                joins.push({
+                    on: sql `true`,
+                    table: new Subquery(builtRelation.sql, {}, relationTableAlias),
+                    alias: relationTableAlias,
+                    joinType: 'left',
+                    lateral: true,
+                });
+                selection.push({
+                    dbKey: selectedRelationTsKey,
+                    tsKey: selectedRelationTsKey,
+                    field,
+                    relationTableTsKey: relationTableTsName,
+                    isJson: true,
+                    selection: builtRelation.selection,
                 });
             }
-            const relationOrderBySql = relationOrderBy?.length
-                ? sql ` order by ${sql.join(relationOrderBy, sql `, `)}`
-                : undefined;
-            const elseField = sql `json_agg(json_build_array(${sql.join(builtRelation.selection.map(({ dbKey: key, isJson }) => {
-                let field = sql `${sql.identifier(relationAlias)}.${sql.identifier(key)}`;
-                if (isJson) {
-                    field = sql `${field}::json`;
-                }
-                return field;
-            }), sql `, `)})${relationOrderBySql})`;
-            if (selectedRelations.length > 1) {
-                elseField.append(sql.raw('::text'));
-            }
-            const countSql = normalizedRelation.references.length === 1
-                ? aliasedTableColumn(normalizedRelation.references[0], relationAlias)
-                : sql.fromList([
-                    sql `coalesce(`,
-                    sql.join(normalizedRelation.references.map((c) => aliasedTableColumn(c, relationAlias)), sql.raw(', ')),
-                    sql.raw(')'),
-                ]);
-            const field = sql `case when count(${countSql}) = 0 then '[]' else ${elseField} end`.as(selectedRelationKey);
-            const builtRelationField = {
-                path: [selectedRelationKey],
-                field,
-            };
+        }
+        if (selection.length === 0) {
+            throw new DrizzleError(`No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")`);
+        }
+        let result;
+        where = and(joinOn, where);
+        if (nestedQueryRelation) {
+            let field = sql `json_build_array(${sql.join(selection.map(({ field, tsKey, isJson }) => isJson
+                ? sql `${sql.identifier(`${tableAlias}_${tsKey}`)}.${sql.identifier('data')}`
+                : is(field, SQL.Aliased)
+                    ? field.sql
+                    : field), sql `, `)})`;
+            if (is(nestedQueryRelation, Many)) {
+                field = sql `coalesce(json_agg(${field}${orderBy.length > 0 ? sql ` order by ${sql.join(orderBy, sql `, `)}` : undefined}), '[]'::json)`;
+                // orderBy = [];
+            }
+            const nestedSelection = [{
+                    dbKey: 'data',
+                    tsKey: 'data',
+                    field: field.as('data'),
+                    isJson: true,
+                    relationTableTsKey: tableConfig.tsName,
+                    selection,
+                }];
+            const needsSubquery = limit !== undefined || offset !== undefined || orderBy.length > 0;
+            if (needsSubquery) {
+                result = this.buildSelectQuery({
+                    table: aliasedTable(table, tableAlias),
+                    fields: {},
+                    fieldsFlat: [{
+                            path: [],
+                            field: sql.raw('*'),
+                        }],
+                    where,
+                    limit,
+                    offset,
+                    orderBy,
+                });
+                where = undefined;
+                limit = undefined;
+                offset = undefined;
+                orderBy = [];
+            }
+            else {
+                result = aliasedTable(table, tableAlias);
+            }
             result = this.buildSelectQuery({
-                table: result ? new Subquery(result, {}, tableAlias) : aliasedTable(table, tableAlias),
+                table: is(result, PgTable) ? result : new Subquery(result, {}, tableAlias),
                 fields: {},
-                fieldsFlat: [
-                    {
-                        path: [],
-                        field: sql `${sql.identifier(tableAlias)}.*`,
-                    },
-                    ...(selectedRelationIndex === selectedRelations.length - 1
-                        ? selectedExtras.map(({ key, value }) => ({
-                            path: [key],
-                            field: value,
-                        }))
-                        : []),
-                    builtRelationField,
-                ],
-                where: relationWhere,
-                groupBy: [
-                    ...groupBy,
-                    ...builtRelationFields.map(({ field }) => sql `${sql.identifier(tableAlias)}.${sql.identifier(field.fieldAlias)}`),
-                ],
-                orderBy: selectedRelationIndex === selectedRelations.length - 1 ? orderBy : [],
-                joins: [join],
-                lockingClauses: [],
+                fieldsFlat: nestedSelection.map(({ field }) => ({
+                    path: [],
+                    field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
+                })),
+                joins,
+                where,
+                limit,
+                offset,
+                orderBy,
             });
-            builtRelationFields.push(builtRelationField);
-            selectedRelationIndex++;
         }
-        const finalFieldsSelection = Object.entries(fieldsSelection).map(([key, value]) => {
-            return {
-                path: [key],
-                field: is(value, Column) ? aliasedTableColumn(value, tableAlias) : value,
-            };
-        });
-        const finalFieldsFlat = isRoot
-            ? [
-                ...finalFieldsSelection.map(({ path, field }) => ({
-                    path,
-                    field: is(field, SQL.Aliased) ? sql `${sql.identifier(field.fieldAlias)}` : field,
-                })),
-                ...builtRelationFields.map(({ path, field }) => ({
-                    path,
-                    field: sql `${sql.identifier(field.fieldAlias)}${selectedRelations.length > 1 ? sql.raw('::json') : undefined}`,
-                })),
-            ]
-            : [
-                {
+        else {
+            result = this.buildSelectQuery({
+                table: aliasedTable(table, tableAlias),
+                fields: {},
+                fieldsFlat: selection.map(({ field }) => ({
                     path: [],
-                    field: sql `${sql.identifier(tableAlias)}.*`,
-                },
-                ...(builtRelationFields.length === 0
-                    ? selectedExtras.map(({ key, value }) => ({
-                        path: [key],
-                        field: value,
-                    }))
-                    : []),
-            ];
-        let limit, offset;
-        if (config.limit !== undefined || config.offset !== undefined) {
-            if (isRoot) {
-                limit = config.limit;
-                offset = config.offset;
-            }
-            else {
-                finalFieldsFlat.push({
-                    path: ['__drizzle_row_number'],
-                    field: sql `row_number() over(partition by ${relationColumns.map((c) => aliasedTableColumn(c, tableAlias))}${orderBy.length ? sql ` order by ${sql.join(orderBy, sql `, `)}` : undefined})`
-                        .as('__drizzle_row_number'),
-                });
-            }
+                    field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
+                })),
+                joins,
+                where,
+                limit,
+                offset,
+                orderBy,
+            });
         }
-        result = this.buildSelectQuery({
-            table: result ? new Subquery(result, {}, tableAlias) : aliasedTable(table, tableAlias),
-            fields: {},
-            fieldsFlat: finalFieldsFlat,
-            where,
-            groupBy: [],
-            orderBy: orderBy ?? [],
-            joins: [],
-            lockingClauses: [],
-            limit,
-            offset: offset,
-        });
         return {
             tableTsKey: tableConfig.tsName,
             sql: result,
-            selection: [
-                ...finalFieldsSelection.map(({ path, field }) => ({
-                    dbKey: is(field, SQL.Aliased) ? field.fieldAlias : tableConfig.columns[path[0]].name,
-                    tsKey: path[0],
-                    field,
-                    tableTsKey: undefined,
-                    isJson: false,
-                    selection: [],
-                })),
-                ...builtRelations.map(({ key, value }) => ({
-                    dbKey: key,
-                    tsKey: key,
-                    field: undefined,
-                    tableTsKey: value.tableTsKey,
-                    isJson: true,
-                    selection: value.selection,
-                })),
-            ],
+            selection,
         };
     }
 }
@@ -1275,10 +1727,6 @@ class PgSelectQueryBuilder extends TypedQueryBuilder {
             withList,
             table,
             fields: { ...fields },
-            joins: [],
-            orderBy: [],
-            groupBy: [],
-            lockingClauses: [],
             distinct,
         };
         this.isPartialSelect = isPartialSelect;
@@ -1294,7 +1742,7 @@ class PgSelectQueryBuilder extends TypedQueryBuilder {
         return (table, on) => {
             const baseTableName = this.tableName;
             const tableName = getTableLikeName(table);
-            if (typeof tableName === 'string' && this.config.joins.some((join) => join.alias === tableName)) {
+            if (typeof tableName === 'string' && this.config.joins?.some((join) => join.alias === tableName)) {
                 throw new Error(`Alias "${tableName}" is already used in this query`);
             }
             if (!this.isPartialSelect) {
@@ -1316,6 +1764,9 @@ class PgSelectQueryBuilder extends TypedQueryBuilder {
             if (typeof on === 'function') {
                 on = on(new Proxy(this.config.fields, new SelectionProxyHandler({ sqlAliasedBehavior: 'sql', sqlBehavior: 'sql' })));
             }
+            if (!this.config.joins) {
+                this.config.joins = [];
+            }
             this.config.joins.push({ on, table, joinType, alias: tableName });
             if (typeof tableName === 'string') {
                 switch (joinType) {
@@ -1464,6 +1915,9 @@ class PgSelectQueryBuilder extends TypedQueryBuilder {
      * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FOR-UPDATE-SHARE|Postgres locking clause documentation}
      */
     for(strength, config = {}) {
+        if (!this.config.lockingClauses) {
+            this.config.lockingClauses = [];
+        }
         this.config.lockingClauses.push({ strength, config });
         return this;
     }
@@ -2526,14 +2980,10 @@ function mapRelationalRow(tablesConfig, tableConfig, row, buildQueryResultSelect
             const relation = tableConfig.relations[selectionItem.tsKey];
             const rawSubRows = row[selectionItemIndex];
             const subRows = typeof rawSubRows === 'string' ? JSON.parse(rawSubRows) : rawSubRows;
-            if (is(relation, One)) {
-                result[selectionItem.tsKey] = subRows[0]
-                    ? mapRelationalRow(tablesConfig, tablesConfig[selectionItem.tableTsKey], subRows[0], selectionItem.selection, mapColumnValue)
-                    : null;
-            }
-            else {
-                result[selectionItem.tsKey] = subRows.map((subRow) => mapRelationalRow(tablesConfig, tablesConfig[selectionItem.tableTsKey], subRow, selectionItem.selection, mapColumnValue));
-            }
+            result[selectionItem.tsKey] = is(relation, One)
+                ? subRows
+                    && mapRelationalRow(tablesConfig, tablesConfig[selectionItem.relationTableTsKey], subRows, selectionItem.selection, mapColumnValue)
+                : subRows.map((subRow) => mapRelationalRow(tablesConfig, tablesConfig[selectionItem.relationTableTsKey], subRow, selectionItem.selection, mapColumnValue));
         }
         else {
             const value = mapColumnValue(row[selectionItemIndex]);
@@ -2585,7 +3035,7 @@ function and(...unfilteredConditions) {
         }
     }
     chunks.push(sql `)`);
-    return sql.fromList(chunks);
+    return sql.join(chunks);
 }
 function or(...unfilteredConditions) {
     const conditions = unfilteredConditions.filter((c) => c !== undefined);
@@ -2605,7 +3055,7 @@ function or(...unfilteredConditions) {
         }
     }
     chunks.push(sql `)`);
-    return sql.fromList(chunks);
+    return sql.join(chunks);
 }
 /**
  * Negate the meaning of an expression using the `not` keyword.
@@ -3138,6 +3588,7 @@ function sql(strings, ...params) {
         return new SQL([]);
     }
     sql.empty = empty;
+    /** @deprecated - use `sql.join()` */
     function fromList(list) {
         return new SQL(list);
     }
@@ -3151,24 +3602,43 @@ function sql(strings, ...params) {
     }
     sql.raw = raw;
     /**
-     * Convenience function to join a list of SQL chunks with a separator.
+     * Join a list of SQL chunks with a separator.
+     * @example
+     * ```ts
+     * const query = sql.join([sql`a`, sql`b`, sql`c`]);
+     * // sql`abc`
+     * ```
+     * @example
+     * ```ts
+     * const query = sql.join([sql`a`, sql`b`, sql`c`], sql`, `);
+     * // sql`a, b, c`
+     * ```
      */
     function join(chunks, separator) {
         const result = [];
         for (const [i, chunk] of chunks.entries()) {
-            if (i > 0) {
+            if (i > 0 && separator !== undefined) {
                 result.push(separator);
             }
             result.push(chunk);
         }
-        return sql.fromList(result);
+        return new SQL(result);
     }
     sql.join = join;
     /**
-     *  Any DB identifier (table name, column name, index name etc.)
+     * Create a SQL chunk that represents a DB identifier (table, column, index etc.).
+     * When used in a query, the identifier will be escaped based on the DB engine.
+     * For example, in PostgreSQL, identifiers are escaped with double quotes.
+     *
+     * **WARNING: This function does not offer any protection against SQL injections, so you must validate any user input beforehand.**
+     *
+     * @example ```ts
+     * const query = sql`SELECT * FROM ${sql.identifier('my-table')}`;
+     * // 'SELECT * FROM "my-table"'
+     * ```
      */
     function identifier(value) {
-        return name(value);
+        return new Name(value);
     }
     sql.identifier = identifier;
 })(sql || (sql = {}));
@@ -3297,7 +3767,7 @@ function mapColumnsInAliasedSQLToAlias(query, alias) {
     return new SQL.Aliased(mapColumnsInSQLToAlias(query.sql, alias), query.fieldAlias);
 }
 function mapColumnsInSQLToAlias(query, alias) {
-    return sql.fromList(query.queryChunks.map((c) => {
+    return sql.join(query.queryChunks.map((c) => {
         if (is(c, Column)) {
             return aliasedTableColumn(c, alias);
         }
@@ -3311,5 +3781,5 @@ function mapColumnsInSQLToAlias(query, alias) {
     }));
 }
 
-export { check as $, mapColumnsInSQLToAlias as A, orderByOperators as B, Column as C, normalizeRelation as D, and as E, or as F, aliasedTable as G, eq as H, TypedQueryBuilder as I, getTableLikeName as J, applyMixins as K, ColumnBuilder as L, TableAliasProxyHandler as M, PgColumnBuilder as N, PgColumn as O, PgDialect as P, QueryPromise as Q, Relation as R, SQL as S, Table as T, pgTableWithSchema as U, View as V, WithSubquery as W, pgViewWithSchema as X, pgMaterializedViewWithSchema as Y, CheckBuilder as Z, Check as _, extractTablesRelationalConfig as a, PgViewConfig as a$, PgArrayBuilder as a0, PgArray as a1, PgDateBuilder as a2, PgDate as a3, PgDateStringBuilder as a4, PgDateString as a5, date as a6, PgJsonBuilder as a7, PgJson as a8, json as a9, primaryKey as aA, PrimaryKeyBuilder as aB, PrimaryKey as aC, unique as aD, uniqueKeyName as aE, UniqueConstraintBuilder as aF, UniqueOnConstraintBuilder as aG, UniqueConstraint as aH, PgSelectQueryBuilder as aI, PgSelect as aJ, InlineForeignKeys as aK, PgTable as aL, pgTable as aM, pgTableCreator as aN, getTableConfig as aO, getViewConfig as aP, getMaterializedViewConfig as aQ, parsePgNestedArray as aR, parsePgArray as aS, makePgArray as aT, DefaultViewBuilderCore as aU, ViewBuilder as aV, ManualViewBuilder as aW, MaterializedViewBuilderCore as aX, MaterializedViewBuilder as aY, ManualMaterializedViewBuilder as aZ, PgViewBase as a_, PgJsonbBuilder as aa, PgJsonb as ab, jsonb as ac, PgNumericBuilder as ad, PgNumeric as ae, numeric as af, decimal as ag, PgTimeBuilder as ah, PgTime as ai, time as aj, PgTimestampBuilder as ak, PgTimestamp as al, PgTimestampStringBuilder as am, PgTimestampString as an, timestamp as ao, PgUUIDBuilder as ap, PgUUID as aq, uuid as ar, ForeignKeyBuilder as as, ForeignKey as at, foreignKey as au, IndexBuilderOn as av, IndexBuilder as aw, Index as ax, index as ay, uniqueIndex as az, Param as b, PgView as b0, PgMaterializedViewConfig as b1, PgMaterializedView as b2, pgView as b3, pgMaterializedView as b4, ColumnAliasProxyHandler as b5, RelationTableAliasProxyHandler as b6, hasOwnEntityKind as b7, bindIfParam as b8, ne as b9, isSQLWrapper as bA, StringChunk as bB, Name as bC, isDriverValueEncoder as bD, noopDecoder as bE, noopEncoder as bF, noopMapper as bG, Placeholder as bH, placeholder as bI, TableName as bJ, Schema as bK, Columns as bL, OriginalName as bM, BaseName as bN, IsAlias as bO, ExtraConfigBuilder as bP, isTable as bQ, iife as bR, not as ba, gt as bb, gte as bc, lt as bd, lte as be, inArray as bf, notInArray as bg, isNull as bh, isNotNull as bi, exists as bj, notExists as bk, between as bl, notBetween as bm, like as bn, notLike as bo, ilike as bp, notIlike as bq, asc as br, desc as bs, Relations as bt, One as bu, Many as bv, relations as bw, createOne as bx, createMany as by, FakePrimitiveParam as bz, createTableRelationsHelpers as c, mapUpdateSet as d, entityKind as e, fillPlaceholders as f, mapRelationalRow as g, QueryBuilder as h, is as i, SelectionProxyHandler as j, PgSelectBuilder as k, getTableColumns as l, mapResultRow as m, name as n, orderSelectedFields as o, getTableName as p, Subquery as q, SubqueryConfig as r, sql as s, tracer as t, ViewBaseConfig as u, param as v, aliasedTableColumn as w, aliasedRelation as x, mapColumnsInAliasedSQLToAlias as y, operators as z };
-//# sourceMappingURL=alias-3e926a50.mjs.map
+export { check as $, mapColumnsInAliasedSQLToAlias as A, orderByOperators as B, ColumnBuilder as C, normalizeRelation as D, and as E, eq as F, DrizzleError as G, aliasedTable as H, applyMixins as I, TypedQueryBuilder as J, getTableLikeName as K, param as L, Many as M, PgColumnBuilder as N, One as O, PgDialect as P, QueryPromise as Q, PgColumn as R, SQL as S, Table as T, pgTableWithSchema as U, ViewBaseConfig as V, WithSubquery as W, pgViewWithSchema as X, pgMaterializedViewWithSchema as Y, CheckBuilder as Z, Check as _, extractTablesRelationalConfig as a, PgViewConfig as a$, PgArrayBuilder as a0, PgArray as a1, PgDateBuilder as a2, PgDate as a3, PgDateStringBuilder as a4, PgDateString as a5, date as a6, PgJsonBuilder as a7, PgJson as a8, json as a9, primaryKey as aA, PrimaryKeyBuilder as aB, PrimaryKey as aC, unique as aD, uniqueKeyName as aE, UniqueConstraintBuilder as aF, UniqueOnConstraintBuilder as aG, UniqueConstraint as aH, PgSelectQueryBuilder as aI, PgSelect as aJ, InlineForeignKeys as aK, PgTable as aL, pgTable as aM, pgTableCreator as aN, getTableConfig as aO, getViewConfig as aP, getMaterializedViewConfig as aQ, parsePgNestedArray as aR, parsePgArray as aS, makePgArray as aT, DefaultViewBuilderCore as aU, ViewBuilder as aV, ManualViewBuilder as aW, MaterializedViewBuilderCore as aX, MaterializedViewBuilder as aY, ManualMaterializedViewBuilder as aZ, PgViewBase as a_, PgJsonbBuilder as aa, PgJsonb as ab, jsonb as ac, PgNumericBuilder as ad, PgNumeric as ae, numeric as af, decimal as ag, PgTimeBuilder as ah, PgTime as ai, time as aj, PgTimestampBuilder as ak, PgTimestamp as al, PgTimestampStringBuilder as am, PgTimestampString as an, timestamp as ao, PgUUIDBuilder as ap, PgUUID as aq, uuid as ar, ForeignKeyBuilder as as, ForeignKey as at, foreignKey as au, IndexBuilderOn as av, IndexBuilder as aw, Index as ax, index as ay, uniqueIndex as az, Param as b, PgView as b0, PgMaterializedViewConfig as b1, PgMaterializedView as b2, pgView as b3, pgMaterializedView as b4, ColumnAliasProxyHandler as b5, RelationTableAliasProxyHandler as b6, aliasedRelation as b7, hasOwnEntityKind as b8, bindIfParam as b9, FakePrimitiveParam as bA, isSQLWrapper as bB, StringChunk as bC, Name as bD, name as bE, isDriverValueEncoder as bF, noopDecoder as bG, noopEncoder as bH, noopMapper as bI, Placeholder as bJ, placeholder as bK, TableName as bL, Schema as bM, Columns as bN, OriginalName as bO, BaseName as bP, IsAlias as bQ, ExtraConfigBuilder as bR, isTable as bS, iife as bT, ne as ba, or as bb, not as bc, gt as bd, gte as be, lt as bf, lte as bg, inArray as bh, notInArray as bi, isNull as bj, isNotNull as bk, exists as bl, notExists as bm, between as bn, notBetween as bo, like as bp, notLike as bq, ilike as br, notIlike as bs, asc as bt, desc as bu, Relation as bv, Relations as bw, relations as bx, createOne as by, createMany as bz, createTableRelationsHelpers as c, mapUpdateSet as d, entityKind as e, fillPlaceholders as f, mapRelationalRow as g, QueryBuilder as h, is as i, SelectionProxyHandler as j, PgSelectBuilder as k, TransactionRollbackError as l, mapResultRow as m, TableAliasProxyHandler as n, orderSelectedFields as o, Column as p, getTableColumns as q, View as r, sql as s, tracer as t, getTableName as u, Subquery as v, SubqueryConfig as w, aliasedTableColumn as x, operators as y, mapColumnsInSQLToAlias as z };
+//# sourceMappingURL=alias-340e2b86.mjs.map