neoorm 0.4.7 → 0.5.0

package/dist/runtime/query/compile.js

@@ -1,5 +1,5 @@
 import { effectiveRelations } from "../../codegen/manifest-relations.js";
-import { postgresDialect, 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";
@@ -20,6 +20,35 @@ const operatorParamTransform = {
     startsWith: (v) => `${String(v)}%`,
     endsWith: (v) => `%${String(v)}`,
 };
+function parseQueryMode(value) {
+    if (value === undefined || value === "default")
+        return "default";
+    if (value === "insensitive")
+        return "insensitive";
+    throw new Error(`unsupported query mode: ${String(value)}`);
+}
+function isStringPatternOp(op) {
+    return (op === "contains" ||
+        op === "startsWith" ||
+        op === "endsWith" ||
+        op === "search");
+}
+function stringFilterSql(op, sqlCol, paramIndex, mode, dialect) {
+    switch (op) {
+        case "contains":
+        case "startsWith":
+        case "endsWith":
+            return mode === "insensitive"
+                ? dialect.ilike(sqlCol, paramIndex)
+                : dialect.whereOperators[op](sqlCol, paramIndex);
+        case "search":
+            return dialect.regex(sqlCol, paramIndex, mode === "insensitive");
+        default: {
+            const _never = op;
+            throw new Error(`unsupported string filter: ${_never}`);
+        }
+    }
+}
 function pluginWhereOperators(col) {
     if (col.kind === "fk")
         return {};
@@ -60,6 +89,7 @@ function compileColumnCondition(col, rawValue, dialect, paramIndex, columnRef) {
         nextParamIndex++;
         return { sql: conditions.join(" AND "), params, nextParamIndex };
     }
+    const queryMode = parseQueryMode(rawValue.mode);
     const hasOperator = Object.keys(rawValue).some((k) => k in dialect.whereOperators || k in spatialOps);
     if (!hasOperator) {
         conditions.push(dialect.whereOperators.equals(sqlCol, nextParamIndex));
@@ -68,6 +98,8 @@ function compileColumnCondition(col, rawValue, dialect, paramIndex, columnRef) {
         return { sql: conditions.join(" AND "), params, nextParamIndex };
     }
     for (const [op, value] of Object.entries(rawValue)) {
+        if (op === "mode")
+            continue;
         if (op in spatialOps) {
             const operator = spatialOps[op];
             if (!operator)
@@ -102,7 +134,9 @@ function compileColumnCondition(col, rawValue, dialect, paramIndex, columnRef) {
             : transform
                 ? transform(value)
                 : serializeColumnValue(col, value);
-        conditions.push(dialect.whereOperators[operator](sqlCol, nextParamIndex));
+        conditions.push(isStringPatternOp(operator)
+            ? stringFilterSql(operator, sqlCol, nextParamIndex, queryMode, dialect)
+            : dialect.whereOperators[operator](sqlCol, nextParamIndex));
         params.push(paramValue);
         nextParamIndex++;
     }
@@ -282,13 +316,15 @@ function compileWhereNode(manifest, table, where, dialect, startParamIndex, colu
         nextParamIndex: paramIndex,
     };
 }
-export function compileWhere(manifest, table, where, dialect, startParamIndex = 1, manifestIndex, qualifyColumns = false) {
+export function compileWhere(manifest, table, where, dialect, startParamIndex = 1, manifestIndex, qualifyColumns = false, tableAlias) {
     if (!where || Object.keys(where).length === 0) {
         return { sql: "", params: [] };
     }
-    const columnRef = qualifyColumns
-        ? qualifiedColumnRefForTable(table)
-        : defaultColumnRef;
+    const columnRef = tableAlias
+        ? (col) => `${quoteIdentifier(tableAlias)}.${quoteIdentifier(col.sqlName)}`
+        : qualifyColumns
+            ? qualifiedColumnRefForTable(table)
+            : defaultColumnRef;
     const result = compileWhereNode(manifest, table, where, dialect, startParamIndex, columnRef, manifestIndex);
     const impossible = isImpossibleWhereSql(result.sql);
     return {
@@ -297,19 +333,23 @@ export function compileWhere(manifest, table, where, dialect, startParamIndex =
         ...(impossible ? { impossible: true } : {}),
     };
 }
-function whereShapeKey(where) {
+export 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))
+                .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))
+                .filter((item) => !!item &&
+                typeof item === "object" &&
+                !Array.isArray(item))
                 .map((item) => whereShapeKey(item))
                 .join(",")}`);
             continue;
@@ -332,7 +372,9 @@ function whereShapeKey(where) {
                 parts.push(`${key}:${op}:${len}`);
             }
             else {
-                parts.push(`${key}:${ops.join(",")}`);
+                const modePart = typeof value.mode === "string" ? `:mode:${value.mode}` : "";
+                const opsForKey = ops.filter((op) => op !== "mode");
+                parts.push(`${key}:${opsForKey.join(",")}${modePart}`);
             }
             continue;
         }
@@ -345,12 +387,17 @@ function collectWhereParams(manifest, table, where, dialect, manifestIndex) {
     function walk(node, columnRef) {
         const tableIndex = getTableIndex(manifestIndex, table.accessor);
         const relations = tableIndex?.effectiveRelationsByName ??
-            new Map(effectiveRelations(manifest, table).map((rel) => [rel.name, rel]));
+            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)) {
+                        if (item &&
+                            typeof item === "object" &&
+                            !Array.isArray(item)) {
                             walk(item, columnRef);
                         }
                     }
@@ -413,7 +460,9 @@ export function orderByShapeKey(orderBy, tableAlias) {
         return "";
     const entries = Object.entries(orderBy)
         .filter(([key]) => key !== "_count")
-        .map(([key, direction]) => typeof direction === "string" ? `${key}:${direction.toUpperCase()}` : "")
+        .map(([key, direction]) => typeof direction === "string"
+        ? `${key}:${direction.toUpperCase()}`
+        : "")
         .filter(Boolean)
         .sort((a, b) => a.localeCompare(b));
     if (entries.length === 0)
@@ -458,9 +507,108 @@ function buildValuePlaceholder(col, paramIndex) {
     }
     return `$${paramIndex}`;
 }
-function buildSetExpression(col, paramIndex) {
+function isBinaryValue(value) {
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(value))
+        return true;
+    return value instanceof Uint8Array;
+}
+const ATOMIC_UPDATE_OPS = new Set([
+    "increment",
+    "decrement",
+    "multiply",
+    "set",
+]);
+const NUMERIC_UPDATE_KINDS = new Set(["int", "serial", "decimal", "bigint"]);
+function isNumericUpdateKind(kind) {
+    return NUMERIC_UPDATE_KINDS.has(kind);
+}
+function needsNumericCast(col, dialect) {
+    return (col.kind === "decimal" ||
+        (dialect.name === "sqlite" && col.kind === "bigint"));
+}
+function isAtomicOp(op) {
+    return ATOMIC_UPDATE_OPS.has(op);
+}
+function arithmeticSql(op, left, right) {
+    switch (op) {
+        case "increment":
+            return `${left} + ${right}`;
+        case "decrement":
+            return `${left} - ${right}`;
+        case "multiply":
+            return `${left} * ${right}`;
+        default: {
+            const _never = op;
+            throw new Error(`unsupported atomic update: ${_never}`);
+        }
+    }
+}
+export function parseAtomicUpdate(col, value) {
+    if (!isOperatorObject(value) || isBinaryValue(value)) {
+        return { op: "set", value };
+    }
+    const keys = Object.keys(value);
+    const opKeys = keys.filter(isAtomicOp);
+    if (opKeys.length === 0) {
+        if (isNumericUpdateKind(col.kind)) {
+            throw new Error(`update on ${col.tsName} requires increment, decrement, multiply, or set`);
+        }
+        return { op: "set", value };
+    }
+    if (opKeys.length !== keys.length) {
+        throw new Error(`update on ${col.tsName} cannot mix operators with other keys`);
+    }
+    if (opKeys.length !== 1) {
+        throw new Error(`update on ${col.tsName} allows only one of increment, decrement, multiply, set`);
+    }
+    const op = opKeys[0];
+    if (op === undefined) {
+        throw new Error(`update on ${col.tsName} requires an operator`);
+    }
+    if (value[op] === undefined) {
+        throw new Error(`update ${op} on ${col.tsName} requires a value`);
+    }
+    if (op !== "set" && !isNumericUpdateKind(col.kind)) {
+        throw new Error(`${op} is not supported on ${col.kind} column ${col.tsName}`);
+    }
+    return { op, value: value[op] };
+}
+function orderUpdateAssignments(dataKeys, ops) {
+    const pairs = dataKeys.map((key, i) => ({
+        key,
+        op: ops?.[i] ?? "set",
+    }));
+    pairs.sort((a, b) => a.key.localeCompare(b.key));
+    return {
+        keys: pairs.map((pair) => pair.key),
+        ops: pairs.map((pair) => pair.op),
+    };
+}
+function buildSetExpression(col, paramIndex, op = "set", dialect = postgresDialect) {
     const sqlCol = quoteIdentifier(col?.sqlName ?? "");
-    return `${sqlCol} = ${buildValuePlaceholder(col, paramIndex)}`;
+    const placeholder = buildValuePlaceholder(col, paramIndex);
+    switch (op) {
+        case "set":
+            return `${sqlCol} = ${placeholder}`;
+        case "increment":
+        case "decrement":
+        case "multiply": {
+            if (!col) {
+                throw new Error("atomic update requires a column");
+            }
+            const left = needsNumericCast(col, dialect)
+                ? dialect.castToNumeric(sqlCol)
+                : sqlCol;
+            const right = needsNumericCast(col, dialect)
+                ? dialect.castToNumeric(placeholder)
+                : placeholder;
+            return `${sqlCol} = ${arithmeticSql(op, left, right)}`;
+        }
+        default: {
+            const _never = op;
+            throw new Error(`unsupported atomic update: ${_never}`);
+        }
+    }
 }
 export function compileOrderBy(table, orderBy, tableAlias, manifestIndex) {
     if (!orderBy || Object.keys(orderBy).length === 0)
@@ -518,10 +666,10 @@ export function buildQualifiedSelectColumns(table, select, manifestIndex) {
         : table.columns;
     return cols.map((c) => `${ref}.${selectExpression(c)}`).join(", ");
 }
-export function buildFindByIdQuery(table) {
+export function buildFindByIdQuery(table, select, manifestIndex) {
     const { sqlName } = requireScalarPrimaryKey(table);
     const sqlCol = quoteIdentifier(sqlName);
-    const selectCols = buildSelectColumns(table);
+    const selectCols = buildSelectColumns(table, select, manifestIndex);
     return `SELECT ${selectCols} FROM ${tableRef(table)} WHERE ${sqlCol} = $1`;
 }
 export function buildFindAllQuery(table) {
@@ -533,12 +681,12 @@ export function normalizeLimitOffset(value, label) {
     }
     return value;
 }
-export function buildFindManyQuery(table, whereSql, orderSql, limit, offset, distinctOn, extraSelectCols, joinClauses, manifestIndex, groupBySql) {
+export function buildFindManyQuery(table, whereSql, orderSql, take, skip, distinctOn, extraSelectCols, joinClauses, manifestIndex, groupBySql, select) {
     const hasJoins = Boolean(joinClauses && joinClauses.length > 0);
     const tableIndex = getTableIndex(manifestIndex, table.accessor);
     const selectCols = hasJoins
-        ? buildQualifiedSelectColumns(table, undefined, manifestIndex)
-        : buildSelectColumns(table, undefined, manifestIndex);
+        ? buildQualifiedSelectColumns(table, select, manifestIndex)
+        : buildSelectColumns(table, select, manifestIndex);
     let sql = "SELECT ";
     if (distinctOn && distinctOn.length > 0) {
         const distinctCols = columnsByTsNames(tableIndex, table, distinctOn)
@@ -562,23 +710,99 @@ export function buildFindManyQuery(table, whereSql, orderSql, limit, offset, dis
         sql += ` ${groupBySql}`;
     if (orderSql)
         sql += ` ${orderSql}`;
-    if (limit !== undefined) {
-        sql += ` LIMIT ${normalizeLimitOffset(limit, "limit")}`;
+    if (take !== undefined) {
+        sql += ` LIMIT ${normalizeLimitOffset(take, "take")}`;
     }
-    if (offset !== undefined) {
-        sql += ` OFFSET ${normalizeLimitOffset(offset, "offset")}`;
+    if (skip !== undefined) {
+        sql += ` OFFSET ${normalizeLimitOffset(skip, "skip")}`;
     }
     return sql;
 }
 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, dialect = postgresDialect) {
-    let sql = `SELECT ${dialect.castToInt("COUNT(*)")} AS count FROM ${tableRef(table)}`;
+export function buildCountQuery(table, whereSql, dialect = postgresDialect, distinct, select, manifestIndex) {
+    if (select !== undefined) {
+        if (distinct) {
+            throw new Error("count cannot combine distinct and select");
+        }
+        const parts = countSelectParts(table, select, dialect, manifestIndex);
+        if (parts.length === 0) {
+            throw new Error("count select requires at least one field");
+        }
+        let sql = `SELECT ${parts.join(", ")} FROM ${tableRef(table)}`;
+        if (whereSql)
+            sql += ` ${whereSql}`;
+        return sql;
+    }
+    let expr = "COUNT(*)";
+    if (distinct) {
+        const sqlCol = requireCountSqlCol(table, distinct, manifestIndex);
+        expr = `COUNT(DISTINCT ${sqlCol})`;
+    }
+    let sql = `SELECT ${dialect.castToInt(expr)} AS count FROM ${tableRef(table)}`;
+    if (whereSql)
+        sql += ` ${whereSql}`;
+    return sql;
+}
+export function buildExistsQuery(table, whereSql) {
+    let sql = `SELECT 1 FROM ${tableRef(table)}`;
     if (whereSql)
         sql += ` ${whereSql}`;
+    sql += " LIMIT 1";
     return sql;
 }
+function countSqlCol(table, tsName, manifestIndex) {
+    const tableIndex = getTableIndex(manifestIndex, table.accessor);
+    const col = columnByTsName(tableIndex, table, tsName);
+    if (!col)
+        return undefined;
+    return quoteIdentifier(col.sqlName);
+}
+export function requireCountSqlCol(table, tsName, manifestIndex) {
+    const sqlCol = countSqlCol(table, tsName, manifestIndex);
+    if (!sqlCol) {
+        throw new Error(`Unknown count column: ${tsName}`);
+    }
+    return sqlCol;
+}
+export function normalizeCountMap(select) {
+    const map = {};
+    for (const [key, value] of Object.entries(select)) {
+        if (value === true)
+            map[key] = true;
+    }
+    return map;
+}
+export function toCountSelector(value) {
+    if (value === true)
+        return true;
+    const map = normalizeCountMap(value);
+    if (Object.keys(map).length === 0) {
+        throw new Error("_count requires at least one field");
+    }
+    return map;
+}
+export function hasStarCount(selectors) {
+    return (selectors._count === true ||
+        (typeof selectors._count === "object" && selectors._count._all === true));
+}
+export function hasCountField(selectors, field) {
+    return (typeof selectors._count === "object" && selectors._count[field] === true);
+}
+export function countSelectParts(table, select, dialect = postgresDialect, manifestIndex) {
+    const parts = [];
+    if (select._all) {
+        parts.push(`${dialect.castToInt("COUNT(*)")} AS "_all"`);
+    }
+    for (const key of Object.keys(select).sort()) {
+        if (key === "_all")
+            continue;
+        const sqlCol = requireCountSqlCol(table, key, manifestIndex);
+        parts.push(`${dialect.castToInt(`COUNT(${sqlCol})`)} AS ${quoteIdentifier(key)}`);
+    }
+    return parts;
+}
 function aggregateSqlCol(table, tsName, dialect, manifestIndex) {
     const tableIndex = getTableIndex(manifestIndex, table.accessor);
     const col = columnByTsName(tableIndex, table, tsName);
@@ -589,31 +813,58 @@ function aggregateSqlCol(table, tsName, dialect, manifestIndex) {
         return dialect.castToNumeric(sqlCol);
     return sqlCol;
 }
-export function buildAggregateQuery(table, selectors, whereSql, manifestIndex, dialect = postgresDialect) {
+const FIELD_AGG_KEYS = ["_avg", "_sum", "_min", "_max"];
+function sqlFnForFieldAgg(key) {
+    switch (key) {
+        case "_avg":
+            return "AVG";
+        case "_sum":
+            return "SUM";
+        case "_min":
+            return "MIN";
+        case "_max":
+            return "MAX";
+        default: {
+            const _never = key;
+            throw new Error(`unsupported aggregate: ${_never}`);
+        }
+    }
+}
+function fieldAggExpression(key, table, colName, dialect, manifestIndex) {
+    const sqlCol = aggregateSqlCol(table, colName, dialect, manifestIndex);
+    if (!sqlCol)
+        return undefined;
+    return `${sqlFnForFieldAgg(key)}(${sqlCol})`;
+}
+export function aggregateSelectParts(table, selectors, dialect = postgresDialect, manifestIndex) {
     const parts = [];
-    if (selectors._count) {
+    if (selectors._count === true) {
         parts.push(`${dialect.castToInt("COUNT(*)")} AS "__count"`);
     }
-    for (const colName of Object.keys(selectors._avg ?? {})) {
-        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, dialect, manifestIndex);
-        if (sqlCol)
-            parts.push(`SUM(${sqlCol}) AS "_sum_${colName}"`);
-    }
-    for (const colName of Object.keys(selectors._min ?? {})) {
-        const sqlCol = aggregateSqlCol(table, colName, dialect, manifestIndex);
-        if (sqlCol)
-            parts.push(`MIN(${sqlCol}) AS "_min_${colName}"`);
+    else if (selectors._count) {
+        for (const key of Object.keys(selectors._count).sort()) {
+            if (key === "_all") {
+                parts.push(`${dialect.castToInt("COUNT(*)")} AS "__count_all"`);
+                continue;
+            }
+            const sqlCol = requireCountSqlCol(table, key, manifestIndex);
+            parts.push(`${dialect.castToInt(`COUNT(${sqlCol})`)} AS "__count_${key}"`);
+        }
     }
-    for (const colName of Object.keys(selectors._max ?? {})) {
-        const sqlCol = aggregateSqlCol(table, colName, dialect, manifestIndex);
-        if (sqlCol)
-            parts.push(`MAX(${sqlCol}) AS "_max_${colName}"`);
+    for (const key of FIELD_AGG_KEYS) {
+        const fieldMap = selectors[key];
+        if (!fieldMap)
+            continue;
+        for (const colName of Object.keys(fieldMap)) {
+            const expr = fieldAggExpression(key, table, colName, dialect, manifestIndex);
+            if (expr)
+                parts.push(`${expr} AS "${key}_${colName}"`);
+        }
     }
+    return parts;
+}
+export function buildAggregateQuery(table, selectors, whereSql, manifestIndex, dialect = postgresDialect) {
+    const parts = aggregateSelectParts(table, selectors, dialect, manifestIndex);
     if (parts.length === 0) {
         throw new Error("aggregate requires at least one selector");
     }
@@ -624,8 +875,12 @@ export function buildAggregateQuery(table, selectors, whereSql, manifestIndex, d
 }
 export function aggregateSelectorCacheKey(selectors) {
     const parts = [];
-    if (selectors._count)
+    if (selectors._count === true) {
         parts.push("_count");
+    }
+    else if (selectors._count) {
+        parts.push(`_count:${Object.keys(selectors._count).sort().join(",")}`);
+    }
     for (const key of ["_avg", "_sum", "_min", "_max"]) {
         const fieldMap = selectors[key];
         if (!fieldMap)
@@ -641,7 +896,297 @@ export function getCachedAggregateQuery(tableIndex, table, selectors, whereSql,
     }
     return getOrSetSqlCache(tableIndex.aggregateSqlBySelector, cacheKey, () => buildAggregateQuery(table, selectors, whereSql, manifestIndex, dialect));
 }
-export function buildUpsertQuery(table, insertKeys, updateKeys, conflictSqlColumns, exprSets = [], manifestIndex) {
+function isHavingOperator(op) {
+    return (op === "equals" ||
+        op === "gt" ||
+        op === "gte" ||
+        op === "lt" ||
+        op === "lte" ||
+        op === "in" ||
+        op === "notIn");
+}
+function requireStarCount(selectors, context) {
+    if (!hasStarCount(selectors)) {
+        throw new Error(`${context} requires _count: true or _count: { _all: true }`);
+    }
+}
+function requireCountMapField(selectors, field, context) {
+    if (field === "_all") {
+        requireStarCount(selectors, context);
+        return;
+    }
+    if (!hasCountField(selectors, field)) {
+        throw new Error(`${context} requires _count: { ${field}: true }`);
+    }
+}
+function isStarHavingSpec(spec) {
+    if (typeof spec === "number")
+        return true;
+    const keys = Object.keys(spec);
+    return keys.every((key) => isHavingOperator(key));
+}
+function isMixedCountHaving(spec) {
+    const keys = Object.keys(spec);
+    const hasOps = keys.some((key) => isHavingOperator(key));
+    const hasFields = keys.some((key) => !isHavingOperator(key));
+    return hasOps && hasFields;
+}
+function countStarExpr() {
+    return "COUNT(*)";
+}
+function countFieldExpr(table, field, manifestIndex) {
+    if (field === "_all")
+        return countStarExpr();
+    return `COUNT(${requireCountSqlCol(table, field, manifestIndex)})`;
+}
+function requireSelectedFieldAgg(selectors, key, colName) {
+    if (!selectors[key]?.[colName]) {
+        throw new Error(`having.${key}.${colName} requires ${key}: { ${colName}: true }`);
+    }
+}
+function compileHavingCompare(expr, spec, dialect, paramIndex) {
+    const conditions = [];
+    const params = [];
+    let nextParamIndex = paramIndex;
+    let impossible = false;
+    const ops = typeof spec === "number" ? { equals: spec } : spec;
+    for (const [op, value] of Object.entries(ops)) {
+        if (!isHavingOperator(op)) {
+            throw new Error(`unsupported having operator: ${op}`);
+        }
+        switch (op) {
+            case "in":
+            case "notIn": {
+                if (Array.isArray(value) && value.length === 0) {
+                    if (op === "in") {
+                        conditions.push("1=0");
+                        impossible = true;
+                    }
+                    else {
+                        conditions.push("1=1");
+                    }
+                    break;
+                }
+                conditions.push(dialect.whereOperators[op](expr, nextParamIndex));
+                params.push(value);
+                nextParamIndex++;
+                break;
+            }
+            case "equals":
+            case "gt":
+            case "gte":
+            case "lt":
+            case "lte": {
+                conditions.push(dialect.whereOperators[op](expr, nextParamIndex));
+                params.push(value);
+                nextParamIndex++;
+                break;
+            }
+            default: {
+                const _never = op;
+                throw new Error(`unsupported having operator: ${_never}`);
+            }
+        }
+    }
+    return {
+        sql: conditions.join(" AND "),
+        params,
+        nextParamIndex,
+        ...(impossible ? { impossible: true } : {}),
+    };
+}
+function requireFieldAggExpression(key, table, colName, dialect, manifestIndex) {
+    const expr = fieldAggExpression(key, table, colName, dialect, manifestIndex);
+    if (!expr) {
+        throw new Error(`Unknown aggregate column: ${colName}`);
+    }
+    return expr;
+}
+export function compileHaving(table, selectors, having, dialect, startParamIndex = 1, manifestIndex) {
+    if (!having || Object.keys(having).length === 0) {
+        return { sql: "", params: [] };
+    }
+    for (const key of Object.keys(having)) {
+        if (key !== "_count" &&
+            key !== "_avg" &&
+            key !== "_sum" &&
+            key !== "_min" &&
+            key !== "_max") {
+            throw new Error(`unsupported having key: ${key}`);
+        }
+    }
+    const conditions = [];
+    const params = [];
+    let paramIndex = startParamIndex;
+    let impossible = false;
+    const pushCompare = (expr, spec) => {
+        const compiled = compileHavingCompare(expr, spec, dialect, paramIndex);
+        if (compiled.sql)
+            conditions.push(compiled.sql);
+        params.push(...compiled.params);
+        paramIndex = compiled.nextParamIndex;
+        if (compiled.impossible)
+            impossible = true;
+    };
+    if (having._count !== undefined) {
+        const spec = having._count;
+        if (typeof spec === "number") {
+            requireStarCount(selectors, "having._count");
+            pushCompare(countStarExpr(), spec);
+        }
+        else if (typeof spec === "object" && spec !== null) {
+            if (isMixedCountHaving(spec)) {
+                throw new Error("having._count cannot mix comparison operators with field keys");
+            }
+            if (isStarHavingSpec(spec)) {
+                requireStarCount(selectors, "having._count");
+                pushCompare(countStarExpr(), spec);
+            }
+            else {
+                for (const [field, fieldSpec] of Object.entries(spec)) {
+                    if (typeof fieldSpec === "number") {
+                        requireCountMapField(selectors, field, `having._count.${field}`);
+                        pushCompare(countFieldExpr(table, field, manifestIndex), fieldSpec);
+                        continue;
+                    }
+                    if (typeof fieldSpec !== "object" || fieldSpec === null) {
+                        throw new Error(`invalid having._count.${field} predicate`);
+                    }
+                    requireCountMapField(selectors, field, `having._count.${field}`);
+                    pushCompare(countFieldExpr(table, field, manifestIndex), fieldSpec);
+                }
+            }
+        }
+    }
+    for (const key of FIELD_AGG_KEYS) {
+        const fieldMap = having[key];
+        if (!fieldMap)
+            continue;
+        for (const [colName, spec] of Object.entries(fieldMap)) {
+            requireSelectedFieldAgg(selectors, key, colName);
+            if (typeof spec !== "number" &&
+                (typeof spec !== "object" || spec === null)) {
+                throw new Error(`invalid having.${key}.${colName} predicate`);
+            }
+            const expr = requireFieldAggExpression(key, table, colName, dialect, manifestIndex);
+            pushCompare(expr, spec);
+        }
+    }
+    if (conditions.length === 0)
+        return { sql: "", params: [] };
+    return {
+        sql: `HAVING ${conditions.join(" AND ")}`,
+        params,
+        ...(impossible ? { impossible: true } : {}),
+    };
+}
+export function compileGroupByOrderBy(table, byKeys, selectors, orderBy, dialect = postgresDialect, manifestIndex) {
+    if (!orderBy || Object.keys(orderBy).length === 0)
+        return "";
+    const tableIndex = getTableIndex(manifestIndex, table.accessor);
+    const bySet = new Set(byKeys);
+    const parts = [];
+    for (const [tsKey, direction] of Object.entries(orderBy)) {
+        if (tsKey === "_count") {
+            if (typeof direction === "string") {
+                requireStarCount(selectors, "orderBy._count");
+                const dir = direction.toUpperCase() === "DESC" ? "DESC" : "ASC";
+                parts.push(`${countStarExpr()} ${dir}`);
+                continue;
+            }
+            if (typeof direction !== "object" || direction === null) {
+                throw new Error('orderBy._count must be "asc" or "desc" or a field map');
+            }
+            for (const [field, colDir] of Object.entries(direction)) {
+                if (typeof colDir !== "string")
+                    continue;
+                requireCountMapField(selectors, field, `orderBy._count.${field}`);
+                const dir = colDir.toUpperCase() === "DESC" ? "DESC" : "ASC";
+                parts.push(`${countFieldExpr(table, field, manifestIndex)} ${dir}`);
+            }
+            continue;
+        }
+        if (tsKey === "_avg" ||
+            tsKey === "_sum" ||
+            tsKey === "_min" ||
+            tsKey === "_max") {
+            const key = tsKey;
+            if (typeof direction !== "object" || direction === null) {
+                throw new Error(`orderBy.${key} must be a column map`);
+            }
+            for (const [colName, colDir] of Object.entries(direction)) {
+                if (typeof colDir !== "string")
+                    continue;
+                if (!selectors[key]?.[colName]) {
+                    throw new Error(`orderBy.${key}.${colName} requires ${key}: { ${colName}: true }`);
+                }
+                const expr = requireFieldAggExpression(key, table, colName, dialect, manifestIndex);
+                const dir = colDir.toUpperCase() === "DESC" ? "DESC" : "ASC";
+                parts.push(`${expr} ${dir}`);
+            }
+            continue;
+        }
+        if (typeof direction !== "string")
+            continue;
+        if (!bySet.has(tsKey)) {
+            throw new Error(`orderBy column "${tsKey}" is not in groupBy by`);
+        }
+        const col = columnByTsName(tableIndex, table, tsKey);
+        if (!col) {
+            throw new Error(`Unknown groupBy column: ${tsKey}`);
+        }
+        const dir = direction.toUpperCase() === "DESC" ? "DESC" : "ASC";
+        parts.push(`${quoteIdentifier(col.sqlName)} ${dir}`);
+    }
+    return parts.length > 0 ? `ORDER BY ${parts.join(", ")}` : "";
+}
+export function resolveGroupByColumns(table, byKeys, manifestIndex) {
+    if (byKeys.length === 0) {
+        throw new Error("groupBy requires at least one column");
+    }
+    const tableIndex = getTableIndex(manifestIndex, table.accessor);
+    const cols = [];
+    for (const key of byKeys) {
+        const col = columnByTsName(tableIndex, table, key);
+        if (!col) {
+            throw new Error(`Unknown groupBy column: ${key}`);
+        }
+        cols.push(col);
+    }
+    return cols;
+}
+export function buildGroupByQuery(table, byKeys, selectors, whereSql, havingSql, orderSql, take, skip, manifestIndex, dialect = postgresDialect) {
+    const byCols = resolveGroupByColumns(table, byKeys, manifestIndex);
+    const selectBy = buildSelectColumns(table, byKeys, manifestIndex);
+    const aggParts = aggregateSelectParts(table, selectors, dialect, manifestIndex);
+    const selectList = aggParts.length > 0 ? `${selectBy}, ${aggParts.join(", ")}` : selectBy;
+    const groupList = byCols
+        .map((col) => quoteIdentifier(col.sqlName))
+        .join(", ");
+    let sql = `SELECT ${selectList} FROM ${tableRef(table)}`;
+    if (whereSql)
+        sql += ` ${whereSql}`;
+    sql += ` GROUP BY ${groupList}`;
+    if (havingSql)
+        sql += ` ${havingSql}`;
+    if (orderSql)
+        sql += ` ${orderSql}`;
+    if (take !== undefined) {
+        sql += ` LIMIT ${normalizeLimitOffset(take, "take")}`;
+    }
+    if (skip !== undefined) {
+        sql += ` OFFSET ${normalizeLimitOffset(skip, "skip")}`;
+    }
+    return sql;
+}
+export function getCachedGroupByQuery(tableIndex, table, byKeys, selectors, whereSql, havingSql, orderSql, take, skip, manifestIndex, dialect = postgresDialect) {
+    const cacheKey = `${dialect.name}|${byKeys.join(",")}|${aggregateSelectorCacheKey(selectors)}|${whereSql}|${havingSql}|${orderSql}|${take ?? ""}|${skip ?? ""}`;
+    if (!tableIndex) {
+        return buildGroupByQuery(table, byKeys, selectors, whereSql, havingSql, orderSql, take, skip, manifestIndex, dialect);
+    }
+    return getOrSetSqlCache(tableIndex.groupBySqlBySignature, cacheKey, () => buildGroupByQuery(table, byKeys, selectors, whereSql, havingSql, orderSql, take, skip, manifestIndex, dialect));
+}
+export function buildUpsertQuery(table, insertKeys, updateKeys, conflictSqlColumns, exprSets = [], manifestIndex, dialect = postgresDialect, updateOps) {
     const insertCols = insertKeys.map((k) => {
         const col = colByTs(table, k, manifestIndex);
         return quoteIdentifier(col?.sqlName ?? k);
@@ -656,11 +1201,18 @@ export function buildUpsertQuery(table, insertKeys, updateKeys, conflictSqlColum
     const conflictCols = conflictSqlColumns
         .map((c) => quoteIdentifier(c))
         .join(", ");
+    let nextParam = insertKeys.length + 1;
     const updateSets = updateKeys.length > 0
-        ? updateKeys.map((k) => {
+        ? updateKeys.map((k, i) => {
             const col = colByTs(table, k, manifestIndex);
             const sqlCol = quoteIdentifier(col?.sqlName ?? k);
-            return `${sqlCol} = excluded.${sqlCol}`;
+            const op = updateOps?.[i] ?? "set";
+            if (op === "set") {
+                return `${sqlCol} = excluded.${sqlCol}`;
+            }
+            const expr = buildSetExpression(col, nextParam, op, dialect);
+            nextParam++;
+            return expr;
         })
         : exprSets.length === 0
             ? conflictSqlColumns.map((c) => {
@@ -728,7 +1280,7 @@ export function buildInsertQuery(table, dataKeys, manifestIndex, returning = "pk
         return buildValuePlaceholder(col, i + 1);
     })
         .join(", ");
-    let sql = `INSERT INTO ${tableRef(table)} (${cols.join(", ")}) VALUES (${placeholders})`;
+    const sql = `INSERT INTO ${tableRef(table)} (${cols.join(", ")}) VALUES (${placeholders})`;
     if (returning === "none")
         return sql;
     const effectiveReturning = resolveReturning(table, returning);
@@ -774,7 +1326,7 @@ export function buildInsertManyValueRows(table, dataKeys, rows, manifestIndex) {
     }
     return { valueRows, values };
 }
-export function buildInsertManyQuery(table, dataKeys, valueRows, manifestIndex) {
+export function buildInsertManyQuery(table, dataKeys, valueRows, manifestIndex, skipDuplicates = false, dialect = postgresDialect) {
     if (dataKeys.length === 0) {
         throw new Error("Cannot build INSERT many query with no columns");
     }
@@ -783,16 +1335,18 @@ export function buildInsertManyQuery(table, dataKeys, valueRows, manifestIndex)
         return quoteIdentifier(col?.sqlName ?? k);
     });
     const selectCols = buildSelectColumns(table, undefined, manifestIndex);
-    return `INSERT INTO ${tableRef(table)} (${cols.join(", ")}) VALUES ${valueRows.join(", ")} RETURNING ${selectCols}`;
+    const conflict = skipDuplicates ? ` ${dialect.onConflictDoNothing()}` : "";
+    return `INSERT INTO ${tableRef(table)} (${cols.join(", ")}) VALUES ${valueRows.join(", ")}${conflict} RETURNING ${selectCols}`;
 }
-export function buildUpdateQuery(table, dataKeys, whereSql, exprSets = [], manifestIndex, returning = "full") {
-    const orderedKeys = [...dataKeys].sort();
-    const paramSets = orderedKeys.map((k, i) => {
+export function buildUpdateQuery(table, dataKeys, whereSql, exprSets = [], manifestIndex, returning = "full", dialect = postgresDialect, ops) {
+    const ordered = orderUpdateAssignments(dataKeys, ops);
+    const paramSets = ordered.keys.map((k, i) => {
         const col = colByTs(table, k, manifestIndex);
-        return buildSetExpression(col, i + 1);
+        const op = ordered.ops[i] ?? "set";
+        return buildSetExpression(col, i + 1, op, dialect);
     });
     const sets = [...paramSets, ...exprSets];
-    const whereOffset = orderedKeys.length;
+    const whereOffset = ordered.keys.length;
     let sql = `UPDATE ${tableRef(table)} SET ${sets.join(", ")}`;
     if (whereSql) {
         const adjustedWhere = rebaseParamRefs(whereSql, whereOffset);
@@ -832,14 +1386,15 @@ export function buildDeleteManyQuery(table, whereSql) {
         sql += ` ${whereSql}`;
     return sql;
 }
-export function buildUpdateManyQuery(table, dataKeys, whereSql, exprSets = [], manifestIndex) {
-    const orderedKeys = [...dataKeys].sort();
-    const paramSets = orderedKeys.map((k, i) => {
+export function buildUpdateManyQuery(table, dataKeys, whereSql, exprSets = [], manifestIndex, dialect = postgresDialect, ops) {
+    const ordered = orderUpdateAssignments(dataKeys, ops);
+    const paramSets = ordered.keys.map((k, i) => {
         const col = colByTs(table, k, manifestIndex);
-        return buildSetExpression(col, i + 1);
+        const op = ordered.ops[i] ?? "set";
+        return buildSetExpression(col, i + 1, op, dialect);
     });
     const sets = [...paramSets, ...exprSets];
-    const whereOffset = orderedKeys.length;
+    const whereOffset = ordered.keys.length;
     let sql = `UPDATE ${tableRef(table)} SET ${sets.join(", ")}`;
     if (whereSql) {
         const adjustedWhere = rebaseParamRefs(whereSql, whereOffset);
@@ -847,13 +1402,16 @@ export function buildUpdateManyQuery(table, dataKeys, whereSql, exprSets = [], m
     }
     return sql;
 }
-export function getCachedUpdateManyQuery(tableIndex, table, dataKeys, whereSql, exprSets, manifestIndex) {
-    const orderedKeys = [...dataKeys].sort();
-    const cacheKey = `${sortedKeysCacheKey(orderedKeys)}|${exprSets.length}|${whereSql}`;
+export function getCachedUpdateManyQuery(tableIndex, table, dataKeys, whereSql, exprSets, manifestIndex, dialect = postgresDialect, ops) {
+    const ordered = orderUpdateAssignments(dataKeys, ops);
+    const opKey = ordered.keys
+        .map((key, i) => `${key}:${ordered.ops[i] ?? "set"}`)
+        .join(",");
+    const cacheKey = `${dialect.name}|${opKey}|${exprSets.length}|${whereSql}`;
     if (!tableIndex) {
-        return buildUpdateManyQuery(table, orderedKeys, whereSql, exprSets, manifestIndex);
+        return buildUpdateManyQuery(table, ordered.keys, whereSql, exprSets, manifestIndex, dialect, ordered.ops);
     }
-    return getOrSetSqlCache(tableIndex.updateManySqlByKeys, cacheKey, () => buildUpdateManyQuery(table, orderedKeys, whereSql, exprSets, manifestIndex));
+    return getOrSetSqlCache(tableIndex.updateManySqlByKeys, cacheKey, () => buildUpdateManyQuery(table, ordered.keys, whereSql, exprSets, manifestIndex, dialect, ordered.ops));
 }
 export function getCachedFindManyQuery(tableIndex, signature, build) {
     if (!tableIndex)
@@ -877,6 +1435,46 @@ export function dataToSqlValues(table, data, options, manifestIndex, dialect = p
     }
     return reorderKeyValues(keys, values);
 }
+export function dataToUpdateAssignments(table, data, options, manifestIndex, dialect = postgresDialect) {
+    const tableIndex = getTableIndex(manifestIndex, table.accessor);
+    const keys = [];
+    const ops = [];
+    const values = [];
+    for (const [key, raw] of Object.entries(data)) {
+        const col = columnByTsName(tableIndex, table, key);
+        if (!col)
+            continue;
+        if (options?.excludePrimary && col.primary)
+            continue;
+        if (raw === undefined)
+            continue;
+        const parsed = parseAtomicUpdate(col, raw);
+        keys.push(key);
+        ops.push(parsed.op);
+        values.push(serializeColumnValue(col, parsed.value, dialect));
+    }
+    if (keys.length <= 1)
+        return { keys, ops, values };
+    const pairs = keys.map((key, index) => ({
+        key,
+        op: ops[index] ?? "set",
+        value: values[index],
+    }));
+    pairs.sort((a, b) => a.key.localeCompare(b.key));
+    return {
+        keys: pairs.map((pair) => pair.key),
+        ops: pairs.map((pair) => pair.op),
+        values: pairs.map((pair) => pair.value),
+    };
+}
+export function upsertAtomicValues(ops, values) {
+    const extra = [];
+    for (let i = 0; i < ops.length; i++) {
+        if (ops[i] !== "set")
+            extra.push(values[i]);
+    }
+    return extra;
+}
 export function rowToTs(table, row) {
     const result = {};
     for (const col of table.columns) {