neoorm 0.3.1 → 0.4.0

package/dist/runtime/query/find.js

@@ -1,9 +1,19 @@
 import { postgresDialect, quoteIdentifier, tableRef, } from "../../dialect/postgres.js";
-import { buildFindByIdQuery, buildFindManyQuery, buildSelectColumns, compileOrderBy, compileWhere, isImpossibleWhere, normalizeSelectColumns, rowsToTs, rowsToTsIndexed, rowToTs, rowToTsIndexed, } from "./compile.js";
+import { buildFindByIdQuery, buildFindManyQuery, buildSelectColumns, compileOrderBy, compileWhere, getCachedFindManyQuery, getCachedOrderByClause, getCachedWhereClause, isImpossibleWhere, mapRowToTs, mapRowsToTs, normalizeLimitOffset, normalizeSelectColumns, } from "./compile.js";
+import { rebaseParamRefs } from "../../sql/template.js";
 import { runQuery, runQueryOne } from "./execute.js";
 import { findM2M, findRelation, tableOwnsFkColumn, } from "./manifest-lookup.js";
 import { primaryKeyTsNames, requireScalarPrimaryKey, resolvePkWhere, rowPkKey, targetRelationPkSql, } from "./primary-key.js";
-import { getTableIndex } from "./table-index.js";
+import { getTableIndex, columnBySqlName } from "./table-index.js";
+import { buildCountAggregateGroupBy, buildPlanExtraSelectCols, compileCountOrderBy, getCachedFindByIdWithQuery, getCachedRelationPlan, hydrateRowsWithPlan, planRelationLoad, withShapeSignature, } from "./relation-planner.js";
+function isRelationSpec(withSpec) {
+    if (typeof withSpec !== "object" || withSpec === null)
+        return false;
+    return ("select" in withSpec ||
+        "orderBy" in withSpec ||
+        "limit" in withSpec ||
+        "with" in withSpec);
+}
 function validateDistinctOrderBy(distinct, orderBy) {
     if (!distinct || distinct.length === 0)
         return;
@@ -37,13 +47,12 @@ function splitWithSpec(withSpec) {
 async function loadRelationCounts(executor, runtime, parentTable, parentRows, countSpec) {
     if (parentRows.length === 0)
         return;
-    const { manifest } = runtime;
     const parentIds = parentRows
         .map((r) => rowPkKey(r, parentTable))
         .filter(Boolean);
     if (parentIds.length === 0)
         return;
-    for (const [relationName, spec] of Object.entries(countSpec)) {
+    await Promise.all(Object.entries(countSpec).map(async ([relationName, spec]) => {
         const whereFilter = typeof spec === "object" ? spec.where : undefined;
         const counts = await countRelationLinks(executor, runtime, parentTable, relationName, parentIds, whereFilter);
         for (const parent of parentRows) {
@@ -52,9 +61,10 @@ async function loadRelationCounts(executor, runtime, parentTable, parentRows, co
             bucket[relationName] = counts.get(parentKey) ?? 0;
             parent["_count"] = bucket;
         }
-    }
+    }));
 }
 async function countRelationLinks(executor, runtime, parentTable, relationName, parentIds, whereFilter) {
+    const dialect = runtime.dialect ?? postgresDialect;
     const { manifest } = runtime;
     const m2m = findM2M(manifest, parentTable.accessor, relationName);
     if (m2m) {
@@ -72,18 +82,19 @@ async function countRelationLinks(executor, runtime, parentTable, relationName,
     let extraWhere = "";
     let extraParams = [];
     if (whereFilter) {
-        const compiled = compileWhere(manifest, targetTable, whereFilter, postgresDialect);
+        const compiled = compileWhere(manifest, targetTable, whereFilter, dialect, 1, runtime.tableIndex);
         if (compiled.sql) {
-            const adjusted = compiled.sql.replace(/\$(\d+)/g, (_, n) => `$${Number(n) + parentIds.length}`);
+            const adjusted = rebaseParamRefs(compiled.sql, parentIds.length);
             extraWhere = ` AND ${adjusted.replace(/^WHERE\s+/i, "")}`;
             extraParams = compiled.params;
         }
     }
-    const sql = `SELECT ${fkCol} AS parent_id, COUNT(*)::int AS count FROM ${tableRef(targetTable)} WHERE ${fkCol} IN (${placeholders})${extraWhere} GROUP BY ${fkCol}`;
+    const sql = `SELECT ${fkCol} AS parent_id, ${dialect.castToInt("COUNT(*)")} AS count FROM ${tableRef(targetTable)} WHERE ${fkCol} IN (${placeholders})${extraWhere} GROUP BY ${fkCol}`;
     const rows = await runQuery(executor, runtime, { operation: "select", tableAccessor: targetTable.accessor }, sql, [...parentIds, ...extraParams]);
     return new Map(rows.map((row) => [String(row.parent_id), row.count]));
 }
 async function countM2MLinks(executor, runtime, parentTable, m2m, parentIds, whereFilter) {
+    const dialect = runtime.dialect ?? postgresDialect;
     const { manifest } = runtime;
     const isLeft = m2m.leftAccessor === parentTable.accessor;
     const targetAccessor = isLeft ? m2m.rightAccessor : m2m.leftAccessor;
@@ -98,32 +109,27 @@ async function countM2MLinks(executor, runtime, parentTable, m2m, parentIds, whe
     let extraWhere = "";
     let extraParams = [];
     if (whereFilter) {
-        const compiled = compileWhere(manifest, targetTable, whereFilter, postgresDialect);
+        const compiled = compileWhere(manifest, targetTable, whereFilter, dialect, 1, runtime.tableIndex);
         joinSql = ` JOIN ${tableRef(targetTable)} t ON t.${quoteIdentifier(targetRelationPkSql(targetTable))} = j.${quoteIdentifier(targetFkCol)}`;
         if (compiled.sql) {
-            const adjusted = compiled.sql.replace(/\$(\d+)/g, (_, n) => `$${Number(n) + parentIds.length}`);
+            const adjusted = rebaseParamRefs(compiled.sql, parentIds.length);
             extraWhere = ` AND ${adjusted.replace(/^WHERE\s+/i, "")}`;
             extraParams = compiled.params;
         }
     }
-    const sql = `SELECT j.${quoteIdentifier(parentFkCol)} AS parent_id, COUNT(*)::int AS count FROM ${tableRef(throughTable)} j${joinSql} WHERE j.${quoteIdentifier(parentFkCol)} IN (${placeholders})${extraWhere} GROUP BY j.${quoteIdentifier(parentFkCol)}`;
+    const sql = `SELECT j.${quoteIdentifier(parentFkCol)} AS parent_id, ${dialect.castToInt("COUNT(*)")} AS count FROM ${tableRef(throughTable)} j${joinSql} WHERE j.${quoteIdentifier(parentFkCol)} IN (${placeholders})${extraWhere} GROUP BY j.${quoteIdentifier(parentFkCol)}`;
     const rows = await runQuery(executor, runtime, { operation: "select", tableAccessor: throughTable.accessor }, sql, [...parentIds, ...extraParams]);
     return new Map(rows.map((row) => [String(row.parent_id), row.count]));
 }
 function columnsForSelect(table, withSpec) {
-    const nestedSpec = typeof withSpec === "object" ? withSpec : undefined;
+    const nestedSpec = isRelationSpec(withSpec) ? withSpec : undefined;
     const selectKeys = normalizeSelectColumns(nestedSpec?.select);
     return buildSelectColumns(table, selectKeys ? [...selectKeys] : undefined);
 }
-function isM2MRelation(manifest, tableAccessor, relationName) {
-    return findM2M(manifest, tableAccessor, relationName) !== undefined;
-}
 async function loadNestedRelations(executor, runtime, targetTable, childRows, nestedWith) {
     if (childRows.length === 0)
         return;
-    for (const [nestedName, nestedWithSpec] of Object.entries(nestedWith)) {
-        await loadOneRelation(executor, runtime, targetTable, childRows, nestedName, nestedWithSpec);
-    }
+    await Promise.all(Object.entries(nestedWith).map(([nestedName, nestedWithSpec]) => loadOneRelation(executor, runtime, targetTable, childRows, nestedName, nestedWithSpec)));
 }
 async function loadOneRelation(executor, runtime, parentTable, parentRows, relationName, withSpec) {
     if (parentRows.length === 0)
@@ -143,7 +149,7 @@ async function loadOneRelation(executor, runtime, parentTable, parentRows, relat
     const parentIds = parentRows
         .map((r) => rowPkKey(r, parentTable))
         .filter(Boolean);
-    const nestedSpec = typeof withSpec === "object" ? withSpec : undefined;
+    const nestedSpec = isRelationSpec(withSpec) ? withSpec : undefined;
     if (relation.cardinality === "one" &&
         tableOwnsFkColumn(parentTable, relation)) {
         const fkValues = parentRows
@@ -159,7 +165,8 @@ async function loadOneRelation(executor, runtime, parentTable, parentRows, relat
             throw new Error(`No primary key defined for table "${targetTable.accessor}"`);
         }
         const rows = await runQuery(executor, runtime, { operation: "select", tableAccessor: targetTable.accessor }, `SELECT ${selectCols} FROM ${tableRef(targetTable)} WHERE ${targetPkCol} IN (${placeholders})`, fkValues);
-        const mapped = rowsToTs(targetTable, rows);
+        const targetTableIndex = getTableIndex(runtime.tableIndex, targetTable.accessor);
+        const mapped = mapRowsToTs(targetTableIndex, targetTable, rows);
         const byId = new Map(mapped.map((r) => [String(r[targetPkTsName]), r]));
         for (const parent of parentRows) {
             const fkVal = parent[relation.fkColumn];
@@ -173,14 +180,15 @@ async function loadOneRelation(executor, runtime, parentTable, parentRows, relat
         const selectCols = columnsForSelect(targetTable, withSpec);
         let sql = `SELECT ${selectCols} FROM ${tableRef(targetTable)} WHERE ${fkCol} IN (${placeholders})`;
         if (nestedSpec?.orderBy) {
-            sql += ` ${compileOrderBy(targetTable, nestedSpec.orderBy)}`;
+            sql += ` ${compileOrderBy(targetTable, nestedSpec.orderBy, undefined, runtime.tableIndex)}`;
         }
         if (nestedSpec?.limit !== undefined) {
-            sql += ` LIMIT ${nestedSpec.limit}`;
+            sql += ` LIMIT ${normalizeLimitOffset(nestedSpec.limit, "limit")}`;
         }
         const rows = await runQuery(executor, runtime, { operation: "select", tableAccessor: targetTable.accessor }, sql, parentIds);
-        const mapped = rowsToTs(targetTable, rows);
-        const fkTargetCol = targetTable.columns.find((c) => c.sqlName === relation.fkSqlColumn);
+        const targetTableIndex = getTableIndex(runtime.tableIndex, targetTable.accessor);
+        const mapped = mapRowsToTs(targetTableIndex, targetTable, rows);
+        const fkTargetCol = columnBySqlName(targetTableIndex, targetTable, relation.fkSqlColumn);
         const fkTsName = fkTargetCol?.tsName ?? relation.fkColumn;
         const grouped = new Map();
         for (const row of mapped) {
@@ -240,10 +248,12 @@ async function loadM2MRelation(executor, runtime, parentTable, parentRows, m2m,
     WHERE j.${quoteIdentifier(parentFkCol)} IN (${placeholders})
   `.trim();
     const rows = await runQuery(executor, runtime, { operation: "select", tableAccessor: targetTable.accessor }, sql, parentIds);
+    const targetTableIndex = getTableIndex(runtime.tableIndex, targetTable.accessor);
     const grouped = new Map();
     for (const row of rows) {
         const parentId = String(row["_parent_id"]);
-        const mapped = rowToTs(targetTable, row);
+        const { ["_parent_id"]: _parentKey, ...targetRow } = row;
+        const mapped = mapRowToTs(targetTableIndex, targetTable, targetRow);
         let bucket = grouped.get(parentId);
         if (!bucket) {
             bucket = [];
@@ -256,76 +266,60 @@ async function loadM2MRelation(executor, runtime, parentTable, parentRows, m2m,
         parent[relationName] = grouped.get(parentKey) ?? [];
     }
 }
-function buildJoinClauses(manifest, parentTable, withSpec) {
-    const joins = [];
-    const selectCols = [];
-    const joinedRelations = new Set();
-    if (!withSpec)
-        return { joins, selectCols, joinedRelations };
-    for (const [relationName, spec] of Object.entries(withSpec)) {
-        if (relationName === "_count")
-            continue;
-        const relation = findRelation(parentTable, relationName);
-        if (!relation)
-            continue;
-        if (relation.cardinality !== "one")
-            continue;
-        if (!tableOwnsFkColumn(parentTable, relation))
-            continue;
-        const m2m = findM2M(manifest, parentTable.accessor, relationName);
-        if (m2m)
-            continue;
-        const nestedSpec = typeof spec === "object" ? spec : undefined;
-        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 selectKeys = nestedSpec?.select
-            ? normalizeSelectColumns(nestedSpec.select)
-            : undefined;
-        const targetCols = selectKeys && selectKeys.length > 0
-            ? targetTable.columns.filter((c) => selectKeys.includes(c.tsName))
-            : 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);
+export async function hydrateAndLoadRelations(executor, runtime, table, rawRows, withSpec, plan) {
+    if (rawRows.length === 0)
+        return [];
+    const resolvedPlan = plan ??
+        planRelationLoad(runtime.manifest, table, withSpec, runtime.dialect ?? postgresDialect, runtime.tableIndex);
+    let resultRows;
+    if (withSpec) {
+        resultRows = hydrateRowsWithPlan(runtime, table, rawRows, resolvedPlan);
     }
-    return { joins, selectCols, joinedRelations };
+    else {
+        const tableIndex = getTableIndex(runtime.tableIndex, table.accessor);
+        resultRows = mapRowsToTs(tableIndex, table, rawRows);
+    }
+    const batchWith = resolvedPlan.batchWith;
+    if (Object.keys(batchWith).length > 0) {
+        await loadRelations(executor, runtime, table, resultRows, batchWith);
+    }
+    return resultRows;
 }
-function extractJoinedRelations(row, manifest, parentTable, joinedRelations) {
-    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];
-            }
-            relations[relationName] = rowToTs(targetTable, raw);
-        }
+async function executeFindManyWithRelations(executor, runtime, tableAccessor, table, tableIndex, args, whereSql, params, planOptions) {
+    const dialect = runtime.dialect ?? postgresDialect;
+    const { manifest } = runtime;
+    const plan = getCachedRelationPlan(manifest, table, args.with, dialect, runtime.tableIndex, planOptions);
+    const needsQualifiedRefs = plan.joins.length > 0 ||
+        plan.countAggregate !== undefined ||
+        plan.hasManyAggregate !== undefined ||
+        plan.joinedRelations.size > 0;
+    if (needsQualifiedRefs && whereSql) {
+        const qualifiedWhere = getCachedWhereClause(manifest, table, args.where, dialect, 1, runtime.tableIndex, true);
+        whereSql = qualifiedWhere.sql;
+        params = qualifiedWhere.params;
+    }
+    const extraSelectCols = buildPlanExtraSelectCols(manifest, table, plan, dialect, runtime.tableIndex);
+    const countOrderSql = compileCountOrderBy(manifest, table, args.orderBy, plan, runtime.tableIndex);
+    const orderSqlForWith = countOrderSql ||
+        getCachedOrderByClause(table, args.orderBy, needsQualifiedRefs ? table.sqlName : undefined, runtime.tableIndex);
+    const joinClauses = plan.countAggregate && plan.countAggregate.joins.length > 0
+        ? plan.countAggregate.joins
+        : plan.hasManyAggregate && plan.hasManyAggregate.joins.length > 0
+            ? plan.hasManyAggregate.joins
+            : plan.joins.length > 0
+                ? plan.joins
+                : undefined;
+    const groupBySql = buildCountAggregateGroupBy(plan);
+    const distinctOn = normalizeSelectColumns(args.distinct);
+    if (distinctOn && distinctOn.length > 0 && dialect.name === "sqlite") {
+        throw new Error("distinct is not supported on SQLite (DISTINCT ON is PostgreSQL-only). Use groupBy or orderBy + a manual query instead.");
     }
-    return relations;
+    const withSignature = withShapeSignature(args.with);
+    const planMode = planOptions?.useHasManyAggregate === false ? "corr" : "agg";
+    const signature = `${whereSql}|${orderSqlForWith}|${args.limit ?? ""}|${args.offset ?? ""}|${distinctOn?.join(",") ?? ""}|${withSignature}|${planMode}|${groupBySql}`;
+    const query = getCachedFindManyQuery(tableIndex, signature, () => buildFindManyQuery(table, whereSql, orderSqlForWith, args.limit, args.offset, distinctOn, extraSelectCols.length > 0 ? extraSelectCols : undefined, joinClauses, runtime.tableIndex, groupBySql || undefined));
+    const rows = await runQuery(executor, runtime, { operation: "select", tableAccessor }, query, params);
+    return await hydrateAndLoadRelations(executor, runtime, table, rows, args.with, plan);
 }
 export async function loadRelations(executor, runtime, table, rows, withSpec) {
     if (!withSpec || rows.length === 0)
@@ -338,6 +332,7 @@ export async function loadRelations(executor, runtime, table, rows, withSpec) {
     return rows;
 }
 export async function findMany(executor, runtime, tableAccessor, args) {
+    const dialect = runtime.dialect ?? postgresDialect;
     const { manifest } = runtime;
     const table = manifest.tables[tableAccessor];
     if (!table)
@@ -352,51 +347,64 @@ export async function findMany(executor, runtime, tableAccessor, args) {
         args?.offset === undefined;
     if (isSimpleFind && tableIndex) {
         const rows = await runQuery(executor, runtime, queryCtx, tableIndex.findAllSql, []);
-        return rowsToTsIndexed(tableIndex, table, rows);
+        return mapRowsToTs(tableIndex, table, rows);
     }
     const distinctOn = normalizeSelectColumns(args?.distinct);
     validateDistinctOrderBy(distinctOn, args?.orderBy);
-    const compiledWhere = compileWhere(manifest, table, args?.where, postgresDialect);
+    if (distinctOn && distinctOn.length > 0 && dialect.name === "sqlite") {
+        throw new Error("distinct is not supported on SQLite (DISTINCT ON is PostgreSQL-only). Use groupBy or orderBy + a manual query instead.");
+    }
+    const compiledWhere = getCachedWhereClause(manifest, table, args?.where, dialect, 1, runtime.tableIndex);
     if (compiledWhere.impossible || isImpossibleWhere(compiledWhere.sql)) {
         return [];
     }
-    const { sql: whereSql, params } = compiledWhere;
-    const orderSql = compileOrderBy(table, args?.orderBy);
-    const { relationWith, countSpec } = args?.with
-        ? splitWithSpec(args.with)
-        : { relationWith: {} };
-    const { joins, selectCols, joinedRelations } = buildJoinClauses(manifest, table, relationWith);
-    const query = buildFindManyQuery(table, whereSql, orderSql, args?.limit, args?.offset, distinctOn, selectCols.length > 0 ? selectCols : undefined, joins.length > 0 ? joins : undefined);
-    const rows = await runQuery(executor, runtime, { operation: "select", tableAccessor }, query, params);
-    let resultRows;
-    if (joinedRelations.size > 0) {
-        resultRows = rows.map((rawRow) => {
-            const relations = extractJoinedRelations(rawRow, manifest, table, joinedRelations);
-            return { ...rowToTs(table, rawRow), ...relations };
-        });
-    }
-    else {
-        resultRows = tableIndex
-            ? rowsToTsIndexed(tableIndex, table, rows)
-            : rowsToTs(table, rows);
+    let whereSql = compiledWhere.sql;
+    let params = compiledWhere.params;
+    const hasWith = Boolean(args?.with && Object.keys(args.with).length > 0);
+    if (!hasWith) {
+        const orderSql = getCachedOrderByClause(table, args?.orderBy, undefined, runtime.tableIndex);
+        const signature = `${whereSql}|${orderSql}|${args?.limit ?? ""}|${args?.offset ?? ""}|${distinctOn?.join(",") ?? ""}`;
+        const query = getCachedFindManyQuery(tableIndex, signature, () => buildFindManyQuery(table, whereSql, orderSql, args?.limit, args?.offset, distinctOn, undefined, undefined, runtime.tableIndex));
+        const rows = await runQuery(executor, runtime, { operation: "select", tableAccessor }, query, params);
+        return mapRowsToTs(tableIndex, table, rows);
     }
-    const remainingWith = {};
-    for (const [key, spec] of Object.entries(relationWith)) {
-        if (!joinedRelations.has(key)) {
-            remainingWith[key] = spec;
+    return executeFindManyWithRelations(executor, runtime, tableAccessor, table, tableIndex, { ...(args ?? {}), with: args.with }, whereSql, params, { useHasManyAggregate: true });
+}
+export async function findFirst(executor, runtime, tableAccessor, args) {
+    const dialect = runtime.dialect ?? postgresDialect;
+    const hasWith = Boolean(args?.with && Object.keys(args.with).length > 0);
+    const canFastPath = !hasWith && !args?.distinct && args?.offset === undefined;
+    if (canFastPath) {
+        const { manifest } = runtime;
+        const table = manifest.tables[tableAccessor];
+        if (!table)
+            throw new Error(`Unknown table: ${tableAccessor}`);
+        const tableIndex = getTableIndex(runtime.tableIndex, tableAccessor);
+        const compiledWhere = getCachedWhereClause(manifest, table, args?.where, dialect, 1, runtime.tableIndex);
+        if (compiledWhere.impossible || isImpossibleWhere(compiledWhere.sql)) {
+            return null;
         }
+        const { sql: whereSql, params } = compiledWhere;
+        const orderSql = getCachedOrderByClause(table, args?.orderBy, undefined, runtime.tableIndex);
+        const signature = `${whereSql}|${orderSql}|1||`;
+        const query = getCachedFindManyQuery(tableIndex, signature, () => buildFindManyQuery(table, whereSql, orderSql, 1, undefined, undefined, undefined, undefined, runtime.tableIndex));
+        const rows = await runQuery(executor, runtime, { operation: "select", tableAccessor }, query, params);
+        if (rows.length === 0)
+            return null;
+        return mapRowToTs(tableIndex, table, rows[0]);
     }
-    if (countSpec) {
-        remainingWith._count = countSpec;
+    const { manifest } = runtime;
+    const table = manifest.tables[tableAccessor];
+    if (!table)
+        throw new Error(`Unknown table: ${tableAccessor}`);
+    const tableIndex = getTableIndex(runtime.tableIndex, tableAccessor);
+    const compiledWhere = getCachedWhereClause(manifest, table, args?.where, dialect, 1, runtime.tableIndex);
+    if (compiledWhere.impossible || isImpossibleWhere(compiledWhere.sql)) {
+        return null;
     }
-    await loadRelations(executor, runtime, table, resultRows, Object.keys(remainingWith).length > 0 ? remainingWith : undefined);
-    return resultRows;
-}
-export async function findFirst(executor, runtime, tableAccessor, args) {
-    const rows = await findMany(executor, runtime, tableAccessor, {
-        ...args,
-        limit: 1,
-    });
+    const distinctOn = normalizeSelectColumns(args?.distinct);
+    validateDistinctOrderBy(distinctOn, args?.orderBy);
+    const rows = await executeFindManyWithRelations(executor, runtime, tableAccessor, table, tableIndex, { ...args, with: args.with, limit: 1 }, compiledWhere.sql, compiledWhere.params, { useHasManyAggregate: false });
     return rows[0] ?? null;
 }
 function extractScalarPkValue(table, id) {
@@ -404,131 +412,50 @@ function extractScalarPkValue(table, id) {
     const { tsName } = requireScalarPrimaryKey(table);
     return where[tsName];
 }
-function inlineRelationColumnAlias(relationName) {
-    return `__neoorm_${relationName}`;
-}
-function tryGetInlineManyRelationLoad(manifest, table, withSpec) {
-    if (!withSpec)
-        return null;
-    const { relationWith, countSpec } = splitWithSpec(withSpec);
-    if (countSpec)
-        return null;
-    const entries = Object.entries(relationWith);
-    if (entries.length !== 1)
-        return null;
-    const [relationName, withInput] = entries[0];
-    if (isM2MRelation(manifest, table.accessor, relationName))
-        return null;
-    const relation = findRelation(table, relationName);
-    if (!relation || relation.cardinality !== "many")
-        return null;
-    if (tableOwnsFkColumn(table, relation))
-        return null;
-    const nestedSpec = typeof withInput === "object" ? withInput : undefined;
-    if (nestedSpec?.with)
-        return null;
-    const targetTable = manifest.tables[relation.targetAccessor];
-    if (!targetTable)
-        return null;
-    return { relationName, relation, targetTable, nestedSpec };
-}
-const INLINE_RELATION_PARENT_ALIAS = "u";
-const INLINE_RELATION_CHILD_ALIAS = "r";
-function buildInlineManyRelationSubquery(parentAlias, parentTable, relation, targetTable, nestedSpec) {
-    const { sqlName: parentPkSql } = requireScalarPrimaryKey(parentTable);
-    const parentPkCol = quoteIdentifier(parentPkSql);
-    const fkCol = quoteIdentifier(relation.fkSqlColumn);
-    const childAlias = INLINE_RELATION_CHILD_ALIAS;
-    const childRef = tableRef(targetTable);
-    const parentRef = quoteIdentifier(parentAlias);
-    let sql = `(SELECT json_agg(${quoteIdentifier(childAlias)}.*) FROM ${childRef} ${quoteIdentifier(childAlias)} WHERE ${quoteIdentifier(childAlias)}.${fkCol} = ${parentRef}.${parentPkCol}`;
-    if (nestedSpec?.orderBy) {
-        sql += ` ${compileOrderBy(targetTable, nestedSpec.orderBy, childAlias)}`;
-    }
-    if (nestedSpec?.limit !== undefined) {
-        sql += ` LIMIT ${nestedSpec.limit}`;
-    }
-    const alias = quoteIdentifier(inlineRelationColumnAlias(relation.name));
-    return `${sql}) AS ${alias}`;
-}
-function buildFindByIdWithInlineRelationQuery(table, inlineSubquery) {
-    const parentAlias = INLINE_RELATION_PARENT_ALIAS;
-    const { sqlName } = requireScalarPrimaryKey(table);
-    const pkCol = quoteIdentifier(sqlName);
-    const ref = quoteIdentifier(parentAlias);
-    return `SELECT ${ref}.*, ${inlineSubquery} FROM ${tableRef(table)} ${ref} WHERE ${ref}.${pkCol} = $1 LIMIT 1`;
-}
-function hydrateInlineManyRelationRow(parentIndex, targetIndex, parentTable, targetTable, relationName, rawRow) {
-    const alias = inlineRelationColumnAlias(relationName);
-    const jsonVal = rawRow[alias];
-    const parentRaw = {};
-    for (const col of parentTable.columns) {
-        if (col.sqlName in rawRow) {
-            parentRaw[col.sqlName] = rawRow[col.sqlName];
-        }
-    }
-    const parent = parentIndex
-        ? rowToTsIndexed(parentIndex, parentTable, parentRaw)
-        : rowToTs(parentTable, parentRaw);
-    let children = [];
-    if (jsonVal != null) {
-        const parsed = typeof jsonVal === "string"
-            ? JSON.parse(jsonVal)
-            : jsonVal;
-        if (Array.isArray(parsed)) {
-            children = parsed.map((row) => {
-                const childRow = row;
-                return targetIndex
-                    ? rowToTsIndexed(targetIndex, targetTable, childRow)
-                    : rowToTs(targetTable, childRow);
-            });
-        }
-    }
-    parent[relationName] = children;
-    return parent;
-}
 export async function findById(executor, runtime, tableAccessor, id, args) {
+    const dialect = runtime.dialect ?? postgresDialect;
     const { manifest } = runtime;
     const table = manifest.tables[tableAccessor];
     if (!table)
         throw new Error(`Unknown table: ${tableAccessor}`);
+    const tableIndex = getTableIndex(runtime.tableIndex, tableAccessor);
     if (table.primaryKey.length !== 1) {
         const where = resolvePkWhere(table, id);
-        const findArgs = {
+        if (args?.with) {
+            const compiledWhere = getCachedWhereClause(manifest, table, where, dialect, 1, runtime.tableIndex);
+            if (compiledWhere.impossible || isImpossibleWhere(compiledWhere.sql)) {
+                return null;
+            }
+            const rows = await executeFindManyWithRelations(executor, runtime, tableAccessor, table, tableIndex, { where, limit: 1, with: args.with }, compiledWhere.sql, compiledWhere.params, { useHasManyAggregate: false });
+            return rows[0] ?? null;
+        }
+        const rows = await findMany(executor, runtime, tableAccessor, {
             where,
             limit: 1,
-        };
-        if (args?.with !== undefined) {
-            findArgs.with = args.with;
-        }
-        const rows = await findMany(executor, runtime, tableAccessor, findArgs);
+        });
         return rows[0] ?? null;
     }
     const pkValue = extractScalarPkValue(table, id);
-    const tableIndex = getTableIndex(runtime.tableIndex, tableAccessor);
     const ctx = { operation: "select", tableAccessor };
     if (!args?.with) {
         const query = tableIndex?.findByIdSql || buildFindByIdQuery(table);
         const row = await runQueryOne(executor, runtime, ctx, query, [pkValue]);
-        return row ? (tableIndex ? rowToTsIndexed(tableIndex, table, row) : rowToTs(table, row)) : null;
+        return row ? mapRowToTs(tableIndex, table, row) : null;
     }
-    const inlineLoad = tryGetInlineManyRelationLoad(manifest, table, args.with);
-    if (inlineLoad) {
-        const subquery = buildInlineManyRelationSubquery(INLINE_RELATION_PARENT_ALIAS, table, inlineLoad.relation, inlineLoad.targetTable, inlineLoad.nestedSpec);
-        const query = buildFindByIdWithInlineRelationQuery(table, subquery);
-        const row = await runQueryOne(executor, runtime, ctx, query, [pkValue]);
-        if (!row)
+    const cached = getCachedFindByIdWithQuery(manifest, table, args.with, dialect, runtime.tableIndex);
+    if (cached) {
+        const rows = await runQuery(executor, runtime, ctx, cached.sql, [pkValue]);
+        if (rows.length === 0)
             return null;
-        const targetIndex = getTableIndex(runtime.tableIndex, inlineLoad.targetTable.accessor);
-        return hydrateInlineManyRelationRow(tableIndex, targetIndex, table, inlineLoad.targetTable, inlineLoad.relationName, row);
+        const hydrated = hydrateRowsWithPlan(runtime, table, rows, cached.plan);
+        return hydrated[0] ?? null;
     }
     const where = resolvePkWhere(table, id);
-    const findArgs = {
-        where,
-        limit: 1,
-        with: args.with,
-    };
-    const rows = await findMany(executor, runtime, tableAccessor, findArgs);
+    const compiledWhere = getCachedWhereClause(manifest, table, where, dialect, 1, runtime.tableIndex);
+    if (compiledWhere.impossible || isImpossibleWhere(compiledWhere.sql)) {
+        return null;
+    }
+    const rows = await executeFindManyWithRelations(executor, runtime, tableAccessor, table, tableIndex, { where, limit: 1, with: args.with }, compiledWhere.sql, compiledWhere.params, { useHasManyAggregate: false });
     return rows[0] ?? null;
 }
 //# sourceMappingURL=find.js.map