typhex 0.1.0-alpha.0

package/dist/dbs/query-compiler.js

@@ -0,0 +1,775 @@
+/**
+ * Shared SQL query compiler.
+ *
+ * The public surface compiles complete query/migration operations. Dialect
+ * subclasses override protected pieces where SQL differs.
+ */
+import { getColumnDef, resolveParamSentinels, SQL_DEFAULT } from "./types.js";
+import { QueryPlanBuilder } from "../orm/helpers/query-plan/query-plan.js";
+function wrapUnionAllBranchSql(sql, plan) {
+    const needsParens = plan.orderBy.length > 0 || plan.limitNum != null || plan.offsetNum != null;
+    return needsParens ? `(${sql})` : sql;
+}
+export class BaseQueryCompiler {
+    static JOIN_SQL_KEYWORDS = {
+        inner: "INNER JOIN",
+        left: "LEFT JOIN",
+        right: "RIGHT JOIN",
+        cross: "CROSS JOIN",
+        full: "FULL OUTER JOIN",
+    };
+    renderColumn(col) {
+        if (col.column.length === 0)
+            return this.escapeIdentifier(col.alias);
+        return `${this.escapeIdentifier(col.alias)}.${col.column.map((c) => this.escapeIdentifier(c)).join(".")}`;
+    }
+    compileUnarySql(op, operandSql) {
+        if (op === "~")
+            return `(~${operandSql})`;
+        return `(NOT ${operandSql})`;
+    }
+    compileXorSql(left, right) {
+        if (this.dialect === "postgres")
+            return `(${left} # ${right})`;
+        return `((${left} & ~${right}) | (~${left} & ${right}))`;
+    }
+    compileBinarySql(op, left, right) {
+        if (op === "&&")
+            return `(${left} AND ${right})`;
+        if (op === "||")
+            return `(${left} OR ${right})`;
+        if (op === "^")
+            return this.compileXorSql(left, right);
+        const sqlOp = op === "==" || op === "===" ? "=" : op === "!=" || op === "!==" ? "<>" : op;
+        return `(${left} ${sqlOp} ${right})`;
+    }
+    compileInlineExpr(arg, params) {
+        if (arg === null)
+            return "*";
+        if (arg.kind === "column")
+            return this.renderColumn(arg);
+        if (arg.kind === "const")
+            return this.inlineConstLiteral(arg.value);
+        if (arg.kind === "binary")
+            return this.compileInlineBinary(arg, params);
+        if (arg.kind === "case")
+            return this.compileInlineCase(arg, params);
+        if (arg.kind === "unary") {
+            return this.compileUnarySql(arg.op, this.compileInlineExpr(arg.operand, params));
+        }
+        return this.compileNode(arg, params);
+    }
+    inlineConstLiteral(value) {
+        if (value === null)
+            return "NULL";
+        if (typeof value === "number")
+            return String(value);
+        if (typeof value === "boolean")
+            return value ? "TRUE" : "FALSE";
+        if (typeof value === "string")
+            return `'${value.replaceAll("'", "''")}'`;
+        throw new Error(`[typhex] Cannot inline SQL literal of type ${typeof value}`);
+    }
+    compileInlineBinary(node, params) {
+        if (this.isNullEquality(node)) {
+            const left = this.compileInlineExpr(node.left, params);
+            const negated = node.op === "!==" || node.op === "!=";
+            return `(${left} ${negated ? "IS NOT NULL" : "IS NULL"})`;
+        }
+        const left = this.compileInlineExpr(node.left, params);
+        const right = this.compileInlineExpr(node.right, params);
+        return this.compileBinarySql(node.op, left, right);
+    }
+    compileInlineCase(node, params) {
+        const whens = node.branches
+            .map((b) => `WHEN ${this.compileInlineExpr(b.when, params)} THEN ${this.compileInlineExpr(b.then, params)}`)
+            .join(" ");
+        const elseSql = node.else ? ` ELSE ${this.compileInlineExpr(node.else, params)}` : "";
+        return `(CASE ${whens}${elseSql} END)`;
+    }
+    isNullEquality(node) {
+        const isEq = node.op === "===" || node.op === "==" || node.op === "!==" || node.op === "!=";
+        return isEq && node.right.kind === "const" && node.right.value === null;
+    }
+    compileStandardAggregate(funcName, agg, params) {
+        const argSql = this.compileInlineExpr(agg.arg, params);
+        const distinctPrefix = agg.distinct ? "DISTINCT " : "";
+        const expr = `${funcName}(${distinctPrefix}${argSql})`;
+        return agg.alias ? `${expr} AS ${this.escapeIdentifier(agg.alias)}` : expr;
+    }
+    compileConcatAggregate(funcName, agg, defaultSep, params) {
+        const argSql = this.compileInlineExpr(agg.arg, params);
+        const distinctPrefix = agg.distinct ? "DISTINCT " : "";
+        const sepLiteral = agg.separator !== undefined ? `'${agg.separator.replaceAll("'", "''")}'` : defaultSep;
+        const inner = sepLiteral !== undefined
+            ? `${distinctPrefix}${argSql}, ${sepLiteral}`
+            : `${distinctPrefix}${argSql}`;
+        const expr = `${funcName}(${inner})`;
+        return agg.alias ? `${expr} AS ${this.escapeIdentifier(agg.alias)}` : expr;
+    }
+    compileGroupBy(items) {
+        return items
+            .map((entry) => {
+            if (entry.kind === "index")
+                return String(entry.index);
+            return this.renderColumn(entry);
+        })
+            .join(", ");
+    }
+    compilePlan(plan, options = {}) {
+        const operation = plan.operation;
+        switch (operation.kind) {
+            case "select":
+                return this.compileSelectPlan(plan, options);
+            case "insert":
+                return this.compileInsert(plan.tableName, operation.columns, operation.values, operation.pk, operation.onConflict);
+            case "insertMany":
+                return this.compileInsertMany(plan.tableName, operation.columns, operation.rows, operation.pk, operation.onConflict);
+            case "update":
+                return this.compileUpdatePlan(plan);
+            case "delete":
+                return this.compileDeletePlan(plan);
+        }
+    }
+    compileResultSize(plan) {
+        const inner = this.compileSelectPlan({ ...plan, orderBy: [], limitNum: null, offsetNum: null }, { wrap: true });
+        return {
+            sql: `SELECT COUNT(*) AS c FROM ${inner.sql} AS ${this.escapeIdentifier("_count")}`,
+            params: inner.params,
+        };
+    }
+    compileCteBodies(ctes, allowedCteNames = []) {
+        if (!ctes?.length)
+            return [];
+        const bodies = [];
+        for (const clause of ctes) {
+            const innerState = clause.inner;
+            const innerPlan = QueryPlanBuilder.build(innerState, { kind: "select" });
+            const priorNames = [...allowedCteNames, ...bodies.map((c) => c.name)];
+            const allowedForInner = clause.kind === "recursive" ? [...priorNames, clause.name] : priorNames;
+            const body = this.compilePlan(innerPlan, {
+                paramStartIndex: 1,
+                allowedCteNames: allowedForInner,
+            });
+            bodies.push({
+                name: clause.name,
+                bodySql: body.sql,
+                bodyParams: body.params,
+                recursive: clause.kind === "recursive",
+            });
+        }
+        return bodies;
+    }
+    resolvePlanFromClause(plan, allowedCteNames, paramStartIndex, compileOptions = {}) {
+        const source = plan.fromSource ?? { kind: "table" };
+        const alias = this.escapeIdentifier(plan.tableAlias);
+        switch (source.kind) {
+            case "table":
+                return {
+                    fromClause: `${this.escapeIdentifier(plan.tableName)} AS ${alias}`,
+                    fromParams: [],
+                };
+            case "cte":
+                return {
+                    fromClause: `${this.escapeIdentifier(source.name)} AS ${alias}`,
+                    fromParams: [],
+                };
+            case "subquery": {
+                const innerPlan = QueryPlanBuilder.build(source.state, { kind: "select" });
+                const compiled = this.compilePlan(innerPlan, {
+                    wrap: true,
+                    paramStartIndex,
+                    allowedCteNames: compileOptions.allowedCteNames,
+                });
+                return {
+                    fromClause: `${compiled.sql} AS ${alias}`,
+                    fromParams: compiled.params,
+                };
+            }
+        }
+    }
+    prepareReadPlan(plan, options) {
+        const compiledCteBodies = options.skipCteRender
+            ? []
+            : this.compileCteBodies(plan.ctes, options.allowedCteNames);
+        const allowedCteNames = [
+            ...(options.allowedCteNames ?? []),
+            ...compiledCteBodies.map((c) => c.name),
+        ];
+        const fromResolved = this.resolvePlanFromClause(plan, allowedCteNames, options.paramStartIndex ?? 1, options);
+        const { expand, paramStartIndex } = this.createExpander({
+            ...options,
+            paramStartIndex: (options.paramStartIndex ?? 1) + fromResolved.fromParams.length,
+        });
+        const joinsExpanded = this.compileJoinsSql(plan, expand);
+        return {
+            compiledCteBodies,
+            fromResolved,
+            joinsSql: joinsExpanded.sql,
+            joinParams: joinsExpanded.params,
+            expand,
+            paramStartIndex,
+        };
+    }
+    compileJoinsSql(plan, expand) {
+        const parts = [];
+        const params = [];
+        for (const join of plan.joins) {
+            if (join.on) {
+                const onExpanded = expand(this.compileWhereExpr(join.on), plan.whereParams);
+                params.push(...onExpanded.params);
+                parts.push(this.buildJoinClause(join, plan.tableAlias, onExpanded.sql));
+            }
+            else {
+                parts.push(this.buildJoinClause(join, plan.tableAlias));
+            }
+        }
+        return { sql: parts.join(""), params };
+    }
+    attachCteBodies(core, bodies, paramStartIndex) {
+        if (!bodies.length)
+            return core;
+        return this.compileWithClause(core.sql, core.params, bodies, paramStartIndex);
+    }
+    compileMigrationUp(action) {
+        switch (action.kind) {
+            case "add_table":
+                return this.compileCreateTable(action.table, action.schema, false);
+            case "drop_table":
+                return `DROP TABLE IF EXISTS ${this.escapeIdentifier(action.table)};`;
+            case "add_column":
+                return `ALTER TABLE ${this.escapeIdentifier(action.table)} ADD COLUMN ${this.escapeIdentifier(action.column)} ${this.toColumnDef(action.definition)};`;
+            case "drop_column":
+                return `ALTER TABLE ${this.escapeIdentifier(action.table)} DROP COLUMN ${this.escapeIdentifier(action.column)};`;
+            case "alter_column":
+                return this.compileAlterColumn(action, false);
+        }
+    }
+    compileMigrationDown(action) {
+        switch (action.kind) {
+            case "add_table":
+                return `DROP TABLE IF EXISTS ${this.escapeIdentifier(action.table)};`;
+            case "drop_table":
+                return this.compileRecreateDroppedTable(action.table, action.columnInfos);
+            case "add_column":
+                return `ALTER TABLE ${this.escapeIdentifier(action.table)} DROP COLUMN ${this.escapeIdentifier(action.column)};`;
+            case "drop_column":
+                return `ALTER TABLE ${this.escapeIdentifier(action.table)} ADD COLUMN ${this.escapeIdentifier(action.column)} ${this.reconstructColDef(action.columnInfo)};`;
+            case "alter_column":
+                return this.compileAlterColumn(action, true);
+        }
+    }
+    compileCreateTableIfNotExists(table, schema) {
+        return this.compileCreateTable(table, schema, true);
+    }
+    compileAppliedMigrations() {
+        const id = this.escapeIdentifier("id");
+        const name = this.escapeIdentifier("name");
+        const appliedAt = this.escapeIdentifier("applied_at");
+        const table = this.escapeIdentifier("_typhex_migrations");
+        return {
+            sql: `SELECT ${id}, ${name}, ${appliedAt} FROM ${table} ORDER BY ${id}`,
+            params: [],
+        };
+    }
+    compileRecordMigration(name) {
+        return {
+            sql: `INSERT INTO ${this.escapeIdentifier("_typhex_migrations")} (${this.escapeIdentifier("name")}) VALUES (${this.placeholder(1)})`,
+            params: [name],
+        };
+    }
+    compileDeleteMigration(name) {
+        return {
+            sql: `DELETE FROM ${this.escapeIdentifier("_typhex_migrations")} WHERE ${this.escapeIdentifier("name")} = ${this.placeholder(1)}`,
+            params: [name],
+        };
+    }
+    compileNextSequenceValues(_tableName, _pkColumn, _count) {
+        throw new Error(`${this.dialect} sequence allocation is not configured for this dialect`);
+    }
+    /** @internal */
+    compileWhereExpr(node) {
+        const params = [];
+        const sql = node ? this.compileNode(node, params) : "1=1";
+        return { sql, params };
+    }
+    /** @internal */
+    compileOrderByExpr(orders) {
+        if (orders.length === 0)
+            return { sql: "", params: [] };
+        const params = [];
+        const sql = orders
+            .map((o) => {
+            const dir = o.direction === "desc" ? "DESC" : "ASC";
+            return `${this.compileInlineExpr(o.expr, params)} ${dir}`;
+        })
+            .join(", ");
+        return { sql, params };
+    }
+    /** @internal */
+    compileSelectListExpr(items, selectAll, tableAlias, columnNames) {
+        const params = [];
+        if (selectAll && items.length === 0) {
+            return {
+                sql: columnNames
+                    .map((c) => `${this.escapeIdentifier(tableAlias)}.${this.escapeIdentifier(c)}`)
+                    .join(", "),
+                params,
+            };
+        }
+        const parts = [];
+        for (const item of items) {
+            const col = item.expr.kind === "aggregate"
+                ? this.compileAggregate(item.expr, params)
+                : this.compileInlineExpr(item.expr, params);
+            if (item.expr.kind === "aggregate") {
+                if (item.alias && !item.expr.alias) {
+                    parts.push(`${col} AS ${this.escapeIdentifier(item.alias)}`);
+                }
+                else {
+                    parts.push(col);
+                }
+            }
+            else if (item.alias) {
+                parts.push(`${col} AS ${this.escapeIdentifier(item.alias)}`);
+            }
+            else {
+                parts.push(col);
+            }
+        }
+        return { sql: parts.join(", "), params };
+    }
+    escapeIdentifier(name) {
+        return `"${name.replaceAll('"', '""')}"`;
+    }
+    placeholder(index) {
+        return this.dialect === "postgres" ? `$${index}` : "?";
+    }
+    toColumnDef(def) {
+        return getColumnDef(def, this.dialect);
+    }
+    compileSelectPlan(plan, options) {
+        const prepared = this.prepareReadPlan(plan, options);
+        const fromCtes = plan.referencedRegisteredCtes;
+        const fromSource = plan.fromSource ?? { kind: "table" };
+        let fromClause = prepared.fromResolved.fromClause;
+        if (fromSource.kind === "table" && fromCtes.length > 0) {
+            const extra = fromCtes.map((n) => this.escapeIdentifier(n)).join(", ");
+            fromClause = `${fromClause}, ${extra}`;
+        }
+        const selectListExpanded = prepared.expand(this.compileSelectListExpr(plan.selectItems, plan.selectAll, plan.tableAlias, plan.columnNames), plan.whereParams);
+        const whereExpanded = prepared.expand(this.compileWhereExpr(plan.where), plan.whereParams);
+        const havingExpanded = plan.having
+            ? prepared.expand(this.compileWhereExpr(plan.having), plan.havingParams)
+            : null;
+        const orderByExpanded = prepared.expand(this.compileOrderByExpr(plan.orderBy), plan.whereParams);
+        let result = this.compileSelect({
+            table: plan.tableName,
+            tableAlias: plan.tableAlias,
+            fromClause,
+            fromParams: prepared.fromResolved.fromParams,
+            joinParams: prepared.joinParams,
+            selectList: selectListExpanded.sql,
+            selectListParams: selectListExpanded.params,
+            whereSql: whereExpanded.sql,
+            whereParams: whereExpanded.params,
+            orderBySql: orderByExpanded.sql,
+            orderByParams: orderByExpanded.params,
+            limitNum: plan.limitNum,
+            offsetNum: plan.offsetNum,
+            joinsSql: prepared.joinsSql || undefined,
+            groupBy: plan.groupBy.length > 0 ? plan.groupBy : undefined,
+            havingSql: havingExpanded?.sql,
+            havingParams: havingExpanded?.params,
+            paramStartIndex: prepared.paramStartIndex,
+        });
+        if (plan.unionAll) {
+            const unionStart = (options.paramStartIndex ?? 1) + result.params.length;
+            const unionCompiled = this.compileSelectPlan(plan.unionAll, {
+                ...options,
+                skipCteRender: true,
+                wrap: false,
+                paramStartIndex: unionStart,
+            });
+            const left = wrapUnionAllBranchSql(result.sql, plan);
+            const right = wrapUnionAllBranchSql(unionCompiled.sql, plan.unionAll);
+            result = {
+                sql: `${left} UNION ALL ${right}`,
+                params: [...result.params, ...unionCompiled.params],
+            };
+        }
+        const wrapped = options.skipCteRender
+            ? result
+            : this.attachCteBodies(result, prepared.compiledCteBodies, options.paramStartIndex ?? 1);
+        return options.wrap ? { sql: `(${wrapped.sql})`, params: wrapped.params } : wrapped;
+    }
+    compileUpdatePlan(plan) {
+        if (plan.operation.kind !== "update") {
+            throw new Error("compileUpdatePlan expects an update operation");
+        }
+        const registered = this.registeredCteNames(plan);
+        const fromCtes = plan.referencedRegisteredCtes;
+        const referencedCtes = (plan.ctes ?? []).filter((c) => fromCtes.includes(c.name));
+        const bodies = fromCtes.length > 0 ? this.compileCteBodies(referencedCtes) : [];
+        const { expand } = this.createExpander({});
+        const whereExpanded = expand(this.compileWhereExpr(plan.where), plan.whereParams);
+        const result = this.compileUpdate(plan.tableName, plan.updateSet ?? {}, plan.columnNames, whereExpanded.sql, whereExpanded.params, {
+            returning: plan.operation.returning,
+            fromCtes,
+            tableAlias: plan.tableAlias,
+            registeredCteNames: registered,
+        });
+        if (!result.sql)
+            return result;
+        return bodies.length > 0 ? this.attachCteBodies(result, bodies, 1) : result;
+    }
+    compileDeletePlan(plan) {
+        if (plan.operation.kind !== "delete") {
+            throw new Error("compileDeletePlan expects a delete operation");
+        }
+        const fromCtes = plan.referencedRegisteredCtes;
+        const referencedCtes = (plan.ctes ?? []).filter((c) => fromCtes.includes(c.name));
+        const bodies = fromCtes.length > 0 ? this.compileCteBodies(referencedCtes) : [];
+        const { expand } = this.createExpander({});
+        const whereExpanded = expand(this.compileWhereExpr(plan.where), plan.whereParams);
+        const result = this.compileDelete(plan.tableName, whereExpanded.sql, whereExpanded.params, {
+            returning: plan.operation.returning,
+            fromCtes,
+            tableAlias: plan.tableAlias,
+        });
+        if (!result.sql)
+            return result;
+        return bodies.length > 0 ? this.attachCteBodies(result, bodies, 1) : result;
+    }
+    compileSelect(opts) {
+        const params = [
+            ...(opts.fromParams ?? []),
+            ...(opts.joinParams ?? []),
+            ...(opts.selectListParams ?? []),
+            ...opts.whereParams,
+        ];
+        const groupByClause = opts.groupBy && opts.groupBy.length > 0
+            ? ` GROUP BY ${this.compileGroupBy(opts.groupBy)}`
+            : "";
+        let havingClause = "";
+        if (opts.havingSql) {
+            havingClause = ` HAVING ${opts.havingSql}`;
+            params.push(...(opts.havingParams ?? []));
+        }
+        if (opts.orderByParams && opts.orderByParams.length > 0) {
+            params.push(...opts.orderByParams);
+        }
+        const fromParamCount = opts.fromParams?.length ?? 0;
+        let paramIdx = (opts.paramStartIndex ?? 1) + params.length - fromParamCount;
+        const nextPlaceholder = () => this.placeholder(paramIdx++);
+        const limitClause = opts.limitNum != null ? ` LIMIT ${nextPlaceholder()}` : "";
+        if (opts.limitNum != null)
+            params.push(opts.limitNum);
+        const offsetClause = opts.offsetNum != null ? ` OFFSET ${nextPlaceholder()}` : "";
+        if (opts.offsetNum != null)
+            params.push(opts.offsetNum);
+        const orderClause = opts.orderBySql ? ` ORDER BY ${opts.orderBySql}` : "";
+        const fromPart = opts.fromClause ??
+            `${this.escapeIdentifier(opts.table)} AS ${this.escapeIdentifier(opts.tableAlias)}`;
+        return {
+            sql: `SELECT ${opts.selectList} FROM ${fromPart}${opts.joinsSql ?? ""} WHERE ${opts.whereSql}${groupByClause}${havingClause}${orderClause}${limitClause}${offsetClause}`,
+            params,
+        };
+    }
+    compileInsert(table, columns, values, pk, onConflict) {
+        const hasPk = !!pk?.length;
+        if (columns.length === 0) {
+            if (onConflict) {
+                throw new Error("insert: ON CONFLICT requires explicit columns (empty INSERT not supported with onConflict)");
+            }
+            const returning = this.singleInsertReturnsRows(hasPk);
+            return {
+                sql: `INSERT INTO ${this.escapeIdentifier(table)} DEFAULT VALUES${returning ? " RETURNING *" : ""}`,
+                params: [],
+                returningRow: returning,
+            };
+        }
+        const placeholders = columns.map((_, i) => this.placeholder(i + 1)).join(", ");
+        let sql = `INSERT INTO ${this.escapeIdentifier(table)} (${columns.map((c) => this.escapeIdentifier(c)).join(", ")}) VALUES (${placeholders})`;
+        if (onConflict)
+            sql = this.appendOnConflict(sql, onConflict, columns);
+        const returning = this.singleInsertReturnsRows(hasPk);
+        if (returning)
+            sql += " RETURNING *";
+        return { sql, params: values, returningRow: returning };
+    }
+    compileInsertMany(table, columns, rows, pk, onConflict) {
+        if (rows.length === 0 || columns.length === 0) {
+            return { sql: "", params: [], returningRow: false };
+        }
+        let paramIdx = 1;
+        const params = [];
+        const rowPlaceholders = rows.map((row) => {
+            const placeholders = row.map((value) => {
+                const rendered = this.renderInsertManyValue(value, paramIdx);
+                if (rendered.params.length > 0) {
+                    params.push(...rendered.params);
+                    paramIdx += rendered.params.length;
+                }
+                return rendered.sql;
+            });
+            return `(${placeholders.join(", ")})`;
+        });
+        let sql = `INSERT INTO ${this.escapeIdentifier(table)} (${columns.map((c) => this.escapeIdentifier(c)).join(", ")}) VALUES ${rowPlaceholders.join(", ")}`;
+        if (onConflict)
+            sql = this.appendOnConflict(sql, onConflict, columns);
+        const returning = !!pk?.length;
+        if (returning)
+            sql += " RETURNING *";
+        return { sql, params, returningRow: returning };
+    }
+    compileUpdate(table, updateSet, columns, whereSql, whereParams, options) {
+        const cols = Object.keys(updateSet).filter((k) => columns.includes(k));
+        if (cols.length === 0)
+            return { sql: "", params: [] };
+        const cteNames = options?.registeredCteNames ?? new Set();
+        const fromCtes = options?.fromCtes ?? [];
+        const useFrom = fromCtes.length > 0;
+        const alias = options?.tableAlias ?? "t0";
+        const params = [];
+        const assignments = cols
+            .map((c) => {
+            const expr = updateSet[c];
+            if (expr.kind === "column") {
+                if (cteNames.has(expr.alias) || expr.alias === alias) {
+                    return `${this.escapeIdentifier(c)} = ${this.renderColumn(expr)}`;
+                }
+            }
+            if (expr.kind === "const") {
+                params.push(expr.value);
+                return `${this.escapeIdentifier(c)} = ${this.placeholder(params.length)}`;
+            }
+            throw new Error(`compileUpdate: unsupported SET expression for column "${c}"`);
+        })
+            .join(", ");
+        const fixedWhere = this.fixMutationWhereAlias(table, whereSql, alias, useFrom);
+        const where = this.renumberUpdateWhereParams(fixedWhere, params.length);
+        params.push(...whereParams);
+        let sql;
+        if (useFrom) {
+            const fromList = fromCtes.map((n) => this.escapeIdentifier(n)).join(", ");
+            const whereClause = where ? ` WHERE ${where}` : "";
+            sql = `UPDATE ${this.escapeIdentifier(table)} AS ${this.escapeIdentifier(alias)} SET ${assignments} FROM ${fromList}${whereClause}`;
+        }
+        else {
+            sql = `UPDATE ${this.escapeIdentifier(table)} SET ${assignments} WHERE ${where}`;
+        }
+        if (options?.returning)
+            sql += " RETURNING *";
+        return { sql, params, returningRow: !!options?.returning };
+    }
+    compileDelete(table, whereSql, whereParams, options) {
+        const fromCtes = options?.fromCtes ?? [];
+        const useFrom = fromCtes.length > 0;
+        const alias = options?.tableAlias ?? "t0";
+        const fixedWhere = this.fixMutationWhereAlias(table, whereSql, alias, useFrom);
+        let sql;
+        if (useFrom) {
+            const fromList = fromCtes.map((n) => this.escapeIdentifier(n)).join(", ");
+            const existsWhere = fixedWhere || "1=1";
+            sql = `DELETE FROM ${this.escapeIdentifier(table)} AS ${this.escapeIdentifier(alias)} WHERE EXISTS (SELECT 1 FROM ${fromList} WHERE ${existsWhere})`;
+        }
+        else {
+            sql = `DELETE FROM ${this.escapeIdentifier(table)} WHERE ${fixedWhere}`;
+        }
+        if (options?.returning)
+            sql += " RETURNING *";
+        return { sql, params: whereParams, returningRow: !!options?.returning };
+    }
+    compileNode(node, params) {
+        switch (node.kind) {
+            case "binary": {
+                if (this.isNullEquality(node)) {
+                    const left = this.compileNode(node.left, params);
+                    const negated = node.op === "!==" || node.op === "!=";
+                    return `(${left} ${negated ? "IS NOT NULL" : "IS NULL"})`;
+                }
+                const left = this.compileNode(node.left, params);
+                const right = this.compileNode(node.right, params);
+                return this.compileBinarySql(node.op, left, right);
+            }
+            case "unary":
+                return this.compileUnarySql(node.op, this.compileNode(node.operand, params));
+            case "column":
+                return this.renderColumn(node);
+            case "const":
+                params.push(node.value);
+                return this.placeholder(params.length);
+            case "param":
+                params.push({ __param: node.name });
+                return this.placeholder(params.length);
+            case "in":
+                return this.compileInNode(node, params);
+            case "exists":
+                return this.compileExistsNode(node, params);
+            case "subquery":
+                return this.compileSubqueryPlan(node.plan, params);
+            case "call": {
+                const receiver = this.compileNode(node.receiver, params);
+                if (node.method === "startsWith" ||
+                    node.method === "endsWith" ||
+                    node.method === "includes") {
+                    const arg = this.compileNode(node.args[0], params);
+                    return this.compileLike(receiver, arg, node.method);
+                }
+                throw new Error(`Unsupported method: ${node.method}`);
+            }
+            case "aggregate":
+                return this.compileAggregate(node, params);
+            case "case":
+                return this.compileInlineCase(node, params);
+        }
+    }
+    compileSubqueryPlan(plan, outerParams) {
+        const compiled = this.compilePlan(plan, {
+            wrap: true,
+            paramStartIndex: outerParams.length + 1,
+        });
+        outerParams.push(...compiled.params);
+        return compiled.sql;
+    }
+    compileInNode(node, params) {
+        const left = this.compileNode(node.left, params);
+        const op = node.negated ? "NOT IN" : "IN";
+        const rhs = node.right;
+        if (rhs.kind === "values") {
+            if (rhs.values.length === 0)
+                return node.negated ? "1=1" : "1=0";
+            const placeholders = rhs.values.map((v) => {
+                params.push(v);
+                return this.placeholder(params.length);
+            });
+            return `${left} ${op} (${placeholders.join(", ")})`;
+        }
+        if (rhs.kind === "param") {
+            params.push({ __param: rhs.name });
+            return `${left} ${op} (${this.placeholder(params.length)})`;
+        }
+        return `${left} ${op} ${this.compileSubqueryPlan(rhs.plan, params)}`;
+    }
+    compileExistsNode(node, params) {
+        const innerSql = this.compileNode(node.predicate, params);
+        const wrappedSql = node.negated ? `(NOT (${innerSql}))` : innerSql;
+        const existsSql = this.compileExists(node.targetTable, node.innerAlias, node.fkColumns, node.outerAlias, node.mainPk, wrappedSql);
+        return node.negated ? `(NOT ${existsSql})` : existsSql;
+    }
+    compileExists(targetTable, alias, fkColumns, mainAlias, mainPk, innerSql) {
+        const pkConds = fkColumns
+            .map((fk, i) => `${this.escapeIdentifier(alias)}.${this.escapeIdentifier(fk)} = ${this.escapeIdentifier(mainAlias)}.${this.escapeIdentifier(mainPk[i] ?? mainPk[0])}`)
+            .join(" AND ");
+        return `(EXISTS (SELECT 1 FROM ${this.escapeIdentifier(targetTable)} AS ${this.escapeIdentifier(alias)} WHERE ${pkConds} AND (${innerSql})))`;
+    }
+    compileLike(receiver, arg, mode) {
+        if (mode === "startsWith")
+            return `(${receiver} LIKE ${arg} || '%')`;
+        if (mode === "endsWith")
+            return `(${receiver} LIKE '%' || ${arg})`;
+        return `(${receiver} LIKE '%' || ${arg} || '%')`;
+    }
+    compileAggregate(agg, params = []) {
+        switch (agg.func) {
+            case "SUM":
+            case "AVG":
+            case "MIN":
+            case "MAX":
+            case "COUNT":
+                return this.compileStandardAggregate(agg.func, agg, params);
+            default:
+                throw new Error(`[typhex] Aggregate function "${agg.func}" is dialect-specific. Use the matching dialect query compiler.`);
+        }
+    }
+    buildJoinClause(join, mainAlias, onSql) {
+        const kw = BaseQueryCompiler.JOIN_SQL_KEYWORDS[join.joinType] ?? "LEFT JOIN";
+        if (join.on) {
+            return ` ${kw} ${this.escapeIdentifier(join.targetTable)} AS ${this.escapeIdentifier(join.alias)} ON ${onSql}`;
+        }
+        const on = join.foreignKeys
+            .map((fk, i) => `${this.escapeIdentifier(mainAlias)}.${this.escapeIdentifier(fk)} = ${this.escapeIdentifier(join.alias)}.${this.escapeIdentifier(join.targetPkColumns[i] ?? join.targetPkColumns[0])}`)
+            .join(" AND ");
+        return ` ${kw} ${this.escapeIdentifier(join.targetTable)} AS ${this.escapeIdentifier(join.alias)} ON ${on}`;
+    }
+    appendOnConflict(baseSql, onConflict, insertColumns) {
+        const conflictCols = onConflict.conflictColumns.map((c) => this.escapeIdentifier(c)).join(", ");
+        if (onConflict.action === "nothing") {
+            return `${baseSql} ON CONFLICT (${conflictCols}) DO NOTHING`;
+        }
+        const updateCols = onConflict.updateColumns?.length
+            ? onConflict.updateColumns
+            : insertColumns.filter((c) => !onConflict.conflictColumns.includes(c));
+        const setClauses = updateCols
+            .map((c) => `${this.escapeIdentifier(c)} = ${this.excludedTableName()}.${this.escapeIdentifier(c)}`)
+            .join(", ");
+        return `${baseSql} ON CONFLICT (${conflictCols}) DO UPDATE SET ${setClauses}`;
+    }
+    excludedTableName() {
+        return "EXCLUDED";
+    }
+    singleInsertReturnsRows(hasPk) {
+        return hasPk;
+    }
+    renderInsertManyValue(value, paramIndex) {
+        if (value === SQL_DEFAULT)
+            return { sql: "DEFAULT", params: [] };
+        return { sql: this.placeholder(paramIndex), params: [value] };
+    }
+    renumberUpdateWhereParams(whereSql, offset) {
+        if (this.dialect !== "postgres")
+            return whereSql;
+        return whereSql.replaceAll(/\$(\d+)/g, (_, n) => `$${Number.parseInt(n, 10) + offset}`);
+    }
+    registeredCteNames(plan) {
+        return new Set([
+            ...(plan.inScopeRegisteredCteNames ?? []),
+            ...(plan.ctes?.map((c) => c.name) ?? []),
+        ]);
+    }
+    fixMutationWhereAlias(table, whereSql, alias = "t0", keepAlias = false) {
+        if (keepAlias)
+            return whereSql;
+        const aliasRef = `${this.escapeIdentifier(alias)}.`;
+        return whereSql.replaceAll(aliasRef, `${this.escapeIdentifier(table)}.`);
+    }
+    compileCreateTable(table, schema, ifNotExists) {
+        const cols = Object.entries(schema).map(([c, def]) => `  ${this.escapeIdentifier(c)} ${this.toColumnDef(def)}`);
+        const existenceClause = ifNotExists ? " IF NOT EXISTS" : "";
+        return `CREATE TABLE${existenceClause} ${this.escapeIdentifier(table)} (\n${cols.join(",\n")}\n);`;
+    }
+    compileRecreateDroppedTable(table, columnInfos) {
+        const cols = columnInfos.map((c) => `  ${this.escapeIdentifier(c.name)} ${this.reconstructColDef(c)}`);
+        return `CREATE TABLE IF NOT EXISTS ${this.escapeIdentifier(table)} (\n${cols.join(",\n")}\n);`;
+    }
+    compileAlterColumn(action, reverse) {
+        const dimensions = action.changes.map((c) => c.kind).join(", ");
+        const direction = reverse ? "rollback" : "apply";
+        throw new Error(`${this.dialect} cannot ${direction} ALTER COLUMN on ${action.table}.${action.column} ` +
+            `(changes: ${dimensions}). The table must be recreated; please write the migration manually.`);
+    }
+    reconstructColDef(col) {
+        let def = col.type;
+        if (col.pk)
+            def += " PRIMARY KEY";
+        else if (col.notnull)
+            def += " NOT NULL";
+        if (col.dflt_value !== null)
+            def += ` DEFAULT ${col.dflt_value}`;
+        return def;
+    }
+    createExpander(options) {
+        const paramStartIndex = options.paramStartIndex ?? 1;
+        let nextOffset = paramStartIndex;
+        return {
+            paramStartIndex,
+            expand: (compiled, paramValues) => {
+                const out = this.expandPlaceholders(compiled.sql, resolveParamSentinels(compiled.params, paramValues), nextOffset);
+                nextOffset += out.params.length;
+                return out;
+            },
+        };
+    }
+}
+//# sourceMappingURL=query-compiler.js.map