Spaces:
Sleeping
Sleeping
| ; | |
| var __defProp = Object.defineProperty; | |
| var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | |
| var __getOwnPropNames = Object.getOwnPropertyNames; | |
| var __hasOwnProp = Object.prototype.hasOwnProperty; | |
| var __export = (target, all) => { | |
| for (var name in all) | |
| __defProp(target, name, { get: all[name], enumerable: true }); | |
| }; | |
| var __copyProps = (to, from, except, desc) => { | |
| if (from && typeof from === "object" || typeof from === "function") { | |
| for (let key of __getOwnPropNames(from)) | |
| if (!__hasOwnProp.call(to, key) && key !== except) | |
| __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | |
| } | |
| return to; | |
| }; | |
| var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | |
| var dialect_exports = {}; | |
| __export(dialect_exports, { | |
| GelDialect: () => GelDialect | |
| }); | |
| module.exports = __toCommonJS(dialect_exports); | |
| var import_alias = require("../alias.cjs"); | |
| var import_casing = require("../casing.cjs"); | |
| var import_column = require("../column.cjs"); | |
| var import_entity = require("../entity.cjs"); | |
| var import_errors = require("../errors.cjs"); | |
| var import_columns = require("./columns/index.cjs"); | |
| var import_table = require("./table.cjs"); | |
| var import_relations = require("../relations.cjs"); | |
| var import_sql = require("../sql/index.cjs"); | |
| var import_sql2 = require("../sql/sql.cjs"); | |
| var import_subquery = require("../subquery.cjs"); | |
| var import_table2 = require("../table.cjs"); | |
| var import_utils = require("../utils.cjs"); | |
| var import_view_common = require("../view-common.cjs"); | |
| var import_timestamp = require("./columns/timestamp.cjs"); | |
| var import_view_base = require("./view-base.cjs"); | |
| class GelDialect { | |
| static [import_entity.entityKind] = "GelDialect"; | |
| /** @internal */ | |
| casing; | |
| constructor(config) { | |
| this.casing = new import_casing.CasingCache(config?.casing); | |
| } | |
| // TODO can not migrate gel with drizzle | |
| // async migrate(migrations: MigrationMeta[], session: GelSession, config: string | MigrationConfig): Promise<void> { | |
| // const migrationsTable = typeof config === 'string' | |
| // ? '__drizzle_migrations' | |
| // : config.migrationsTable ?? '__drizzle_migrations'; | |
| // const migrationsSchema = typeof config === 'string' ? 'drizzle' : config.migrationsSchema ?? 'drizzle'; | |
| // const migrationTableCreate = sql` | |
| // CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)} ( | |
| // id SERIAL PRIMARY KEY, | |
| // hash text NOT NULL, | |
| // created_at bigint | |
| // ) | |
| // `; | |
| // await session.execute(sql`CREATE SCHEMA IF NOT EXISTS ${sql.identifier(migrationsSchema)}`); | |
| // await session.execute(migrationTableCreate); | |
| // const dbMigrations = await session.all<{ id: number; hash: string; created_at: string }>( | |
| // sql`select id, hash, created_at from ${sql.identifier(migrationsSchema)}.${ | |
| // sql.identifier(migrationsTable) | |
| // } order by created_at desc limit 1`, | |
| // ); | |
| // const lastDbMigration = dbMigrations[0]; | |
| // await session.transaction(async (tx) => { | |
| // for await (const migration of migrations) { | |
| // if ( | |
| // !lastDbMigration | |
| // || Number(lastDbMigration.created_at) < migration.folderMillis | |
| // ) { | |
| // for (const stmt of migration.sql) { | |
| // await tx.execute(sql.raw(stmt)); | |
| // } | |
| // await tx.execute( | |
| // sql`insert into ${sql.identifier(migrationsSchema)}.${ | |
| // sql.identifier(migrationsTable) | |
| // } ("hash", "created_at") values(${migration.hash}, ${migration.folderMillis})`, | |
| // ); | |
| // } | |
| // } | |
| // }); | |
| // } | |
| escapeName(name) { | |
| return `"${name}"`; | |
| } | |
| escapeParam(num) { | |
| return `$${num + 1}`; | |
| } | |
| escapeString(str) { | |
| return `'${str.replace(/'/g, "''")}'`; | |
| } | |
| buildWithCTE(queries) { | |
| if (!queries?.length) return void 0; | |
| const withSqlChunks = [import_sql2.sql`with `]; | |
| for (const [i, w] of queries.entries()) { | |
| withSqlChunks.push(import_sql2.sql`${import_sql2.sql.identifier(w._.alias)} as (${w._.sql})`); | |
| if (i < queries.length - 1) { | |
| withSqlChunks.push(import_sql2.sql`, `); | |
| } | |
| } | |
| withSqlChunks.push(import_sql2.sql` `); | |
| return import_sql2.sql.join(withSqlChunks); | |
| } | |
| buildDeleteQuery({ table, where, returning, withList }) { | |
| const withSql = this.buildWithCTE(withList); | |
| const returningSql = returning ? import_sql2.sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0; | |
| const whereSql = where ? import_sql2.sql` where ${where}` : void 0; | |
| return import_sql2.sql`${withSql}delete from ${table}${whereSql}${returningSql}`; | |
| } | |
| buildUpdateSet(table, set) { | |
| const tableColumns = table[import_table2.Table.Symbol.Columns]; | |
| const columnNames = Object.keys(tableColumns).filter( | |
| (colName) => set[colName] !== void 0 || tableColumns[colName]?.onUpdateFn !== void 0 | |
| ); | |
| const setSize = columnNames.length; | |
| return import_sql2.sql.join(columnNames.flatMap((colName, i) => { | |
| const col = tableColumns[colName]; | |
| const onUpdateFnResult = col.onUpdateFn?.(); | |
| const value = set[colName] ?? ((0, import_entity.is)(onUpdateFnResult, import_sql2.SQL) ? onUpdateFnResult : import_sql2.sql.param(onUpdateFnResult, col)); | |
| const res = import_sql2.sql`${import_sql2.sql.identifier(this.casing.getColumnCasing(col))} = ${value}`; | |
| if (i < setSize - 1) { | |
| return [res, import_sql2.sql.raw(", ")]; | |
| } | |
| return [res]; | |
| })); | |
| } | |
| buildUpdateQuery({ table, set, where, returning, withList, from, joins }) { | |
| const withSql = this.buildWithCTE(withList); | |
| const tableName = table[import_table.GelTable.Symbol.Name]; | |
| const tableSchema = table[import_table.GelTable.Symbol.Schema]; | |
| const origTableName = table[import_table.GelTable.Symbol.OriginalName]; | |
| const alias = tableName === origTableName ? void 0 : tableName; | |
| const tableSql = import_sql2.sql`${tableSchema ? import_sql2.sql`${import_sql2.sql.identifier(tableSchema)}.` : void 0}${import_sql2.sql.identifier(origTableName)}${alias && import_sql2.sql` ${import_sql2.sql.identifier(alias)}`}`; | |
| const setSql = this.buildUpdateSet(table, set); | |
| const fromSql = from && import_sql2.sql.join([import_sql2.sql.raw(" from "), this.buildFromTable(from)]); | |
| const joinsSql = this.buildJoins(joins); | |
| const returningSql = returning ? import_sql2.sql` returning ${this.buildSelection(returning, { isSingleTable: !from })}` : void 0; | |
| const whereSql = where ? import_sql2.sql` where ${where}` : void 0; | |
| return import_sql2.sql`${withSql}update ${tableSql} set ${setSql}${fromSql}${joinsSql}${whereSql}${returningSql}`; | |
| } | |
| /** | |
| * Builds selection SQL with provided fields/expressions | |
| * | |
| * Examples: | |
| * | |
| * `select <selection> from` | |
| * | |
| * `insert ... returning <selection>` | |
| * | |
| * If `isSingleTable` is true, then columns won't be prefixed with table name | |
| * ^ Temporarily disabled behaviour, see comments within method for a reasoning | |
| */ | |
| buildSelection(fields, { isSingleTable = false } = {}) { | |
| const columnsLen = fields.length; | |
| const chunks = fields.flatMap(({ field }, i) => { | |
| const chunk = []; | |
| if ((0, import_entity.is)(field, import_sql2.SQL.Aliased) && field.isSelectionField) { | |
| chunk.push(import_sql2.sql.identifier(field.fieldAlias)); | |
| } else if ((0, import_entity.is)(field, import_sql2.SQL.Aliased) || (0, import_entity.is)(field, import_sql2.SQL)) { | |
| const query = (0, import_entity.is)(field, import_sql2.SQL.Aliased) ? field.sql : field; | |
| chunk.push(query); | |
| if ((0, import_entity.is)(field, import_sql2.SQL.Aliased)) { | |
| chunk.push(import_sql2.sql` as ${import_sql2.sql.identifier(field.fieldAlias)}`); | |
| } | |
| } else if ((0, import_entity.is)(field, import_column.Column)) { | |
| chunk.push(field); | |
| } else if ((0, import_entity.is)(field, import_subquery.Subquery)) { | |
| const entries = Object.entries(field._.selectedFields); | |
| if (entries.length === 1) { | |
| const entry = entries[0][1]; | |
| const fieldDecoder = (0, import_entity.is)(entry, import_sql2.SQL) ? entry.decoder : (0, import_entity.is)(entry, import_column.Column) ? { mapFromDriverValue: (v) => entry.mapFromDriverValue(v) } : entry.sql.decoder; | |
| if (fieldDecoder) { | |
| field._.sql.decoder = fieldDecoder; | |
| } | |
| } | |
| chunk.push(field); | |
| } | |
| if (i < columnsLen - 1) { | |
| chunk.push(import_sql2.sql`, `); | |
| } | |
| return chunk; | |
| }); | |
| return import_sql2.sql.join(chunks); | |
| } | |
| buildJoins(joins) { | |
| if (!joins || joins.length === 0) { | |
| return void 0; | |
| } | |
| const joinsArray = []; | |
| for (const [index, joinMeta] of joins.entries()) { | |
| if (index === 0) { | |
| joinsArray.push(import_sql2.sql` `); | |
| } | |
| const table = joinMeta.table; | |
| const lateralSql = joinMeta.lateral ? import_sql2.sql` lateral` : void 0; | |
| const onSql = joinMeta.on ? import_sql2.sql` on ${joinMeta.on}` : void 0; | |
| if ((0, import_entity.is)(table, import_table.GelTable)) { | |
| const tableName = table[import_table.GelTable.Symbol.Name]; | |
| const tableSchema = table[import_table.GelTable.Symbol.Schema]; | |
| const origTableName = table[import_table.GelTable.Symbol.OriginalName]; | |
| const alias = tableName === origTableName ? void 0 : joinMeta.alias; | |
| joinsArray.push( | |
| import_sql2.sql`${import_sql2.sql.raw(joinMeta.joinType)} join${lateralSql} ${tableSchema ? import_sql2.sql`${import_sql2.sql.identifier(tableSchema)}.` : void 0}${import_sql2.sql.identifier(origTableName)}${alias && import_sql2.sql` ${import_sql2.sql.identifier(alias)}`}${onSql}` | |
| ); | |
| } else if ((0, import_entity.is)(table, import_sql.View)) { | |
| const viewName = table[import_view_common.ViewBaseConfig].name; | |
| const viewSchema = table[import_view_common.ViewBaseConfig].schema; | |
| const origViewName = table[import_view_common.ViewBaseConfig].originalName; | |
| const alias = viewName === origViewName ? void 0 : joinMeta.alias; | |
| joinsArray.push( | |
| import_sql2.sql`${import_sql2.sql.raw(joinMeta.joinType)} join${lateralSql} ${viewSchema ? import_sql2.sql`${import_sql2.sql.identifier(viewSchema)}.` : void 0}${import_sql2.sql.identifier(origViewName)}${alias && import_sql2.sql` ${import_sql2.sql.identifier(alias)}`}${onSql}` | |
| ); | |
| } else { | |
| joinsArray.push( | |
| import_sql2.sql`${import_sql2.sql.raw(joinMeta.joinType)} join${lateralSql} ${table}${onSql}` | |
| ); | |
| } | |
| if (index < joins.length - 1) { | |
| joinsArray.push(import_sql2.sql` `); | |
| } | |
| } | |
| return import_sql2.sql.join(joinsArray); | |
| } | |
| buildFromTable(table) { | |
| if ((0, import_entity.is)(table, import_table2.Table) && table[import_table2.Table.Symbol.OriginalName] !== table[import_table2.Table.Symbol.Name]) { | |
| let fullName = import_sql2.sql`${import_sql2.sql.identifier(table[import_table2.Table.Symbol.OriginalName])}`; | |
| if (table[import_table2.Table.Symbol.Schema]) { | |
| fullName = import_sql2.sql`${import_sql2.sql.identifier(table[import_table2.Table.Symbol.Schema])}.${fullName}`; | |
| } | |
| return import_sql2.sql`${fullName} ${import_sql2.sql.identifier(table[import_table2.Table.Symbol.Name])}`; | |
| } | |
| return table; | |
| } | |
| buildSelectQuery({ | |
| withList, | |
| fields, | |
| fieldsFlat, | |
| where, | |
| having, | |
| table, | |
| joins, | |
| orderBy, | |
| groupBy, | |
| limit, | |
| offset, | |
| lockingClause, | |
| distinct, | |
| setOperators | |
| }) { | |
| const fieldsList = fieldsFlat ?? (0, import_utils.orderSelectedFields)(fields); | |
| for (const f of fieldsList) { | |
| if ((0, import_entity.is)(f.field, import_column.Column) && (0, import_table2.getTableName)(f.field.table) !== ((0, import_entity.is)(table, import_subquery.Subquery) ? table._.alias : (0, import_entity.is)(table, import_view_base.GelViewBase) ? table[import_view_common.ViewBaseConfig].name : (0, import_entity.is)(table, import_sql2.SQL) ? void 0 : (0, import_table2.getTableName)(table)) && !((table2) => joins?.some( | |
| ({ alias }) => alias === (table2[import_table2.Table.Symbol.IsAlias] ? (0, import_table2.getTableName)(table2) : table2[import_table2.Table.Symbol.BaseName]) | |
| ))(f.field.table)) { | |
| const tableName = (0, import_table2.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 || joins.length === 0; | |
| const withSql = this.buildWithCTE(withList); | |
| let distinctSql; | |
| if (distinct) { | |
| distinctSql = distinct === true ? import_sql2.sql` distinct` : import_sql2.sql` distinct on (${import_sql2.sql.join(distinct.on, import_sql2.sql`, `)})`; | |
| } | |
| const selection = this.buildSelection(fieldsList, { isSingleTable }); | |
| const tableSql = this.buildFromTable(table); | |
| const joinsSql = this.buildJoins(joins); | |
| const whereSql = where ? import_sql2.sql` where ${where}` : void 0; | |
| const havingSql = having ? import_sql2.sql` having ${having}` : void 0; | |
| let orderBySql; | |
| if (orderBy && orderBy.length > 0) { | |
| orderBySql = import_sql2.sql` order by ${import_sql2.sql.join(orderBy, import_sql2.sql`, `)}`; | |
| } | |
| let groupBySql; | |
| if (groupBy && groupBy.length > 0) { | |
| groupBySql = import_sql2.sql` group by ${import_sql2.sql.join(groupBy, import_sql2.sql`, `)}`; | |
| } | |
| const limitSql = typeof limit === "object" || typeof limit === "number" && limit >= 0 ? import_sql2.sql` limit ${limit}` : void 0; | |
| const offsetSql = offset ? import_sql2.sql` offset ${offset}` : void 0; | |
| const lockingClauseSql = import_sql2.sql.empty(); | |
| if (lockingClause) { | |
| const clauseSql = import_sql2.sql` for ${import_sql2.sql.raw(lockingClause.strength)}`; | |
| if (lockingClause.config.of) { | |
| clauseSql.append( | |
| import_sql2.sql` of ${import_sql2.sql.join( | |
| Array.isArray(lockingClause.config.of) ? lockingClause.config.of : [lockingClause.config.of], | |
| import_sql2.sql`, ` | |
| )}` | |
| ); | |
| } | |
| if (lockingClause.config.noWait) { | |
| clauseSql.append(import_sql2.sql` nowait`); | |
| } else if (lockingClause.config.skipLocked) { | |
| clauseSql.append(import_sql2.sql` skip locked`); | |
| } | |
| lockingClauseSql.append(clauseSql); | |
| } | |
| const finalQuery = import_sql2.sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}${lockingClauseSql}`; | |
| if (setOperators.length > 0) { | |
| return this.buildSetOperations(finalQuery, setOperators); | |
| } | |
| return finalQuery; | |
| } | |
| buildSetOperations(leftSelect, setOperators) { | |
| const [setOperator, ...rest] = setOperators; | |
| if (!setOperator) { | |
| throw new Error("Cannot pass undefined values to any set operator"); | |
| } | |
| if (rest.length === 0) { | |
| return this.buildSetOperationQuery({ leftSelect, setOperator }); | |
| } | |
| return this.buildSetOperations( | |
| this.buildSetOperationQuery({ leftSelect, setOperator }), | |
| rest | |
| ); | |
| } | |
| buildSetOperationQuery({ | |
| leftSelect, | |
| setOperator: { type, isAll, rightSelect, limit, orderBy, offset } | |
| }) { | |
| const leftChunk = import_sql2.sql`(${leftSelect.getSQL()}) `; | |
| const rightChunk = import_sql2.sql`(${rightSelect.getSQL()})`; | |
| let orderBySql; | |
| if (orderBy && orderBy.length > 0) { | |
| const orderByValues = []; | |
| for (const singleOrderBy of orderBy) { | |
| if ((0, import_entity.is)(singleOrderBy, import_columns.GelColumn)) { | |
| orderByValues.push(import_sql2.sql.identifier(singleOrderBy.name)); | |
| } else if ((0, import_entity.is)(singleOrderBy, import_sql2.SQL)) { | |
| for (let i = 0; i < singleOrderBy.queryChunks.length; i++) { | |
| const chunk = singleOrderBy.queryChunks[i]; | |
| if ((0, import_entity.is)(chunk, import_columns.GelColumn)) { | |
| singleOrderBy.queryChunks[i] = import_sql2.sql.identifier(chunk.name); | |
| } | |
| } | |
| orderByValues.push(import_sql2.sql`${singleOrderBy}`); | |
| } else { | |
| orderByValues.push(import_sql2.sql`${singleOrderBy}`); | |
| } | |
| } | |
| orderBySql = import_sql2.sql` order by ${import_sql2.sql.join(orderByValues, import_sql2.sql`, `)} `; | |
| } | |
| const limitSql = typeof limit === "object" || typeof limit === "number" && limit >= 0 ? import_sql2.sql` limit ${limit}` : void 0; | |
| const operatorChunk = import_sql2.sql.raw(`${type} ${isAll ? "all " : ""}`); | |
| const offsetSql = offset ? import_sql2.sql` offset ${offset}` : void 0; | |
| return import_sql2.sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`; | |
| } | |
| buildInsertQuery({ table, values: valuesOrSelect, onConflict, returning, withList, select, overridingSystemValue_ }) { | |
| const valuesSqlList = []; | |
| const columns = table[import_table2.Table.Symbol.Columns]; | |
| const colEntries = Object.entries(columns).filter(([_, col]) => !col.shouldDisableInsert()); | |
| const insertOrder = colEntries.map( | |
| ([, column]) => import_sql2.sql.identifier(this.casing.getColumnCasing(column)) | |
| ); | |
| if (select) { | |
| const select2 = valuesOrSelect; | |
| if ((0, import_entity.is)(select2, import_sql2.SQL)) { | |
| valuesSqlList.push(select2); | |
| } else { | |
| valuesSqlList.push(select2.getSQL()); | |
| } | |
| } else { | |
| const values = valuesOrSelect; | |
| valuesSqlList.push(import_sql2.sql.raw("values ")); | |
| for (const [valueIndex, value] of values.entries()) { | |
| const valueList = []; | |
| for (const [fieldName, col] of colEntries) { | |
| const colValue = value[fieldName]; | |
| if (colValue === void 0 || (0, import_entity.is)(colValue, import_sql2.Param) && colValue.value === void 0) { | |
| if (col.defaultFn !== void 0) { | |
| const defaultFnResult = col.defaultFn(); | |
| const defaultValue = (0, import_entity.is)(defaultFnResult, import_sql2.SQL) ? defaultFnResult : import_sql2.sql.param(defaultFnResult, col); | |
| valueList.push(defaultValue); | |
| } else if (!col.default && col.onUpdateFn !== void 0) { | |
| const onUpdateFnResult = col.onUpdateFn(); | |
| const newValue = (0, import_entity.is)(onUpdateFnResult, import_sql2.SQL) ? onUpdateFnResult : import_sql2.sql.param(onUpdateFnResult, col); | |
| valueList.push(newValue); | |
| } else { | |
| valueList.push(import_sql2.sql`default`); | |
| } | |
| } else { | |
| valueList.push(colValue); | |
| } | |
| } | |
| valuesSqlList.push(valueList); | |
| if (valueIndex < values.length - 1) { | |
| valuesSqlList.push(import_sql2.sql`, `); | |
| } | |
| } | |
| } | |
| const withSql = this.buildWithCTE(withList); | |
| const valuesSql = import_sql2.sql.join(valuesSqlList); | |
| const returningSql = returning ? import_sql2.sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0; | |
| const onConflictSql = onConflict ? import_sql2.sql` on conflict ${onConflict}` : void 0; | |
| const overridingSql = overridingSystemValue_ === true ? import_sql2.sql`overriding system value ` : void 0; | |
| return import_sql2.sql`${withSql}insert into ${table} ${insertOrder} ${overridingSql}${valuesSql}${onConflictSql}${returningSql}`; | |
| } | |
| buildRefreshMaterializedViewQuery({ view, concurrently, withNoData }) { | |
| const concurrentlySql = concurrently ? import_sql2.sql` concurrently` : void 0; | |
| const withNoDataSql = withNoData ? import_sql2.sql` with no data` : void 0; | |
| return import_sql2.sql`refresh materialized view${concurrentlySql} ${view}${withNoDataSql}`; | |
| } | |
| prepareTyping(encoder) { | |
| if ((0, import_entity.is)(encoder, import_columns.GelJson)) { | |
| return "json"; | |
| } else if ((0, import_entity.is)(encoder, import_columns.GelDecimal)) { | |
| return "decimal"; | |
| } else if ((0, import_entity.is)(encoder, import_timestamp.GelTimestamp)) { | |
| return "timestamp"; | |
| } else if ((0, import_entity.is)(encoder, import_columns.GelUUID)) { | |
| return "uuid"; | |
| } else { | |
| return "none"; | |
| } | |
| } | |
| sqlToQuery(sql2, invokeSource) { | |
| return sql2.toQuery({ | |
| casing: this.casing, | |
| escapeName: this.escapeName, | |
| escapeParam: this.escapeParam, | |
| escapeString: this.escapeString, | |
| prepareTyping: this.prepareTyping, | |
| invokeSource | |
| }); | |
| } | |
| // buildRelationalQueryWithPK({ | |
| // fullSchema, | |
| // schema, | |
| // tableNamesMap, | |
| // table, | |
| // tableConfig, | |
| // queryConfig: config, | |
| // tableAlias, | |
| // isRoot = false, | |
| // joinOn, | |
| // }: { | |
| // fullSchema: Record<string, unknown>; | |
| // schema: TablesRelationalConfig; | |
| // tableNamesMap: Record<string, string>; | |
| // table: GelTable; | |
| // tableConfig: TableRelationalConfig; | |
| // queryConfig: true | DBQueryConfig<'many', true>; | |
| // tableAlias: string; | |
| // isRoot?: boolean; | |
| // joinOn?: SQL; | |
| // }): BuildRelationalQueryResult<GelTable, GelColumn> { | |
| // // For { "<relation>": true }, return a table with selection of all columns | |
| // if (config === true) { | |
| // const selectionEntries = Object.entries(tableConfig.columns); | |
| // const selection: BuildRelationalQueryResult<GelTable, GelColumn>['selection'] = selectionEntries.map(( | |
| // [key, value], | |
| // ) => ({ | |
| // dbKey: value.name, | |
| // tsKey: key, | |
| // field: value as GelColumn, | |
| // relationTableTsKey: undefined, | |
| // isJson: false, | |
| // selection: [], | |
| // })); | |
| // return { | |
| // tableTsKey: tableConfig.tsName, | |
| // sql: table, | |
| // selection, | |
| // }; | |
| // } | |
| // // let selection: BuildRelationalQueryResult<GelTable, GelColumn>['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: GelColumn | 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 GelColumn; | |
| // // fieldsSelection.push({ tsKey: field, value: column }); | |
| // // } | |
| // let initiallySelectedRelations: { | |
| // tsKey: string; | |
| // queryConfig: true | DBQueryConfig<'many', false>; | |
| // relation: Relation; | |
| // }[] = []; | |
| // // let selectedRelations: BuildRelationalQueryResult<GelTable, GelColumn>['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 GelColumn; | |
| // } | |
| // 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 GelColumn, | |
| // 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 GelTable, | |
| // 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 GelTable, | |
| // 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: GelSelectConfig['distinct']; | |
| // let tableFrom: GelTable | 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 GelColumn, 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 GelTable, | |
| // 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 GelTable, 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, GelTable) | |
| // ? 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<GelTable, GelColumn>['selection']; | |
| // function prepareSelectedColumns() { | |
| // return selectedColumns.map((key) => ({ | |
| // dbKey: tableConfig.columns[key]!.name, | |
| // tsKey: key, | |
| // field: tableConfig.columns[key] as GelColumn, | |
| // 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, GelTable) ? 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, GelTable) ? 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); | |
| selection = selectionEntries.map(([key, value]) => ({ | |
| dbKey: value.name, | |
| tsKey: key, | |
| field: (0, import_alias.aliasedTableColumn)(value, tableAlias), | |
| relationTableTsKey: void 0, | |
| isJson: false, | |
| selection: [] | |
| })); | |
| } else { | |
| const aliasedColumns = Object.fromEntries( | |
| Object.entries(tableConfig.columns).map(([key, value]) => [key, (0, import_alias.aliasedTableColumn)(value, tableAlias)]) | |
| ); | |
| if (config.where) { | |
| const whereSql = typeof config.where === "function" ? config.where(aliasedColumns, (0, import_relations.getOperators)()) : config.where; | |
| where = whereSql && (0, import_alias.mapColumnsInSQLToAlias)(whereSql, tableAlias); | |
| } | |
| const fieldsSelection = []; | |
| let selectedColumns = []; | |
| if (config.columns) { | |
| let isIncludeMode = false; | |
| for (const [field, value] of Object.entries(config.columns)) { | |
| if (value === void 0) { | |
| 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 { | |
| selectedColumns = Object.keys(tableConfig.columns); | |
| } | |
| for (const field of selectedColumns) { | |
| const column = tableConfig.columns[field]; | |
| fieldsSelection.push({ tsKey: field, value: column }); | |
| } | |
| let selectedRelations = []; | |
| if (config.with) { | |
| selectedRelations = Object.entries(config.with).filter((entry) => !!entry[1]).map(([tsKey, queryConfig]) => ({ tsKey, queryConfig, relation: tableConfig.relations[tsKey] })); | |
| } | |
| let extras; | |
| if (config.extras) { | |
| extras = typeof config.extras === "function" ? config.extras(aliasedColumns, { sql: import_sql2.sql }) : config.extras; | |
| for (const [tsKey, value] of Object.entries(extras)) { | |
| fieldsSelection.push({ | |
| tsKey, | |
| value: (0, import_alias.mapColumnsInAliasedSQLToAlias)(value, tableAlias) | |
| }); | |
| } | |
| } | |
| for (const { tsKey, value } of fieldsSelection) { | |
| selection.push({ | |
| dbKey: (0, import_entity.is)(value, import_sql2.SQL.Aliased) ? value.fieldAlias : tableConfig.columns[tsKey].name, | |
| tsKey, | |
| field: (0, import_entity.is)(value, import_column.Column) ? (0, import_alias.aliasedTableColumn)(value, tableAlias) : value, | |
| relationTableTsKey: void 0, | |
| isJson: false, | |
| selection: [] | |
| }); | |
| } | |
| let orderByOrig = typeof config.orderBy === "function" ? config.orderBy(aliasedColumns, (0, import_relations.getOrderByOperators)()) : config.orderBy ?? []; | |
| if (!Array.isArray(orderByOrig)) { | |
| orderByOrig = [orderByOrig]; | |
| } | |
| orderBy = orderByOrig.map((orderByValue) => { | |
| if ((0, import_entity.is)(orderByValue, import_column.Column)) { | |
| return (0, import_alias.aliasedTableColumn)(orderByValue, tableAlias); | |
| } | |
| return (0, import_alias.mapColumnsInSQLToAlias)(orderByValue, tableAlias); | |
| }); | |
| limit = config.limit; | |
| offset = config.offset; | |
| for (const { | |
| tsKey: selectedRelationTsKey, | |
| queryConfig: selectedRelationConfigValue, | |
| relation | |
| } of selectedRelations) { | |
| const normalizedRelation = (0, import_relations.normalizeRelation)(schema, tableNamesMap, relation); | |
| const relationTableName = (0, import_table2.getTableUniqueName)(relation.referencedTable); | |
| const relationTableTsName = tableNamesMap[relationTableName]; | |
| const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`; | |
| const joinOn2 = (0, import_sql.and)( | |
| ...normalizedRelation.fields.map( | |
| (field2, i) => (0, import_sql.eq)( | |
| (0, import_alias.aliasedTableColumn)(normalizedRelation.references[i], relationTableAlias), | |
| (0, import_alias.aliasedTableColumn)(field2, tableAlias) | |
| ) | |
| ) | |
| ); | |
| const builtRelation = this.buildRelationalQueryWithoutPK({ | |
| fullSchema, | |
| schema, | |
| tableNamesMap, | |
| table: fullSchema[relationTableTsName], | |
| tableConfig: schema[relationTableTsName], | |
| queryConfig: (0, import_entity.is)(relation, import_relations.One) ? selectedRelationConfigValue === true ? { limit: 1 } : { ...selectedRelationConfigValue, limit: 1 } : selectedRelationConfigValue, | |
| tableAlias: relationTableAlias, | |
| joinOn: joinOn2, | |
| nestedQueryRelation: relation | |
| }); | |
| const field = import_sql2.sql`${import_sql2.sql.identifier(relationTableAlias)}.${import_sql2.sql.identifier("data")}`.as(selectedRelationTsKey); | |
| joins.push({ | |
| on: import_sql2.sql`true`, | |
| table: new import_subquery.Subquery(builtRelation.sql, {}, relationTableAlias), | |
| alias: relationTableAlias, | |
| joinType: "left", | |
| lateral: true | |
| }); | |
| selection.push({ | |
| dbKey: selectedRelationTsKey, | |
| tsKey: selectedRelationTsKey, | |
| field, | |
| relationTableTsKey: relationTableTsName, | |
| isJson: true, | |
| selection: builtRelation.selection | |
| }); | |
| } | |
| } | |
| if (selection.length === 0) { | |
| throw new import_errors.DrizzleError({ message: `No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")` }); | |
| } | |
| let result; | |
| where = (0, import_sql.and)(joinOn, where); | |
| if (nestedQueryRelation) { | |
| let field = import_sql2.sql`json_build_array(${import_sql2.sql.join( | |
| selection.map( | |
| ({ field: field2, tsKey, isJson }) => isJson ? import_sql2.sql`${import_sql2.sql.identifier(`${tableAlias}_${tsKey}`)}.${import_sql2.sql.identifier("data")}` : (0, import_entity.is)(field2, import_sql2.SQL.Aliased) ? field2.sql : field2 | |
| ), | |
| import_sql2.sql`, ` | |
| )})`; | |
| if ((0, import_entity.is)(nestedQueryRelation, import_relations.Many)) { | |
| field = import_sql2.sql`coalesce(json_agg(${field}${orderBy.length > 0 ? import_sql2.sql` order by ${import_sql2.sql.join(orderBy, import_sql2.sql`, `)}` : void 0}), '[]'::json)`; | |
| } | |
| const nestedSelection = [{ | |
| dbKey: "data", | |
| tsKey: "data", | |
| field: field.as("data"), | |
| isJson: true, | |
| relationTableTsKey: tableConfig.tsName, | |
| selection | |
| }]; | |
| const needsSubquery = limit !== void 0 || offset !== void 0 || orderBy.length > 0; | |
| if (needsSubquery) { | |
| result = this.buildSelectQuery({ | |
| table: (0, import_alias.aliasedTable)(table, tableAlias), | |
| fields: {}, | |
| fieldsFlat: [{ | |
| path: [], | |
| field: import_sql2.sql.raw("*") | |
| }], | |
| where, | |
| limit, | |
| offset, | |
| orderBy, | |
| setOperators: [] | |
| }); | |
| where = void 0; | |
| limit = void 0; | |
| offset = void 0; | |
| orderBy = []; | |
| } else { | |
| result = (0, import_alias.aliasedTable)(table, tableAlias); | |
| } | |
| result = this.buildSelectQuery({ | |
| table: (0, import_entity.is)(result, import_table.GelTable) ? result : new import_subquery.Subquery(result, {}, tableAlias), | |
| fields: {}, | |
| fieldsFlat: nestedSelection.map(({ field: field2 }) => ({ | |
| path: [], | |
| field: (0, import_entity.is)(field2, import_column.Column) ? (0, import_alias.aliasedTableColumn)(field2, tableAlias) : field2 | |
| })), | |
| joins, | |
| where, | |
| limit, | |
| offset, | |
| orderBy, | |
| setOperators: [] | |
| }); | |
| } else { | |
| result = this.buildSelectQuery({ | |
| table: (0, import_alias.aliasedTable)(table, tableAlias), | |
| fields: {}, | |
| fieldsFlat: selection.map(({ field }) => ({ | |
| path: [], | |
| field: (0, import_entity.is)(field, import_column.Column) ? (0, import_alias.aliasedTableColumn)(field, tableAlias) : field | |
| })), | |
| joins, | |
| where, | |
| limit, | |
| offset, | |
| orderBy, | |
| setOperators: [] | |
| }); | |
| } | |
| return { | |
| tableTsKey: tableConfig.tsName, | |
| sql: result, | |
| selection | |
| }; | |
| } | |
| } | |
| // Annotate the CommonJS export names for ESM import in node: | |
| 0 && (module.exports = { | |
| GelDialect | |
| }); | |
| //# sourceMappingURL=dialect.cjs.map |