neoorm 0.3.0 → 0.4.0

package/dist/runtime/query/relation-planner.js

@@ -0,0 +1,648 @@
+import { quoteIdentifier, tableRef, } from "../../dialect/postgres.js";
+import { buildQualifiedSelectColumns, buildSelectColumns, compileOrderBy, compileWhere, mapRowToTs, normalizeLimitOffset, normalizeSelectColumns, orderByShapeKey, } from "./compile.js";
+import { findM2M, findRelation, tableOwnsFkColumn, } from "./manifest-lookup.js";
+import { requireScalarPrimaryKey, targetRelationPkSql, } from "./primary-key.js";
+import { columnsByTsNames, getOrSetSqlCache, getTableIndex, } from "./table-index.js";
+function relationPlanCacheKey(withSpec, dialect, options) {
+    const useHasManyAggregate = options?.useHasManyAggregate !== false;
+    return `${dialect.name}|${withShapeSignature(withSpec)}|${useHasManyAggregate ? "agg" : "corr"}`;
+}
+export function inlineRelationColumnAlias(relationName) {
+    return `__neoorm_${relationName}`;
+}
+export function inlineCountColumnAlias(relationName) {
+    return `__neoorm_count_${relationName}`;
+}
+function splitWithSpec(withSpec) {
+    const relationWith = {};
+    let countSpec;
+    for (const [key, value] of Object.entries(withSpec)) {
+        if (key === "_count") {
+            countSpec = value;
+            continue;
+        }
+        relationWith[key] = value;
+    }
+    const result = { relationWith };
+    if (countSpec)
+        result.countSpec = countSpec;
+    return result;
+}
+function toInlineSpec(withInput) {
+    return typeof withInput === "object" ? withInput : undefined;
+}
+function parentPkRef(parentTable) {
+    const { sqlName } = requireScalarPrimaryKey(parentTable);
+    return `${tableRef(parentTable)}.${quoteIdentifier(sqlName)}`;
+}
+function parentPkRefForAlias(parentTable, parentAlias) {
+    const { sqlName } = requireScalarPrimaryKey(parentTable);
+    return `${quoteIdentifier(parentAlias)}.${quoteIdentifier(sqlName)}`;
+}
+function columnsForInlineSelect(table, nestedSpec, manifestIndex) {
+    const selectKeys = normalizeSelectColumns(nestedSpec?.select);
+    if (!selectKeys || selectKeys.length === 0)
+        return table.columns;
+    return columnsByTsNames(getTableIndex(manifestIndex, table.accessor), table, selectKeys);
+}
+function tryBuildInlineChainNode(manifest, parentTable, relationName, withInput) {
+    if (findM2M(manifest, parentTable.accessor, relationName))
+        return null;
+    const relation = findRelation(parentTable, relationName);
+    if (!relation)
+        return null;
+    const targetTable = manifest.tables[relation.targetAccessor];
+    if (!targetTable)
+        return null;
+    const nestedSpec = toInlineSpec(withInput);
+    const nestedWith = nestedSpec?.with;
+    if (relation.cardinality === "many") {
+        if (tableOwnsFkColumn(parentTable, relation))
+            return null;
+        if (nestedWith && Object.keys(nestedWith).length > 0) {
+            const nestedEntries = Object.entries(nestedWith);
+            if (nestedEntries.length !== 1)
+                return null;
+            const [childName, childInput] = nestedEntries[0];
+            const childChain = tryBuildInlineChainNode(manifest, targetTable, childName, childInput);
+            if (!childChain)
+                return null;
+            const node = {
+                relationName,
+                relation,
+                targetTable,
+                child: childChain,
+            };
+            if (nestedSpec)
+                node.nestedSpec = nestedSpec;
+            return node;
+        }
+        const node = {
+            relationName,
+            relation,
+            targetTable,
+        };
+        if (nestedSpec)
+            node.nestedSpec = nestedSpec;
+        return node;
+    }
+    if (relation.cardinality === "one" &&
+        tableOwnsFkColumn(parentTable, relation)) {
+        if (nestedWith && Object.keys(nestedWith).length > 0)
+            return null;
+        const node = {
+            relationName,
+            relation,
+            targetTable,
+        };
+        if (nestedSpec)
+            node.nestedSpec = nestedSpec;
+        return node;
+    }
+    return null;
+}
+function canInlineCount(manifest, parentTable, relationName) {
+    if (findM2M(manifest, parentTable.accessor, relationName))
+        return false;
+    const relation = findRelation(parentTable, relationName);
+    return relation?.cardinality === "many";
+}
+function isSimpleCountSpec(spec) {
+    return (spec === true ||
+        (typeof spec === "object" && spec.where === undefined));
+}
+function tryBuildCountAggregatePlan(manifest, parentTable, countSpec, dialect, manifestIndex) {
+    for (const spec of Object.values(countSpec)) {
+        if (!isSimpleCountSpec(spec))
+            return undefined;
+    }
+    const parentRef = tableRef(parentTable);
+    const parentTableIndex = getTableIndex(manifestIndex, parentTable.accessor);
+    const groupByCols = parentTable.columns.map((col) => `${parentRef}.${quoteIdentifier(col.sqlName)}`);
+    const joins = [];
+    const selectCols = [];
+    const inlineCounts = [];
+    for (const [relationName, spec] of Object.entries(countSpec)) {
+        if (!canInlineCount(manifest, parentTable, relationName)) {
+            return undefined;
+        }
+        const relation = findRelation(parentTable, relationName, parentTableIndex);
+        if (!relation)
+            return undefined;
+        const targetTable = manifest.tables[relation.targetAccessor];
+        if (!targetTable)
+            return undefined;
+        const targetAlias = `_cnt_${relationName}`;
+        const fkCol = quoteIdentifier(relation.fkSqlColumn);
+        const parentPkCol = quoteIdentifier(requireScalarPrimaryKey(parentTable).sqlName);
+        const targetPkCol = quoteIdentifier(targetRelationPkSql(targetTable, relation));
+        joins.push(`LEFT JOIN ${tableRef(targetTable)} AS ${quoteIdentifier(targetAlias)} ON ${quoteIdentifier(targetAlias)}.${fkCol} = ${parentRef}.${parentPkCol}`);
+        selectCols.push(`${dialect.castToInt(`COUNT(${quoteIdentifier(targetAlias)}.${targetPkCol})`)} AS ${quoteIdentifier(inlineCountColumnAlias(relationName))}`);
+        inlineCounts.push({ relationName, spec });
+    }
+    return { joins, selectCols, groupByCols, inlineCounts };
+}
+function canHasManyAggregate(manifest, parentTable, chain) {
+    if (findM2M(manifest, parentTable.accessor, chain.relationName)) {
+        return false;
+    }
+    if (chain.child)
+        return false;
+    if (tableOwnsFkColumn(parentTable, chain.relation))
+        return false;
+    const spec = chain.nestedSpec;
+    if (spec?.with && Object.keys(spec.with).length > 0)
+        return false;
+    if (spec?.orderBy)
+        return false;
+    if (spec?.limit !== undefined)
+        return false;
+    return true;
+}
+function groupByExpressionsFromJoinSelectCols(selectCols) {
+    return selectCols.map((col) => {
+        const asIdx = col.search(/\s+AS\s+/i);
+        return asIdx >= 0 ? col.slice(0, asIdx).trim() : col;
+    });
+}
+function tryBuildHasManyAggregatePlan(manifest, parentTable, chains, toOneJoins, dialect, manifestIndex) {
+    if (chains.length === 0)
+        return undefined;
+    const parentRef = tableRef(parentTable);
+    const parentTableIndex = getTableIndex(manifestIndex, parentTable.accessor);
+    const parentPkCol = quoteIdentifier(requireScalarPrimaryKey(parentTable).sqlName);
+    const groupByCols = parentTable.columns.map((col) => `${parentRef}.${quoteIdentifier(col.sqlName)}`);
+    groupByCols.push(...groupByExpressionsFromJoinSelectCols(toOneJoins.selectCols));
+    const joins = [...toOneJoins.joins];
+    const selectCols = [];
+    for (const { relationName, chain } of chains) {
+        const relation = findRelation(parentTable, relationName, parentTableIndex);
+        if (!relation)
+            return undefined;
+        const targetTable = manifest.tables[relation.targetAccessor];
+        if (!targetTable)
+            return undefined;
+        const targetAlias = `_hm_${relationName}`;
+        const fkCol = quoteIdentifier(relation.fkSqlColumn);
+        const targetPkCol = quoteIdentifier(targetRelationPkSql(targetTable, relation));
+        joins.push(`LEFT JOIN ${tableRef(targetTable)} AS ${quoteIdentifier(targetAlias)} ON ${quoteIdentifier(targetAlias)}.${fkCol} = ${parentRef}.${parentPkCol}`);
+        const rowExpr = buildHasManyRowExpression(chain, targetAlias, dialect, manifestIndex);
+        selectCols.push(`COALESCE(${dialect.jsonAggExpr(rowExpr)} FILTER (WHERE ${quoteIdentifier(targetAlias)}.${targetPkCol} IS NOT NULL), '[]') AS ${quoteIdentifier(inlineRelationColumnAlias(relationName))}`);
+    }
+    return { joins, selectCols, groupByCols, inlineJsonAgg: chains };
+}
+function buildJoinClauses(manifest, parentTable, withSpec, manifestIndex) {
+    const joins = [];
+    const selectCols = [];
+    const joinedRelations = new Set();
+    const parentTableIndex = getTableIndex(manifestIndex, parentTable.accessor);
+    for (const [relationName, spec] of Object.entries(withSpec)) {
+        const relation = findRelation(parentTable, relationName, parentTableIndex);
+        if (!relation)
+            continue;
+        if (relation.cardinality !== "one")
+            continue;
+        if (!tableOwnsFkColumn(parentTable, relation, parentTableIndex))
+            continue;
+        if (findM2M(manifest, parentTable.accessor, relationName))
+            continue;
+        const nestedSpec = toInlineSpec(spec);
+        if (nestedSpec?.with)
+            continue;
+        const targetTable = manifest.tables[relation.targetAccessor];
+        if (!targetTable)
+            continue;
+        const alias = `__${relationName}`;
+        const parentFkCol = quoteIdentifier(relation.fkSqlColumn);
+        const targetPkCol = quoteIdentifier(targetRelationPkSql(targetTable, relation));
+        const onClause = `${quoteIdentifier(alias)}.${targetPkCol} = ${tableRef(parentTable)}.${parentFkCol}`;
+        joins.push(`LEFT JOIN ${tableRef(targetTable)} AS ${quoteIdentifier(alias)} ON ${onClause}`);
+        const targetTableIndex = getTableIndex(manifestIndex, targetTable.accessor);
+        const selectKeys = nestedSpec?.select
+            ? normalizeSelectColumns(nestedSpec.select)
+            : undefined;
+        const targetCols = selectKeys && selectKeys.length > 0
+            ? columnsByTsNames(targetTableIndex, targetTable, selectKeys)
+            : targetTable.columns;
+        for (const col of targetCols) {
+            const prefixedName = `__${relationName}__${col.sqlName}`;
+            selectCols.push(`${quoteIdentifier(alias)}.${quoteIdentifier(col.sqlName)} AS ${quoteIdentifier(prefixedName)}`);
+        }
+        joinedRelations.add(relationName);
+    }
+    return { joins, selectCols, joinedRelations };
+}
+function buildToOneScalarSubquery(node, parentRowAlias, dialect, manifestIndex) {
+    const { relation, targetTable } = node;
+    const targetAlias = `${parentRowAlias}_rel`;
+    const targetPkCol = quoteIdentifier(targetRelationPkSql(targetTable, relation));
+    const parentFkCol = quoteIdentifier(relation.fkSqlColumn);
+    const cols = columnsForInlineSelect(targetTable, node.nestedSpec, manifestIndex);
+    const refs = cols.map((col) => `${quoteIdentifier(targetAlias)}.${quoteIdentifier(col.sqlName)}`);
+    const selectList = refs.join(", ");
+    const outerRefs = cols.map((col) => `sub.${quoteIdentifier(col.sqlName)}`);
+    return `(SELECT ${dialect.rowToJsonObject(cols, outerRefs, "sub")} FROM (SELECT ${selectList} FROM ${tableRef(targetTable)} ${quoteIdentifier(targetAlias)} WHERE ${quoteIdentifier(targetAlias)}.${targetPkCol} = ${quoteIdentifier(parentRowAlias)}.${parentFkCol} LIMIT 1) sub)`;
+}
+function buildHasManyRowExpression(node, rowAlias, dialect, manifestIndex) {
+    if (node.child) {
+        const cols = columnsForInlineSelect(node.targetTable, node.nestedSpec, manifestIndex);
+        const entries = cols.map((col) => `'${col.sqlName}', ${quoteIdentifier(rowAlias)}.${quoteIdentifier(col.sqlName)}`);
+        const nested = buildChildAggregationExpr(node.child, rowAlias, node.targetTable, dialect, manifestIndex);
+        entries.push(`'${node.child.relationName}', ${nested}`);
+        return dialect.jsonBuildObjectExpr(entries);
+    }
+    const cols = columnsForInlineSelect(node.targetTable, undefined, manifestIndex);
+    const refs = cols.map((col) => `${quoteIdentifier(rowAlias)}.${quoteIdentifier(col.sqlName)}`);
+    return dialect.rowToJsonObject(cols, refs, `${quoteIdentifier(rowAlias)}.*`);
+}
+function buildHasManySubqueryFromRef(node, parentTable, parentCorrelationRef, dialect, manifestIndex) {
+    const childAlias = `_r_${node.relationName}`;
+    const fkCol = quoteIdentifier(node.relation.fkSqlColumn);
+    const rowExpr = buildHasManyRowExpression(node, childAlias, dialect, manifestIndex);
+    let sql = `(SELECT ${dialect.jsonAggExpr("agg_row")} FROM (SELECT ${rowExpr} AS agg_row FROM ${tableRef(node.targetTable)} ${quoteIdentifier(childAlias)} WHERE ${quoteIdentifier(childAlias)}.${fkCol} = ${parentCorrelationRef}`;
+    if (node.nestedSpec?.orderBy) {
+        sql += ` ${compileOrderBy(node.targetTable, node.nestedSpec.orderBy, childAlias, manifestIndex)}`;
+    }
+    if (node.nestedSpec?.limit !== undefined) {
+        sql += ` LIMIT ${normalizeLimitOffset(node.nestedSpec.limit, "limit")}`;
+    }
+    sql += ") agg)";
+    return sql;
+}
+function buildChildAggregationExpr(node, parentRowAlias, parentTable, dialect, manifestIndex) {
+    const parentTableIndex = getTableIndex(manifestIndex, parentTable.accessor);
+    if (node.relation.cardinality === "one" &&
+        tableOwnsFkColumn(parentTable, node.relation, parentTableIndex)) {
+        return buildToOneScalarSubquery(node, parentRowAlias, dialect, manifestIndex);
+    }
+    if (node.relation.cardinality === "many" &&
+        !tableOwnsFkColumn(parentTable, node.relation, parentTableIndex)) {
+        const parentRef = parentPkRefForAlias(parentTable, parentRowAlias);
+        return buildHasManySubqueryFromRef(node, parentTable, parentRef, dialect, manifestIndex);
+    }
+    throw new Error(`Unsupported inline relation chain node: ${node.relationName}`);
+}
+export function buildInlineJsonAggSelectCol(parentTable, chain, dialect, manifestIndex) {
+    const parentRef = parentPkRef(parentTable);
+    const subquery = buildHasManySubqueryFromRef(chain, parentTable, parentRef, dialect, manifestIndex);
+    const alias = quoteIdentifier(inlineRelationColumnAlias(chain.relationName));
+    return `${subquery} AS ${alias}`;
+}
+export function buildInlineCountSelectCol(manifest, parentTable, relationName, spec, dialect, manifestIndex) {
+    const parentTableIndex = getTableIndex(manifestIndex, parentTable.accessor);
+    const relation = findRelation(parentTable, relationName, parentTableIndex);
+    if (!relation || relation.cardinality !== "many") {
+        throw new Error(`Cannot inline count for relation: ${relationName}`);
+    }
+    const targetTable = manifest.tables[relation.targetAccessor];
+    if (!targetTable) {
+        throw new Error(`Unknown target table for relation: ${relationName}`);
+    }
+    const parentRef = parentPkRef(parentTable);
+    const targetAlias = `_cnt_${relationName}`;
+    const fkCol = quoteIdentifier(relation.fkSqlColumn);
+    const whereFilter = typeof spec === "object" ? spec.where : undefined;
+    let extraWhere = "";
+    if (whereFilter) {
+        const compiled = compileWhere(manifest, targetTable, whereFilter, dialect, 1, manifestIndex);
+        if (compiled.sql) {
+            const adjusted = compiled.sql.replace(/^WHERE\s+/i, "");
+            extraWhere = ` AND ${adjusted}`;
+        }
+    }
+    const subquery = `(SELECT ${dialect.castToInt("COUNT(*)")} FROM ${tableRef(targetTable)} ${quoteIdentifier(targetAlias)} WHERE ${quoteIdentifier(targetAlias)}.${fkCol} = ${parentRef}${extraWhere})`;
+    const alias = quoteIdentifier(inlineCountColumnAlias(relationName));
+    return `${subquery} AS ${alias}`;
+}
+export function planRelationLoad(manifest, parentTable, withSpec, dialect, manifestIndex, options) {
+    const emptyPlan = {
+        joins: [],
+        joinSelectCols: [],
+        joinedRelations: new Set(),
+        inlineJsonAgg: [],
+        inlineCounts: [],
+        batchWith: {},
+    };
+    if (!withSpec)
+        return emptyPlan;
+    const parentTableIndex = getTableIndex(manifestIndex, parentTable.accessor);
+    const { relationWith, countSpec } = splitWithSpec(withSpec);
+    const joinCandidates = {};
+    const batchWith = {};
+    const pendingHasMany = [];
+    const inlineJsonAgg = [];
+    const inlineCounts = [];
+    const batchCounts = {};
+    for (const [relationName, withInput] of Object.entries(relationWith)) {
+        const chain = tryBuildInlineChainNode(manifest, parentTable, relationName, withInput);
+        if (chain &&
+            chain.relation.cardinality === "many" &&
+            !tableOwnsFkColumn(parentTable, chain.relation, parentTableIndex)) {
+            pendingHasMany.push({ relationName, chain });
+            continue;
+        }
+        const relation = findRelation(parentTable, relationName, parentTableIndex);
+        if (relation?.cardinality === "one" &&
+            tableOwnsFkColumn(parentTable, relation, parentTableIndex) &&
+            !findM2M(manifest, parentTable.accessor, relationName) &&
+            !toInlineSpec(withInput)?.with) {
+            joinCandidates[relationName] = withInput;
+            continue;
+        }
+        batchWith[relationName] = withInput;
+    }
+    const aggregateChains = [];
+    for (const item of pendingHasMany) {
+        if (canHasManyAggregate(manifest, parentTable, item.chain)) {
+            aggregateChains.push(item);
+        }
+        else {
+            inlineJsonAgg.push(item);
+        }
+    }
+    const { joins, selectCols, joinedRelations } = buildJoinClauses(manifest, parentTable, joinCandidates, manifestIndex);
+    let hasManyAggregate;
+    const useHasManyAggregate = options?.useHasManyAggregate !== false;
+    if (useHasManyAggregate &&
+        aggregateChains.length > 0 &&
+        aggregateChains.length === pendingHasMany.length) {
+        hasManyAggregate = tryBuildHasManyAggregatePlan(manifest, parentTable, aggregateChains, { joins, selectCols, joinedRelations }, dialect, manifestIndex);
+    }
+    else {
+        inlineJsonAgg.push(...aggregateChains);
+    }
+    if (countSpec) {
+        const canAggregate = Object.keys(relationWith).length === 0 &&
+            pendingHasMany.length === 0 &&
+            Object.keys(joinCandidates).length === 0;
+        if (canAggregate) {
+            const aggregatePlan = tryBuildCountAggregatePlan(manifest, parentTable, countSpec, dialect, manifestIndex);
+            if (aggregatePlan) {
+                return {
+                    joins: aggregatePlan.joins,
+                    joinSelectCols: [],
+                    joinedRelations: new Set(),
+                    inlineJsonAgg: [],
+                    inlineCounts: aggregatePlan.inlineCounts,
+                    batchWith: {},
+                    countAggregate: aggregatePlan,
+                };
+            }
+        }
+        for (const [relationName, spec] of Object.entries(countSpec)) {
+            if (canInlineCount(manifest, parentTable, relationName)) {
+                inlineCounts.push({ relationName, spec });
+            }
+            else {
+                batchCounts[relationName] = spec;
+            }
+        }
+    }
+    if (Object.keys(batchCounts).length > 0) {
+        batchWith._count = batchCounts;
+    }
+    if (hasManyAggregate) {
+        return {
+            joins: [],
+            joinSelectCols: selectCols,
+            joinedRelations,
+            inlineJsonAgg: hasManyAggregate.inlineJsonAgg,
+            inlineCounts,
+            batchWith,
+            hasManyAggregate,
+        };
+    }
+    return {
+        joins,
+        joinSelectCols: selectCols,
+        joinedRelations,
+        inlineJsonAgg,
+        inlineCounts,
+        batchWith,
+    };
+}
+function extractJoinedRelations(row, manifest, parentTable, joinedRelations, manifestIndex) {
+    const relations = {};
+    for (const relationName of joinedRelations) {
+        const relation = findRelation(parentTable, relationName);
+        if (!relation)
+            continue;
+        const targetTable = manifest.tables[relation.targetAccessor];
+        if (!targetTable)
+            continue;
+        const prefix = `__${relationName}__`;
+        const prefixedKeys = Object.keys(row).filter((k) => k.startsWith(prefix));
+        if (prefixedKeys.length === 0)
+            continue;
+        const allNull = prefixedKeys.every((k) => row[k] == null);
+        if (allNull) {
+            relations[relationName] = null;
+        }
+        else {
+            const raw = {};
+            for (const key of prefixedKeys) {
+                raw[key.slice(prefix.length)] = row[key];
+            }
+            const targetIndex = getTableIndex(manifestIndex, targetTable.accessor);
+            relations[relationName] = mapRowToTs(targetIndex, targetTable, raw);
+        }
+    }
+    return relations;
+}
+function parseJsonValue(value) {
+    if (typeof value === "string") {
+        return JSON.parse(value);
+    }
+    return value;
+}
+function hydrateInlineChainValue(runtime, node, value) {
+    if (value == null) {
+        return node.relation.cardinality === "many" ? [] : null;
+    }
+    const targetIndex = getTableIndex(runtime.tableIndex, node.targetTable.accessor);
+    if (node.relation.cardinality === "many") {
+        const parsed = parseJsonValue(value);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.map((row) => {
+            const childRow = row;
+            const mapped = mapRowToTs(targetIndex, node.targetTable, childRow);
+            if (node.child) {
+                const nestedVal = childRow[node.child.relationName];
+                mapped[node.child.relationName] = hydrateInlineChainValue(runtime, node.child, nestedVal);
+            }
+            return mapped;
+        });
+    }
+    const parsed = parseJsonValue(value);
+    if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return null;
+    }
+    return mapRowToTs(targetIndex, node.targetTable, parsed);
+}
+export function hydrateRowsWithPlan(runtime, parentTable, rawRows, plan) {
+    const { manifest } = runtime;
+    const tableIndex = getTableIndex(runtime.tableIndex, parentTable.accessor);
+    return rawRows.map((rawRow) => {
+        const joined = plan.joinedRelations.size > 0
+            ? extractJoinedRelations(rawRow, manifest, parentTable, plan.joinedRelations, runtime.tableIndex)
+            : {};
+        const parent = mapRowToTs(tableIndex, parentTable, rawRow);
+        const row = { ...parent, ...joined };
+        for (const inline of plan.inlineJsonAgg) {
+            const alias = inlineRelationColumnAlias(inline.relationName);
+            row[inline.relationName] = hydrateInlineChainValue(runtime, inline.chain, rawRow[alias]);
+        }
+        if (plan.inlineCounts.length > 0) {
+            const countBucket = {};
+            for (const countPlan of plan.inlineCounts) {
+                const alias = inlineCountColumnAlias(countPlan.relationName);
+                const val = rawRow[alias];
+                countBucket[countPlan.relationName] =
+                    typeof val === "number" ? val : Number(val ?? 0);
+            }
+            row["_count"] = countBucket;
+        }
+        return row;
+    });
+}
+export function buildPlanExtraSelectCols(manifest, parentTable, plan, dialect, manifestIndex) {
+    if (plan.countAggregate) {
+        return [...plan.countAggregate.selectCols];
+    }
+    if (plan.hasManyAggregate) {
+        return [...plan.joinSelectCols, ...plan.hasManyAggregate.selectCols];
+    }
+    const cols = [...plan.joinSelectCols];
+    for (const inline of plan.inlineJsonAgg) {
+        cols.push(buildInlineJsonAggSelectCol(parentTable, inline.chain, dialect, manifestIndex));
+    }
+    for (const countPlan of plan.inlineCounts) {
+        cols.push(buildInlineCountSelectCol(manifest, parentTable, countPlan.relationName, countPlan.spec, dialect, manifestIndex));
+    }
+    return cols;
+}
+export function buildAggregateGroupBy(plan) {
+    if (plan.hasManyAggregate && plan.hasManyAggregate.groupByCols.length > 0) {
+        return `GROUP BY ${plan.hasManyAggregate.groupByCols.join(", ")}`;
+    }
+    if (plan.countAggregate && plan.countAggregate.groupByCols.length > 0) {
+        return `GROUP BY ${plan.countAggregate.groupByCols.join(", ")}`;
+    }
+    return "";
+}
+/** @deprecated Use buildAggregateGroupBy */
+export function buildCountAggregateGroupBy(plan) {
+    return buildAggregateGroupBy(plan);
+}
+export function compileCountOrderBy(manifest, parentTable, orderBy, plan, manifestIndex) {
+    if (!orderBy || !plan.countAggregate)
+        return "";
+    const countOrder = orderBy._count;
+    if (!countOrder || typeof countOrder !== "object" || Array.isArray(countOrder)) {
+        return "";
+    }
+    const parentTableIndex = getTableIndex(manifestIndex, parentTable.accessor);
+    const parts = [];
+    for (const [relationName, direction] of Object.entries(countOrder)) {
+        if (typeof direction !== "string")
+            continue;
+        const countPlan = plan.countAggregate.inlineCounts.find((c) => c.relationName === relationName);
+        if (!countPlan)
+            continue;
+        const relation = findRelation(parentTable, relationName, parentTableIndex);
+        if (!relation)
+            continue;
+        const targetTable = manifest.tables[relation.targetAccessor];
+        if (!targetTable)
+            continue;
+        const targetAlias = `_cnt_${relationName}`;
+        const targetPkCol = quoteIdentifier(targetRelationPkSql(targetTable, relation));
+        const dir = direction.toUpperCase() === "DESC" ? "DESC" : "ASC";
+        parts.push(`COUNT(${quoteIdentifier(targetAlias)}.${targetPkCol}) ${dir}`);
+    }
+    return parts.length > 0 ? `ORDER BY ${parts.join(", ")}` : "";
+}
+export function hasPlanMainQueryExtras(plan) {
+    return (plan.joinedRelations.size > 0 ||
+        plan.inlineJsonAgg.length > 0 ||
+        plan.inlineCounts.length > 0 ||
+        plan.countAggregate !== undefined ||
+        plan.hasManyAggregate !== undefined);
+}
+export function withShapeSignature(withSpec) {
+    const parts = [];
+    const sorted = Object.entries(withSpec).sort(([a], [b]) => a.localeCompare(b));
+    for (const [name, input] of sorted) {
+        if (input === true) {
+            parts.push(name);
+            continue;
+        }
+        if (typeof input === "object" && input !== null) {
+            const spec = input;
+            const bits = [name];
+            if (spec.limit !== undefined)
+                bits.push(`l${spec.limit}`);
+            if (spec.orderBy)
+                bits.push(`o${orderByShapeKey(spec.orderBy)}`);
+            if (spec.with) {
+                bits.push(`w${withShapeSignature(spec.with)}`);
+            }
+            parts.push(bits.join(":"));
+        }
+    }
+    return parts.join("|");
+}
+export function planIsFullyInline(plan) {
+    return Object.keys(plan.batchWith).length === 0;
+}
+export function getCachedRelationPlan(manifest, table, withSpec, dialect, manifestIndex, options) {
+    const tableIndex = getTableIndex(manifestIndex, table.accessor);
+    const signature = relationPlanCacheKey(withSpec, dialect, options);
+    const cached = tableIndex?.relationPlanBySignature.get(signature);
+    if (cached)
+        return cached;
+    const plan = planRelationLoad(manifest, table, withSpec, dialect, manifestIndex, options);
+    tableIndex?.relationPlanBySignature.set(signature, plan);
+    return plan;
+}
+export function getCachedFindByIdWithQuery(manifest, table, withSpec, dialect, manifestIndex) {
+    const plan = getCachedRelationPlan(manifest, table, withSpec, dialect, manifestIndex, { useHasManyAggregate: false });
+    if (!planIsFullyInline(plan))
+        return null;
+    if (plan.countAggregate)
+        return null;
+    const tableIndex = getTableIndex(manifestIndex, table.accessor);
+    const signature = `${dialect.name}|${withShapeSignature(withSpec)}|corr`;
+    const { sqlName } = requireScalarPrimaryKey(table);
+    const pkCol = quoteIdentifier(sqlName);
+    const build = () => {
+        const joinClauses = plan.hasManyAggregate && plan.hasManyAggregate.joins.length > 0
+            ? plan.hasManyAggregate.joins
+            : plan.joins.length > 0
+                ? plan.joins
+                : undefined;
+        const hasJoins = Boolean(joinClauses && joinClauses.length > 0);
+        const selectCols = hasJoins
+            ? buildQualifiedSelectColumns(table, undefined, manifestIndex)
+            : buildSelectColumns(table, undefined, manifestIndex);
+        const extraCols = buildPlanExtraSelectCols(manifest, table, plan, dialect, manifestIndex);
+        let sql = `SELECT ${selectCols}`;
+        if (extraCols.length > 0)
+            sql += `, ${extraCols.join(", ")}`;
+        sql += ` FROM ${tableRef(table)}`;
+        if (joinClauses)
+            sql += ` ${joinClauses.join(" ")}`;
+        sql += ` WHERE ${tableRef(table)}.${pkCol} = $1`;
+        const groupBySql = buildAggregateGroupBy(plan);
+        if (groupBySql)
+            sql += ` ${groupBySql}`;
+        return sql;
+    };
+    if (!tableIndex) {
+        return { sql: build(), plan };
+    }
+    const sql = getOrSetSqlCache(tableIndex.findByIdWithSqlBySignature, signature, build);
+    return { sql, plan };
+}
+//# sourceMappingURL=relation-planner.js.map