neoorm 0.3.0 → 0.4.0

package/dist/runtime/query/compile.js

@@ -1,8 +1,13 @@
 import { effectiveRelations } from "../../codegen/manifest-relations.js";
-import { quoteIdentifier, tableRef } from "../../dialect/postgres.js";
+import { postgresDialect, quoteIdentifier, tableRef } from "../../dialect/postgres.js";
 import { getColumnType } from "../../plugins/registry.js";
+import { rebaseParamRefs } from "../../sql/template.js";
 import { findM2M } from "./manifest-lookup.js";
 import { primaryKeySqlName, requireScalarPrimaryKey, targetRelationPkSql, } from "./primary-key.js";
+import { columnBySqlName, columnByTsName, columnsByTsNames, getOrSetSqlCache, getTableIndex, reorderKeyValues, sortedKeysCacheKey, } from "./table-index.js";
+function colByTs(table, tsName, manifestIndex) {
+    return columnByTsName(getTableIndex(manifestIndex, table.accessor), table, tsName);
+}
 const PARAMLESS_OPERATORS = new Set(["isNull", "isNotNull"]);
 function isOperatorObject(value) {
     return (typeof value === "object" &&
@@ -20,18 +25,21 @@ function pluginWhereOperators(col) {
         return {};
     return getColumnType(col.kind)?.whereOperators ?? {};
 }
-export function serializeColumnValue(col, value) {
+export function serializeColumnValue(col, value, dialect = postgresDialect) {
     if (col.kind === "fk")
         return value;
     const plugin = getColumnType(col.kind);
     if (plugin?.serializeValue) {
-        return plugin.serializeValue(col, value);
+        return plugin.serializeValue(col, value, dialect);
     }
     return value;
 }
 function defaultColumnRef(col) {
     return quoteIdentifier(col.sqlName);
 }
+function qualifiedColumnRefForTable(table) {
+    return (col) => `${tableRef(table)}.${quoteIdentifier(col.sqlName)}`;
+}
 function parentPkRef(table) {
     const pkSql = primaryKeySqlName(table);
     return `${tableRef(table)}.${quoteIdentifier(pkSql)}`;
@@ -77,6 +85,15 @@ function compileColumnCondition(col, rawValue, dialect, paramIndex, columnRef) {
             conditions.push(dialect.whereOperators[operator](sqlCol, nextParamIndex));
             continue;
         }
+        if (Array.isArray(value) && value.length === 0) {
+            if (operator === "in") {
+                conditions.push("1=0");
+            }
+            else if (operator === "notIn") {
+                conditions.push("1=1");
+            }
+            continue;
+        }
         const transform = operatorParamTransform[operator];
         const paramValue = operator === "in" || operator === "notIn"
             ? Array.isArray(value)
@@ -94,20 +111,22 @@ function compileColumnCondition(col, rawValue, dialect, paramIndex, columnRef) {
 function compileExistsSubquery(existsSql, negate) {
     return negate ? `NOT EXISTS (${existsSql})` : `EXISTS (${existsSql})`;
 }
-function compileRelationCondition(manifest, parentTable, relation, rawValue, dialect, paramIndex) {
+function compileRelationCondition(manifest, parentTable, relation, rawValue, dialect, paramIndex, manifestIndex) {
     const m2m = findM2M(manifest, parentTable.accessor, relation.name);
     const targetTable = manifest.tables[relation.targetAccessor];
     if (!targetTable) {
         return { sql: "", params: [], nextParamIndex: paramIndex };
     }
+    const parentTableIndex = getTableIndex(manifestIndex, parentTable.accessor);
+    const targetTableIndex = getTableIndex(manifestIndex, targetTable.accessor);
     if (relation.cardinality === "one") {
         if (!isOperatorObject(rawValue) || Array.isArray(rawValue)) {
             return { sql: "", params: [], nextParamIndex: paramIndex };
         }
         const relAlias = "_rel";
         const columnRef = (col) => `${quoteIdentifier(relAlias)}.${quoteIdentifier(col.sqlName)}`;
-        const nested = compileWhereNode(manifest, targetTable, rawValue, dialect, paramIndex, columnRef);
-        const parentFkCol = parentTable.columns.find((c) => c.tsName === relation.fkColumn);
+        const nested = compileWhereNode(manifest, targetTable, rawValue, dialect, paramIndex, columnRef, manifestIndex);
+        const parentFkCol = columnByTsName(parentTableIndex, parentTable, relation.fkColumn);
         const parentFkRef = parentFkCol
             ? `${tableRef(parentTable)}.${quoteIdentifier(parentFkCol.sqlName)}`
             : `${tableRef(parentTable)}.${quoteIdentifier(relation.fkSqlColumn)}`;
@@ -136,7 +155,7 @@ function compileRelationCondition(manifest, parentTable, relation, rawValue, dia
     }
     const relAlias = "_rel";
     const columnRef = (col) => `${quoteIdentifier(relAlias)}.${quoteIdentifier(col.sqlName)}`;
-    const nested = compileWhereNode(manifest, targetTable, (nestedWhere ?? {}), dialect, paramIndex, columnRef);
+    const nested = compileWhereNode(manifest, targetTable, (nestedWhere ?? {}), dialect, paramIndex, columnRef, manifestIndex);
     let fromClause;
     let whereParts;
     if (m2m) {
@@ -193,18 +212,20 @@ function compileRelationCondition(manifest, parentTable, relation, rawValue, dia
         nextParamIndex: nested.nextParamIndex,
     };
 }
-function compileWhereNode(manifest, table, where, dialect, startParamIndex, columnRef = defaultColumnRef) {
+function compileWhereNode(manifest, table, where, dialect, startParamIndex, columnRef = defaultColumnRef, manifestIndex) {
     const conditions = [];
     const params = [];
     let paramIndex = startParamIndex;
-    const relations = new Map(effectiveRelations(manifest, table).map((rel) => [rel.name, rel]));
+    const tableIndex = getTableIndex(manifestIndex, table.accessor);
+    const relations = tableIndex?.effectiveRelationsByName ??
+        new Map(effectiveRelations(manifest, table).map((rel) => [rel.name, rel]));
     for (const [key, value] of Object.entries(where)) {
         if (key === "AND" && Array.isArray(value)) {
             const parts = [];
             for (const item of value) {
                 if (!item || typeof item !== "object" || Array.isArray(item))
                     continue;
-                const compiled = compileWhereNode(manifest, table, item, dialect, paramIndex, columnRef);
+                const compiled = compileWhereNode(manifest, table, item, dialect, paramIndex, columnRef, manifestIndex);
                 if (compiled.sql)
                     parts.push(`(${compiled.sql})`);
                 params.push(...compiled.params);
@@ -219,7 +240,7 @@ function compileWhereNode(manifest, table, where, dialect, startParamIndex, colu
             for (const item of value) {
                 if (!item || typeof item !== "object" || Array.isArray(item))
                     continue;
-                const compiled = compileWhereNode(manifest, table, item, dialect, paramIndex, columnRef);
+                const compiled = compileWhereNode(manifest, table, item, dialect, paramIndex, columnRef, manifestIndex);
                 if (compiled.sql)
                     parts.push(`(${compiled.sql})`);
                 params.push(...compiled.params);
@@ -230,7 +251,7 @@ function compileWhereNode(manifest, table, where, dialect, startParamIndex, colu
             continue;
         }
         if (key === "NOT" && isOperatorObject(value)) {
-            const compiled = compileWhereNode(manifest, table, value, dialect, paramIndex, columnRef);
+            const compiled = compileWhereNode(manifest, table, value, dialect, paramIndex, columnRef, manifestIndex);
             if (compiled.sql)
                 conditions.push(`NOT (${compiled.sql})`);
             params.push(...compiled.params);
@@ -239,14 +260,14 @@ function compileWhereNode(manifest, table, where, dialect, startParamIndex, colu
         }
         const relation = relations.get(key);
         if (relation) {
-            const compiled = compileRelationCondition(manifest, table, relation, value, dialect, paramIndex);
+            const compiled = compileRelationCondition(manifest, table, relation, value, dialect, paramIndex, manifestIndex);
             if (compiled.sql)
                 conditions.push(compiled.sql);
             params.push(...compiled.params);
             paramIndex = compiled.nextParamIndex;
             continue;
         }
-        const col = table.columns.find((c) => c.tsName === key);
+        const col = columnByTsName(tableIndex, table, key);
         if (!col)
             continue;
         const compiled = compileColumnCondition(col, value, dialect, paramIndex, columnRef);
@@ -261,16 +282,173 @@ function compileWhereNode(manifest, table, where, dialect, startParamIndex, colu
         nextParamIndex: paramIndex,
     };
 }
-export function compileWhere(manifest, table, where, dialect, startParamIndex = 1) {
+export function compileWhere(manifest, table, where, dialect, startParamIndex = 1, manifestIndex, qualifyColumns = false) {
     if (!where || Object.keys(where).length === 0) {
         return { sql: "", params: [] };
     }
-    const result = compileWhereNode(manifest, table, where, dialect, startParamIndex);
+    const columnRef = qualifyColumns
+        ? qualifiedColumnRefForTable(table)
+        : defaultColumnRef;
+    const result = compileWhereNode(manifest, table, where, dialect, startParamIndex, columnRef, manifestIndex);
+    const impossible = isImpossibleWhereSql(result.sql);
     return {
         sql: result.sql ? `WHERE ${result.sql}` : "",
         params: result.params,
+        ...(impossible ? { impossible: true } : {}),
     };
 }
+function whereShapeKey(where) {
+    const parts = [];
+    for (const [key, value] of Object.entries(where)) {
+        if (key === "AND" && Array.isArray(value)) {
+            parts.push(`AND:${value
+                .filter((item) => !!item && typeof item === "object" && !Array.isArray(item))
+                .map((item) => whereShapeKey(item))
+                .join(",")}`);
+            continue;
+        }
+        if (key === "OR" && Array.isArray(value)) {
+            parts.push(`OR:${value
+                .filter((item) => !!item && typeof item === "object" && !Array.isArray(item))
+                .map((item) => whereShapeKey(item))
+                .join(",")}`);
+            continue;
+        }
+        if (key === "NOT" && isOperatorObject(value)) {
+            parts.push(`NOT:${whereShapeKey(value)}`);
+            continue;
+        }
+        if (isOperatorObject(value) && !(value instanceof Date)) {
+            const ops = Object.keys(value).sort();
+            if (ops.some((op) => op === "some" || op === "every" || op === "none")) {
+                const mode = ops.find((op) => op === "some" || op === "every" || op === "none");
+                const nested = value[mode ?? ""];
+                parts.push(`${key}:rel:${mode}:${isOperatorObject(nested) ? whereShapeKey(nested) : "{}"}`);
+            }
+            else if (ops.includes("in") || ops.includes("notIn")) {
+                const arr = value.in ?? value.notIn;
+                const len = Array.isArray(arr) ? arr.length : 0;
+                const op = ops.includes("in") ? "in" : "notIn";
+                parts.push(`${key}:${op}:${len}`);
+            }
+            else {
+                parts.push(`${key}:${ops.join(",")}`);
+            }
+            continue;
+        }
+        parts.push(`${key}:eq`);
+    }
+    return parts.join("&");
+}
+function collectWhereParams(manifest, table, where, dialect, manifestIndex) {
+    const params = [];
+    function walk(node, columnRef) {
+        const tableIndex = getTableIndex(manifestIndex, table.accessor);
+        const relations = tableIndex?.effectiveRelationsByName ??
+            new Map(effectiveRelations(manifest, table).map((rel) => [rel.name, rel]));
+        for (const [key, value] of Object.entries(node)) {
+            if (key === "AND" || key === "OR") {
+                if (Array.isArray(value)) {
+                    for (const item of value) {
+                        if (item && typeof item === "object" && !Array.isArray(item)) {
+                            walk(item, columnRef);
+                        }
+                    }
+                }
+                continue;
+            }
+            if (key === "NOT" && isOperatorObject(value)) {
+                walk(value, columnRef);
+                continue;
+            }
+            if (relations.get(key)) {
+                const compiled = compileRelationCondition(manifest, table, relations.get(key), value, dialect, 1, manifestIndex);
+                params.push(...compiled.params);
+                continue;
+            }
+            const col = columnByTsName(tableIndex, table, key);
+            if (!col)
+                continue;
+            const compiled = compileColumnCondition(col, value, dialect, 1, columnRef);
+            params.push(...compiled.params);
+        }
+    }
+    walk(where, defaultColumnRef);
+    return params;
+}
+function whereValuesFingerprint(manifest, table, where, dialect, manifestIndex) {
+    return JSON.stringify(collectWhereParams(manifest, table, where, dialect, manifestIndex));
+}
+export function getCachedWhereClause(manifest, table, where, dialect, startParamIndex = 1, manifestIndex, qualifyColumns = false) {
+    if (!where || Object.keys(where).length === 0) {
+        return { sql: "", params: [] };
+    }
+    const tableIndex = getTableIndex(manifestIndex, table.accessor);
+    const shape = qualifyColumns
+        ? `${whereShapeKey(where)}|qualified`
+        : whereShapeKey(where);
+    const shellCached = tableIndex?.whereClauseByShape.get(shape);
+    if (shellCached) {
+        return {
+            sql: shellCached.sql,
+            params: collectWhereParams(manifest, table, where, dialect, manifestIndex),
+            ...(shellCached.impossible ? { impossible: true } : {}),
+        };
+    }
+    const fingerprint = whereValuesFingerprint(manifest, table, where, dialect, manifestIndex);
+    const cacheKey = `${shape}\0${fingerprint}`;
+    const cached = tableIndex?.whereClauseByFingerprint.get(cacheKey);
+    if (cached)
+        return cached;
+    const compiled = compileWhere(manifest, table, where, dialect, startParamIndex, manifestIndex, qualifyColumns);
+    tableIndex?.whereClauseByShape.set(shape, {
+        sql: compiled.sql,
+        ...(compiled.impossible ? { impossible: true } : {}),
+    });
+    tableIndex?.whereClauseByFingerprint.set(cacheKey, compiled);
+    return compiled;
+}
+export function orderByShapeKey(orderBy, tableAlias) {
+    if (!orderBy || Object.keys(orderBy).length === 0)
+        return "";
+    const entries = Object.entries(orderBy)
+        .filter(([key]) => key !== "_count")
+        .map(([key, direction]) => typeof direction === "string" ? `${key}:${direction.toUpperCase()}` : "")
+        .filter(Boolean)
+        .sort((a, b) => a.localeCompare(b));
+    if (entries.length === 0)
+        return "";
+    const base = entries.join("|");
+    return tableAlias ? `${base}|@${tableAlias}` : base;
+}
+export function getCachedOrderByClause(table, orderBy, tableAlias, manifestIndex) {
+    if (!orderBy || Object.keys(orderBy).length === 0)
+        return "";
+    const tableIndex = getTableIndex(manifestIndex, table.accessor);
+    const shape = orderByShapeKey(orderBy, tableAlias);
+    if (!shape)
+        return "";
+    if (!tableIndex) {
+        return compileOrderBy(table, orderBy, tableAlias, manifestIndex);
+    }
+    return getOrSetSqlCache(tableIndex.orderBySqlByShape, shape, () => compileOrderBy(table, orderBy, tableAlias, manifestIndex));
+}
+export function getCachedDeleteManyQuery(tableIndex, table, whereSql) {
+    const cacheKey = whereSql || "";
+    if (!tableIndex)
+        return buildDeleteManyQuery(table, whereSql);
+    return getOrSetSqlCache(tableIndex.deleteManySqlByWhereShape, cacheKey, () => buildDeleteManyQuery(table, whereSql));
+}
+export function isImpossibleWhereSql(sql) {
+    if (!sql)
+        return false;
+    return /\b1\s*=\s*0\b/.test(sql);
+}
+export function isImpossibleWhere(whereSql) {
+    if (!whereSql)
+        return false;
+    return isImpossibleWhereSql(whereSql.replace(/^WHERE\s+/i, ""));
+}
 function buildValuePlaceholder(col, paramIndex) {
     if (!col || col.kind === "fk")
         return `$${paramIndex}`;
@@ -284,16 +462,20 @@ function buildSetExpression(col, paramIndex) {
     const sqlCol = quoteIdentifier(col?.sqlName ?? "");
     return `${sqlCol} = ${buildValuePlaceholder(col, paramIndex)}`;
 }
-export function compileOrderBy(table, orderBy) {
+export function compileOrderBy(table, orderBy, tableAlias, manifestIndex) {
     if (!orderBy || Object.keys(orderBy).length === 0)
         return "";
+    const tableIndex = getTableIndex(manifestIndex, table.accessor);
+    const prefix = tableAlias ? `${quoteIdentifier(tableAlias)}.` : "";
     const parts = [];
     for (const [tsKey, direction] of Object.entries(orderBy)) {
-        const col = table.columns.find((c) => c.tsName === tsKey);
+        if (tsKey === "_count" || typeof direction !== "string")
+            continue;
+        const col = columnByTsName(tableIndex, table, tsKey);
         if (!col)
             continue;
         const dir = direction.toUpperCase() === "DESC" ? "DESC" : "ASC";
-        parts.push(`${quoteIdentifier(col.sqlName)} ${dir}`);
+        parts.push(`${prefix}${quoteIdentifier(col.sqlName)} ${dir}`);
     }
     return parts.length > 0 ? `ORDER BY ${parts.join(", ")}` : "";
 }
@@ -306,90 +488,129 @@ export function normalizeSelectColumns(select) {
         .filter(([, enabled]) => enabled === true)
         .map(([key]) => key);
 }
+function aliasToTsName(expression, col) {
+    if (col.sqlName === col.tsName)
+        return expression;
+    return `${expression} AS ${quoteIdentifier(col.tsName)}`;
+}
 function selectExpression(col) {
     if (col.kind === "fk") {
-        return quoteIdentifier(col.sqlName);
+        return aliasToTsName(quoteIdentifier(col.sqlName), col);
     }
     const plugin = getColumnType(col.kind);
     if (plugin?.selectExpression) {
-        return plugin.selectExpression(col);
+        return aliasToTsName(plugin.selectExpression(col), col);
     }
-    return quoteIdentifier(col.sqlName);
+    return aliasToTsName(quoteIdentifier(col.sqlName), col);
 }
-export function buildSelectColumns(table, select) {
+export function buildSelectColumns(table, select, manifestIndex) {
+    const tableIndex = getTableIndex(manifestIndex, table.accessor);
     const cols = select && select.length > 0
-        ? table.columns.filter((c) => select.includes(c.tsName))
+        ? columnsByTsNames(tableIndex, table, select)
         : table.columns;
     return cols.map((c) => selectExpression(c)).join(", ");
 }
+export function buildQualifiedSelectColumns(table, select, manifestIndex) {
+    const ref = tableRef(table);
+    const tableIndex = getTableIndex(manifestIndex, table.accessor);
+    const cols = select && select.length > 0
+        ? columnsByTsNames(tableIndex, table, select)
+        : table.columns;
+    return cols.map((c) => `${ref}.${selectExpression(c)}`).join(", ");
+}
 export function buildFindByIdQuery(table) {
     const { sqlName } = requireScalarPrimaryKey(table);
     const sqlCol = quoteIdentifier(sqlName);
     const selectCols = buildSelectColumns(table);
     return `SELECT ${selectCols} FROM ${tableRef(table)} WHERE ${sqlCol} = $1`;
 }
-export function buildFindManyQuery(table, whereSql, orderSql, limit, offset, distinctOn) {
-    const selectCols = buildSelectColumns(table);
+export function buildFindAllQuery(table) {
+    return `SELECT ${buildSelectColumns(table)} FROM ${tableRef(table)}`;
+}
+export function normalizeLimitOffset(value, label) {
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+        throw new Error(`${label} must be a non-negative integer, got ${JSON.stringify(value)}`);
+    }
+    return value;
+}
+export function buildFindManyQuery(table, whereSql, orderSql, limit, offset, distinctOn, extraSelectCols, joinClauses, manifestIndex, groupBySql) {
+    const hasJoins = Boolean(joinClauses && joinClauses.length > 0);
+    const tableIndex = getTableIndex(manifestIndex, table.accessor);
+    const selectCols = hasJoins
+        ? buildQualifiedSelectColumns(table, undefined, manifestIndex)
+        : buildSelectColumns(table, undefined, manifestIndex);
     let sql = "SELECT ";
     if (distinctOn && distinctOn.length > 0) {
-        const distinctCols = distinctOn
-            .map((tsName) => table.columns.find((c) => c.tsName === tsName))
-            .filter((col) => col !== undefined)
-            .map((col) => quoteIdentifier(col.sqlName))
+        const distinctCols = columnsByTsNames(tableIndex, table, distinctOn)
+            .map((col) => hasJoins
+            ? `${tableRef(table)}.${quoteIdentifier(col.sqlName)}`
+            : quoteIdentifier(col.sqlName))
             .join(", ");
         sql += `DISTINCT ON (${distinctCols}) `;
     }
-    sql += `${selectCols} FROM ${tableRef(table)}`;
+    sql += selectCols;
+    if (extraSelectCols && extraSelectCols.length > 0) {
+        sql += `, ${extraSelectCols.join(", ")}`;
+    }
+    sql += ` FROM ${tableRef(table)}`;
+    if (joinClauses && joinClauses.length > 0) {
+        sql += ` ${joinClauses.join(" ")}`;
+    }
     if (whereSql)
         sql += ` ${whereSql}`;
+    if (groupBySql)
+        sql += ` ${groupBySql}`;
     if (orderSql)
         sql += ` ${orderSql}`;
-    if (limit !== undefined)
-        sql += ` LIMIT ${limit}`;
-    if (offset !== undefined)
-        sql += ` OFFSET ${offset}`;
+    if (limit !== undefined) {
+        sql += ` LIMIT ${normalizeLimitOffset(limit, "limit")}`;
+    }
+    if (offset !== undefined) {
+        sql += ` OFFSET ${normalizeLimitOffset(offset, "offset")}`;
+    }
     return sql;
 }
-export function buildPaginateQuery(table, whereSql, orderSql, take) {
-    return buildFindManyQuery(table, whereSql, orderSql, take + 1);
+export function buildPaginateQuery(table, whereSql, orderSql, take, extraSelectCols, joinClauses, manifestIndex) {
+    return buildFindManyQuery(table, whereSql, orderSql, take + 1, undefined, undefined, extraSelectCols, joinClauses, manifestIndex);
 }
-export function buildCountQuery(table, whereSql) {
-    let sql = `SELECT COUNT(*)::int AS count FROM ${tableRef(table)}`;
+export function buildCountQuery(table, whereSql, dialect = postgresDialect) {
+    let sql = `SELECT ${dialect.castToInt("COUNT(*)")} AS count FROM ${tableRef(table)}`;
     if (whereSql)
         sql += ` ${whereSql}`;
     return sql;
 }
-function aggregateSqlCol(table, tsName) {
-    const col = table.columns.find((c) => c.tsName === tsName);
+function aggregateSqlCol(table, tsName, dialect, manifestIndex) {
+    const tableIndex = getTableIndex(manifestIndex, table.accessor);
+    const col = columnByTsName(tableIndex, table, tsName);
     if (!col)
         return undefined;
     const sqlCol = quoteIdentifier(col.sqlName);
     if (col.kind === "decimal")
-        return `${sqlCol}::numeric`;
+        return dialect.castToNumeric(sqlCol);
     return sqlCol;
 }
-export function buildAggregateQuery(table, selectors, whereSql) {
+export function buildAggregateQuery(table, selectors, whereSql, manifestIndex, dialect = postgresDialect) {
     const parts = [];
     if (selectors._count) {
-        parts.push('COUNT(*)::int AS "_count"');
+        parts.push(`${dialect.castToInt("COUNT(*)")} AS "__count"`);
     }
     for (const colName of Object.keys(selectors._avg ?? {})) {
-        const sqlCol = aggregateSqlCol(table, colName);
+        const sqlCol = aggregateSqlCol(table, colName, dialect, manifestIndex);
         if (sqlCol)
             parts.push(`AVG(${sqlCol}) AS "_avg_${colName}"`);
     }
     for (const colName of Object.keys(selectors._sum ?? {})) {
-        const sqlCol = aggregateSqlCol(table, colName);
+        const sqlCol = aggregateSqlCol(table, colName, dialect, manifestIndex);
         if (sqlCol)
             parts.push(`SUM(${sqlCol}) AS "_sum_${colName}"`);
     }
     for (const colName of Object.keys(selectors._min ?? {})) {
-        const sqlCol = aggregateSqlCol(table, colName);
+        const sqlCol = aggregateSqlCol(table, colName, dialect, manifestIndex);
         if (sqlCol)
             parts.push(`MIN(${sqlCol}) AS "_min_${colName}"`);
     }
     for (const colName of Object.keys(selectors._max ?? {})) {
-        const sqlCol = aggregateSqlCol(table, colName);
+        const sqlCol = aggregateSqlCol(table, colName, dialect, manifestIndex);
         if (sqlCol)
             parts.push(`MAX(${sqlCol}) AS "_max_${colName}"`);
     }
@@ -401,54 +622,118 @@ export function buildAggregateQuery(table, selectors, whereSql) {
         sql += ` ${whereSql}`;
     return sql;
 }
-export function buildUpsertQuery(table, insertKeys, updateKeys, conflictSqlColumns, exprSets = []) {
+export function aggregateSelectorCacheKey(selectors) {
+    const parts = [];
+    if (selectors._count)
+        parts.push("_count");
+    for (const key of ["_avg", "_sum", "_min", "_max"]) {
+        const fieldMap = selectors[key];
+        if (!fieldMap)
+            continue;
+        parts.push(`${key}:${Object.keys(fieldMap).sort().join(",")}`);
+    }
+    return parts.join("|");
+}
+export function getCachedAggregateQuery(tableIndex, table, selectors, whereSql, manifestIndex, dialect = postgresDialect) {
+    const cacheKey = `${dialect.name}|${aggregateSelectorCacheKey(selectors)}|${whereSql}`;
+    if (!tableIndex) {
+        return buildAggregateQuery(table, selectors, whereSql, manifestIndex, dialect);
+    }
+    return getOrSetSqlCache(tableIndex.aggregateSqlBySelector, cacheKey, () => buildAggregateQuery(table, selectors, whereSql, manifestIndex, dialect));
+}
+export function buildUpsertQuery(table, insertKeys, updateKeys, conflictSqlColumns, exprSets = [], manifestIndex) {
     const insertCols = insertKeys.map((k) => {
-        const col = table.columns.find((c) => c.tsName === k);
+        const col = colByTs(table, k, manifestIndex);
         return quoteIdentifier(col?.sqlName ?? k);
     });
     const insertPlaceholders = insertKeys
         .map((k, i) => {
-        const col = table.columns.find((c) => c.tsName === k);
+        const col = colByTs(table, k, manifestIndex);
         return buildValuePlaceholder(col, i + 1);
     })
         .join(", ");
-    const selectCols = buildSelectColumns(table);
+    const selectCols = buildSelectColumns(table, undefined, manifestIndex);
     const conflictCols = conflictSqlColumns
         .map((c) => quoteIdentifier(c))
         .join(", ");
     const updateSets = updateKeys.length > 0
         ? updateKeys.map((k) => {
-            const col = table.columns.find((c) => c.tsName === k);
+            const col = colByTs(table, k, manifestIndex);
             const sqlCol = quoteIdentifier(col?.sqlName ?? k);
-            return `${sqlCol} = EXCLUDED.${sqlCol}`;
+            return `${sqlCol} = excluded.${sqlCol}`;
         })
         : exprSets.length === 0
             ? conflictSqlColumns.map((c) => {
                 const sqlCol = quoteIdentifier(c);
-                return `${sqlCol} = EXCLUDED.${sqlCol}`;
+                return `${sqlCol} = excluded.${sqlCol}`;
             })
             : [];
     const allUpdateSets = [...updateSets, ...exprSets];
     return `INSERT INTO ${tableRef(table)} (${insertCols.join(", ")}) VALUES (${insertPlaceholders}) ON CONFLICT (${conflictCols}) DO UPDATE SET ${allUpdateSets.join(", ")} RETURNING ${selectCols}`;
 }
-export function buildInsertQuery(table, dataKeys) {
+export const FIND_OR_CREATE_FLAG = "__neoorm_created";
+export function buildFindOrCreateQuery(table, insertKeys, conflictSqlColumns, fallbackWhereBody, manifestIndex) {
+    const insertCols = insertKeys.map((k) => {
+        const col = colByTs(table, k, manifestIndex);
+        return quoteIdentifier(col?.sqlName ?? k);
+    });
+    const insertPlaceholders = insertKeys
+        .map((k, i) => {
+        const col = colByTs(table, k, manifestIndex);
+        return buildValuePlaceholder(col, i + 1);
+    })
+        .join(", ");
+    const selectCols = buildSelectColumns(table, undefined, manifestIndex);
+    const conflictCols = conflictSqlColumns
+        .map((c) => quoteIdentifier(c))
+        .join(", ");
+    const tableSql = tableRef(table);
+    const fallbackClause = fallbackWhereBody
+        ? ` AND (${fallbackWhereBody})`
+        : "";
+    return `WITH ins AS (
+  INSERT INTO ${tableSql} (${insertCols.join(", ")}) VALUES (${insertPlaceholders})
+  ON CONFLICT (${conflictCols}) DO NOTHING
+  RETURNING ${selectCols}
+)
+SELECT ${selectCols}, true AS "${FIND_OR_CREATE_FLAG}" FROM ins
+UNION ALL
+SELECT ${selectCols}, false AS "${FIND_OR_CREATE_FLAG}" FROM ${tableSql} t
+WHERE NOT EXISTS (SELECT 1 FROM ins)${fallbackClause}
+LIMIT 1`;
+}
+export function buildInsertQuery(table, dataKeys, manifestIndex, returning = "pk") {
     if (dataKeys.length === 0) {
         throw new Error("Cannot build INSERT query with no columns");
     }
-    const cols = dataKeys.map((k) => {
-        const col = table.columns.find((c) => c.tsName === k);
+    const orderedKeys = [...dataKeys].sort();
+    const cols = orderedKeys.map((k) => {
+        const col = colByTs(table, k, manifestIndex);
         return quoteIdentifier(col?.sqlName ?? k);
     });
-    const placeholders = dataKeys
+    const placeholders = orderedKeys
         .map((k, i) => {
-        const col = table.columns.find((c) => c.tsName === k);
+        const col = colByTs(table, k, manifestIndex);
         return buildValuePlaceholder(col, i + 1);
     })
         .join(", ");
-    const selectCols = buildSelectColumns(table);
-    return `INSERT INTO ${tableRef(table)} (${cols.join(", ")}) VALUES (${placeholders}) RETURNING ${selectCols}`;
-}
-export function buildInsertManyValueRows(table, dataKeys, rows) {
+    let sql = `INSERT INTO ${tableRef(table)} (${cols.join(", ")}) VALUES (${placeholders})`;
+    if (returning === "none")
+        return sql;
+    const returningCols = returning === "full"
+        ? buildSelectColumns(table, undefined, manifestIndex)
+        : buildReturningPkColumns(table, manifestIndex);
+    return `${sql} RETURNING ${returningCols}`;
+}
+export function getCachedInsertQuery(tableIndex, table, dataKeys, returning, manifestIndex) {
+    const orderedKeys = [...dataKeys].sort();
+    const cacheKey = `${sortedKeysCacheKey(orderedKeys)}:${returning}`;
+    if (!tableIndex) {
+        return buildInsertQuery(table, orderedKeys, manifestIndex, returning);
+    }
+    return getOrSetSqlCache(tableIndex.insertSqlByKeys, cacheKey, () => buildInsertQuery(table, orderedKeys, manifestIndex, returning));
+}
+export function buildInsertManyValueRows(table, dataKeys, rows, manifestIndex) {
     if (dataKeys.length === 0) {
         throw new Error("Cannot build INSERT many value rows with no columns");
     }
@@ -462,7 +747,7 @@ export function buildInsertManyValueRows(table, dataKeys, rows) {
             if (key === undefined) {
                 throw new Error("dataKeys index out of bounds");
             }
-            const col = table.columns.find((c) => c.tsName === key);
+            const col = colByTs(table, key, manifestIndex);
             const val = row[i];
             if (val === undefined) {
                 placeholders.push("DEFAULT");
@@ -477,37 +762,50 @@ export function buildInsertManyValueRows(table, dataKeys, rows) {
     }
     return { valueRows, values };
 }
-export function buildInsertManyQuery(table, dataKeys, valueRows) {
+export function buildInsertManyQuery(table, dataKeys, valueRows, manifestIndex) {
     if (dataKeys.length === 0) {
         throw new Error("Cannot build INSERT many query with no columns");
     }
     const cols = dataKeys.map((k) => {
-        const col = table.columns.find((c) => c.tsName === k);
+        const col = colByTs(table, k, manifestIndex);
         return quoteIdentifier(col?.sqlName ?? k);
     });
-    const selectCols = buildSelectColumns(table);
+    const selectCols = buildSelectColumns(table, undefined, manifestIndex);
     return `INSERT INTO ${tableRef(table)} (${cols.join(", ")}) VALUES ${valueRows.join(", ")} RETURNING ${selectCols}`;
 }
-export function buildUpdateQuery(table, dataKeys, whereSql, exprSets = []) {
-    const paramSets = dataKeys.map((k, i) => {
-        const col = table.columns.find((c) => c.tsName === k);
+export function buildUpdateQuery(table, dataKeys, whereSql, exprSets = [], manifestIndex, returning = "full") {
+    const orderedKeys = [...dataKeys].sort();
+    const paramSets = orderedKeys.map((k, i) => {
+        const col = colByTs(table, k, manifestIndex);
         return buildSetExpression(col, i + 1);
     });
     const sets = [...paramSets, ...exprSets];
-    const selectCols = buildSelectColumns(table);
-    const whereOffset = dataKeys.length;
+    const whereOffset = orderedKeys.length;
     let sql = `UPDATE ${tableRef(table)} SET ${sets.join(", ")}`;
     if (whereSql) {
-        const adjustedWhere = whereSql.replace(/\$(\d+)/g, (_, n) => {
-            return `$${Number(n) + whereOffset}`;
-        });
+        const adjustedWhere = rebaseParamRefs(whereSql, whereOffset);
         sql += ` ${adjustedWhere}`;
     }
-    sql += ` RETURNING ${selectCols}`;
-    return sql;
+    if (returning === "none")
+        return sql;
+    const returningCols = returning === "full"
+        ? buildSelectColumns(table, undefined, manifestIndex)
+        : buildReturningPkColumns(table, manifestIndex);
+    return `${sql} RETURNING ${returningCols}`;
+}
+export function buildReturningPkColumns(table, manifestIndex) {
+    const tableIndex = getTableIndex(manifestIndex, table.accessor);
+    return table.primaryKey
+        .map((sqlName) => {
+        const col = columnBySqlName(tableIndex, table, sqlName);
+        return quoteIdentifier(col?.sqlName ?? sqlName);
+    })
+        .join(", ");
 }
-export function buildDeleteQuery(table, whereSql) {
-    const selectCols = buildSelectColumns(table);
+export function buildDeleteQuery(table, whereSql, returning, manifestIndex) {
+    const selectCols = returning === "full"
+        ? buildSelectColumns(table, undefined, manifestIndex)
+        : buildReturningPkColumns(table, manifestIndex);
     let sql = `DELETE FROM ${tableRef(table)}`;
     if (whereSql)
         sql += ` ${whereSql}`;
@@ -520,27 +818,40 @@ export function buildDeleteManyQuery(table, whereSql) {
         sql += ` ${whereSql}`;
     return sql;
 }
-export function buildUpdateManyQuery(table, dataKeys, whereSql, exprSets = []) {
-    const paramSets = dataKeys.map((k, i) => {
-        const col = table.columns.find((c) => c.tsName === k);
+export function buildUpdateManyQuery(table, dataKeys, whereSql, exprSets = [], manifestIndex) {
+    const orderedKeys = [...dataKeys].sort();
+    const paramSets = orderedKeys.map((k, i) => {
+        const col = colByTs(table, k, manifestIndex);
         return buildSetExpression(col, i + 1);
     });
     const sets = [...paramSets, ...exprSets];
-    const whereOffset = dataKeys.length;
+    const whereOffset = orderedKeys.length;
     let sql = `UPDATE ${tableRef(table)} SET ${sets.join(", ")}`;
     if (whereSql) {
-        const adjustedWhere = whereSql.replace(/\$(\d+)/g, (_, n) => {
-            return `$${Number(n) + whereOffset}`;
-        });
+        const adjustedWhere = rebaseParamRefs(whereSql, whereOffset);
         sql += ` ${adjustedWhere}`;
     }
     return sql;
 }
-export function dataToSqlValues(table, data, options) {
+export function getCachedUpdateManyQuery(tableIndex, table, dataKeys, whereSql, exprSets, manifestIndex) {
+    const orderedKeys = [...dataKeys].sort();
+    const cacheKey = `${sortedKeysCacheKey(orderedKeys)}|${exprSets.length}|${whereSql}`;
+    if (!tableIndex) {
+        return buildUpdateManyQuery(table, orderedKeys, whereSql, exprSets, manifestIndex);
+    }
+    return getOrSetSqlCache(tableIndex.updateManySqlByKeys, cacheKey, () => buildUpdateManyQuery(table, orderedKeys, whereSql, exprSets, manifestIndex));
+}
+export function getCachedFindManyQuery(tableIndex, signature, build) {
+    if (!tableIndex)
+        return build();
+    return getOrSetSqlCache(tableIndex.findManySqlBySignature, signature, build);
+}
+export function dataToSqlValues(table, data, options, manifestIndex, dialect = postgresDialect) {
+    const tableIndex = getTableIndex(manifestIndex, table.accessor);
     const keys = [];
     const values = [];
     for (const [key, value] of Object.entries(data)) {
-        const col = table.columns.find((c) => c.tsName === key);
+        const col = columnByTsName(tableIndex, table, key);
         if (!col)
             continue;
         if (options?.excludePrimary && col.primary)
@@ -548,9 +859,9 @@ export function dataToSqlValues(table, data, options) {
         if (value === undefined)
             continue;
         keys.push(key);
-        values.push(serializeColumnValue(col, value));
+        values.push(serializeColumnValue(col, value, dialect));
     }
-    return { keys, values };
+    return reorderKeyValues(keys, values);
 }
 export function rowToTs(table, row) {
     const result = {};
@@ -569,7 +880,84 @@ export function rowToTs(table, row) {
     }
     return result;
 }
+function rowHasSqlNames(index, row) {
+    for (const col of index.renameColumns) {
+        if (col.sqlName !== col.tsName && col.sqlName in row) {
+            return true;
+        }
+    }
+    return false;
+}
+export function rowToTsIndexed(index, table, row) {
+    if (index.selectUsesColumnAliases && !rowHasSqlNames(index, row)) {
+        if (index.deserializeColumns.length === 0) {
+            return row;
+        }
+        const result = { ...row };
+        for (const col of index.deserializeColumns) {
+            const key = col.tsName in row ? col.tsName : col.sqlName;
+            if (key in row) {
+                const plugin = getColumnType(col.kind);
+                if (plugin?.deserializeValue) {
+                    result[col.tsName] = plugin.deserializeValue(col, row[key]);
+                }
+            }
+        }
+        return result;
+    }
+    if (!index.needsRowRename && index.deserializeColumns.length === 0) {
+        return row;
+    }
+    if (!index.needsRowRename) {
+        const result = { ...row };
+        for (const col of index.deserializeColumns) {
+            if (col.sqlName in row) {
+                const plugin = getColumnType(col.kind);
+                if (plugin?.deserializeValue) {
+                    result[col.tsName] = plugin.deserializeValue(col, row[col.sqlName]);
+                }
+            }
+        }
+        return result;
+    }
+    const result = {};
+    for (const col of table.columns) {
+        if (col.sqlName in row) {
+            result[col.tsName] = row[col.sqlName];
+        }
+    }
+    for (const col of index.deserializeColumns) {
+        if (col.sqlName in row) {
+            const plugin = getColumnType(col.kind);
+            if (plugin?.deserializeValue) {
+                result[col.tsName] = plugin.deserializeValue(col, row[col.sqlName]);
+            }
+        }
+    }
+    return result;
+}
+export function rowsToTsIndexed(index, table, rows) {
+    if (index.selectUsesColumnAliases &&
+        index.deserializeColumns.length === 0 &&
+        !index.needsRowRename) {
+        return rows;
+    }
+    if (!index.needsRowRename && index.deserializeColumns.length === 0) {
+        return rows;
+    }
+    return rows.map((row) => rowToTsIndexed(index, table, row));
+}
 export function rowsToTs(table, rows) {
     return rows.map((row) => rowToTs(table, row));
 }
+export function mapRowToTs(tableIndex, table, row) {
+    return tableIndex
+        ? rowToTsIndexed(tableIndex, table, row)
+        : rowToTs(table, row);
+}
+export function mapRowsToTs(tableIndex, table, rows) {
+    return tableIndex
+        ? rowsToTsIndexed(tableIndex, table, rows)
+        : rowsToTs(table, rows);
+}
 //# sourceMappingURL=compile.js.map