prisma-sql 1.67.0 → 1.68.0

package/dist/generator.cjs

@@ -2323,7 +2323,7 @@ var require_package = __commonJS({
   "package.json"(exports$1, module) {
     module.exports = {
       name: "prisma-sql",
-      version: "1.67.0",
+      version: "1.68.0",
       description: "Convert Prisma queries to optimized SQL with type safety. 2-7x faster than Prisma Client.",
       main: "dist/index.cjs",
       module: "dist/index.js",
@@ -2804,6 +2804,8 @@ var LIMITS = Object.freeze({
   MAX_STRING_LENGTH: 1e4,
   MAX_HAVING_DEPTH: 50
 });
+var _a;
+var DEBUG_PARAMS = typeof process !== "undefined" && ((_a = process.env) == null ? void 0 : _a.DEBUG_PARAMS) === "1";
 
 // src/builder/shared/validators/type-guards.ts
 function isNotNullish(value) {
@@ -3347,7 +3349,7 @@ function normalizeField(field) {
   return field;
 }
 function getFieldIndices(model) {
-  var _a;
+  var _a3;
   let cached = FIELD_INDICES_CACHE.get(model);
   if (cached) return cached;
   const scalarFields = /* @__PURE__ */ new Map();
@@ -3366,7 +3368,7 @@ function getFieldIndices(model) {
     } else {
       scalarFields.set(field.name, field);
       scalarNames.push(field.name);
-      const fieldType = String((_a = field.type) != null ? _a : "").toLowerCase();
+      const fieldType = String((_a3 = field.type) != null ? _a3 : "").toLowerCase();
       if (fieldType === "json") {
         jsonFields.add(field.name);
       }
@@ -3464,13 +3466,13 @@ function getModelByName(schemas, name) {
   return schemas.find((m) => m.name === name);
 }
 function normalizeIntLike(name, v, opts = {}) {
-  var _a, _b;
+  var _a3, _b;
   if (!isNotNullish(v)) return void 0;
   if (schemaParser.isDynamicParameter(v)) return v;
   if (typeof v !== "number" || !Number.isFinite(v) || !Number.isInteger(v)) {
     throw new Error(`${name} must be an integer`);
   }
-  const min = (_a = opts.min) != null ? _a : 0;
+  const min = (_a3 = opts.min) != null ? _a3 : 0;
   const allowZero = (_b = opts.allowZero) != null ? _b : true;
   if (!allowZero && v === 0) {
     throw new Error(`${name} must be > 0`);
@@ -3492,7 +3494,9 @@ function scopeName(scope, dynamicName) {
 function addAutoScoped(params, value, scope) {
   if (schemaParser.isDynamicParameter(value)) {
     const dn = schemaParser.extractDynamicName(value);
-    console.log(`[PARAM] ${scope} = ${JSON.stringify(value)}`);
+    if (DEBUG_PARAMS) {
+      console.log(`[PARAM] ${scope} = ${JSON.stringify(value)}`);
+    }
     return params.add(void 0, scopeName(scope, dn));
   }
   return params.add(value);
@@ -3933,7 +3937,7 @@ function assertCursorAndOrderFieldsScalar(model, cursor, orderEntries) {
   }
 }
 function buildCursorCondition(cursor, orderBy, tableName, alias, params, dialect, model) {
-  var _a;
+  var _a3;
   assertSafeTableRef(tableName);
   assertSafeAlias(alias);
   const d = dialect != null ? dialect : getGlobalDialect();
@@ -3948,6 +3952,33 @@ function buildCursorCondition(cursor, orderBy, tableName, alias, params, dialect
   }
   if (cursorEntries.length === 0)
     throw new Error("cursor must have at least one field with defined value");
+  const orderEntries = normalizeAndValidateOrderBy(
+    orderBy,
+    model,
+    parseOrderByValue
+  );
+  if (cursorEntries.length === 1 && orderEntries.length === 0) {
+    const [field, value] = cursorEntries[0];
+    const ph = addAutoScoped(params, value, `cursor.${field}`);
+    const c = col(alias, field, model);
+    return {
+      cte: "",
+      condition: `${c} >= ${ph}`
+    };
+  }
+  if (cursorEntries.length === 1 && orderEntries.length === 1) {
+    const [cursorField, cursorValue] = cursorEntries[0];
+    const orderEntry = orderEntries[0];
+    if (orderEntry.field === cursorField) {
+      const ph = addAutoScoped(params, cursorValue, `cursor.${cursorField}`);
+      const c = col(alias, cursorField, model);
+      const op = orderEntry.direction === "asc" ? ">=" : "<=";
+      return {
+        cte: "",
+        condition: `${c} ${op} ${ph}`
+      };
+    }
+  }
   const { cteName, srcAlias } = buildCursorNames(alias);
   assertSafeAlias(cteName);
   assertSafeAlias(srcAlias);
@@ -3956,49 +3987,52 @@ function buildCursorCondition(cursor, orderBy, tableName, alias, params, dialect
     model,
     parseValue: parseOrderByValue
   });
-  let orderEntries = normalizeAndValidateOrderBy(
+  let finalOrderEntries = normalizeAndValidateOrderBy(
     orderBy,
     model,
     parseOrderByValue
   );
-  if (orderEntries.length === 0) {
-    orderEntries = cursorEntries.map(([field]) => ({
+  if (finalOrderEntries.length === 0) {
+    finalOrderEntries = cursorEntries.map(([field]) => ({
       field,
       direction: "asc"
     }));
   } else {
-    orderEntries = ensureCursorFieldsInOrder(orderEntries, cursorEntries);
+    finalOrderEntries = ensureCursorFieldsInOrder(
+      finalOrderEntries,
+      cursorEntries
+    );
   }
-  assertCursorAndOrderFieldsScalar(model, cursor, orderEntries);
+  assertCursorAndOrderFieldsScalar(model, cursor, finalOrderEntries);
   const { whereSql: cursorWhereSql } = buildCursorFilterParts(
     cursor,
     srcAlias,
     params,
     model
   );
-  const cursorOrderBy = orderEntries.map(
+  const cursorOrderBy = finalOrderEntries.map(
     (e) => srcAlias + "." + quoteColumn(model, e.field) + " " + e.direction.toUpperCase()
   ).join(", ");
   const selectList = buildCursorCteSelectList(
     cursorEntries,
-    orderEntries,
+    finalOrderEntries,
     model
   );
   const cte = cteName + " AS (\n    SELECT " + selectList + " FROM " + tableName + " " + srcAlias + "\n    WHERE " + cursorWhereSql + "\n    ORDER BY " + cursorOrderBy + "\n    LIMIT 1\n  )";
   const existsExpr = "EXISTS (SELECT 1 FROM " + cteName + ")";
   const orClauses = [];
-  for (let level = 0; level < orderEntries.length; level++) {
+  for (let level = 0; level < finalOrderEntries.length; level++) {
     const andParts = [];
     for (let i = 0; i < level; i++) {
-      const e2 = orderEntries[i];
+      const e2 = finalOrderEntries[i];
       const c2 = col(alias, e2.field, model);
       const cursorField2 = cteName + "." + quoteColumn(model, e2.field);
       andParts.push(buildCursorEqualityExpr(c2, cursorField2));
     }
-    const e = orderEntries[level];
+    const e = finalOrderEntries[level];
     const c = col(alias, e.field, model);
     const cursorField = cteName + "." + quoteColumn(model, e.field);
-    const nulls = (_a = e.nulls) != null ? _a : defaultNullsFor(d, e.direction);
+    const nulls = (_a3 = e.nulls) != null ? _a3 : defaultNullsFor(d, e.direction);
     andParts.push(buildCursorInequalityExpr(c, e.direction, nulls, cursorField));
     orClauses.push("(" + andParts.join(SQL_SEPARATORS.CONDITION_AND) + ")");
   }
@@ -4544,6 +4578,16 @@ function handleJsonWildcard(expr, op, val, params, wildcards, dialect) {
 
 // src/builder/where/relations.ts
 var NO_JOINS = [];
+var SCHEMA_MAP_CACHE = /* @__PURE__ */ new WeakMap();
+function getSchemaByName(schemas) {
+  let map = SCHEMA_MAP_CACHE.get(schemas);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    for (const m of schemas) map.set(m.name, m);
+    SCHEMA_MAP_CACHE.set(schemas, map);
+  }
+  return map;
+}
 function isListRelation(fieldType) {
   return typeof fieldType === "string" && fieldType.endsWith("[]");
 }
@@ -4743,7 +4787,8 @@ function buildRelation(fieldName, value, ctx, whereBuilder) {
       modelName: ctx.model.name
     });
   }
-  const relModel = ctx.schemaModels.find((m) => m.name === field.relatedModel);
+  const schemaMap = getSchemaByName(ctx.schemaModels);
+  const relModel = schemaMap.get(field.relatedModel);
   if (!isNotNullish(relModel)) {
     throw createError(
       `Related model '${field.relatedModel}' not found in schema. Available models: ${ctx.schemaModels.map((m) => m.name).join(", ")}`,
@@ -5074,6 +5119,8 @@ function createAliasGenerator(maxAliases = 1e4) {
   };
 }
 var MAX_PARAM_INDEX = Number.MAX_SAFE_INTEGER - 1e3;
+var _a2;
+var IS_PRODUCTION2 = typeof process !== "undefined" && ((_a2 = process.env) == null ? void 0 : _a2.NODE_ENV) === "production";
 function assertSameLength(params, mappings) {
   if (params.length !== mappings.length) {
     throw new Error(
@@ -5133,6 +5180,11 @@ function validateMappings(mappings) {
   }
 }
 function validateState(params, mappings, index) {
+  if (IS_PRODUCTION2) {
+    assertSameLength(params, mappings);
+    assertValidNextIndex(index);
+    return;
+  }
   assertSameLength(params, mappings);
   assertValidNextIndex(index);
   if (mappings.length === 0) return;
@@ -5287,10 +5339,10 @@ function toPublicResult(clause, joins, params) {
 
 // src/builder/where.ts
 function buildWhereClause(where, options) {
-  var _a, _b, _c, _d, _e;
+  var _a3, _b, _c, _d, _e;
   assertSafeAlias(options.alias);
   const dialect = options.dialect || getGlobalDialect();
-  const params = (_a = options.params) != null ? _a : createParamStore(1, dialect);
+  const params = (_a3 = options.params) != null ? _a3 : createParamStore(1, dialect);
   const ctx = {
     alias: options.alias,
     model: options.model,
@@ -5349,8 +5401,8 @@ function buildDefaultScalarFields(model, alias) {
   return out;
 }
 function getDefaultSelectCached(model, alias) {
-  var _a;
-  return (_a = DEFAULT_SELECT_CACHE.get(model)) == null ? void 0 : _a.get(alias);
+  var _a3;
+  return (_a3 = DEFAULT_SELECT_CACHE.get(model)) == null ? void 0 : _a3.get(alias);
 }
 function cacheDefaultSelect(model, alias, sql) {
   let cache = DEFAULT_SELECT_CACHE.get(model);
@@ -5447,7 +5499,8 @@ function buildRelationSelect(relArgs, relModel, relAlias) {
 }
 
 // src/builder/shared/relation-key-utils.ts
-function resolveRelationKeys(field, context = "include") {
+var RELATION_KEYS_CACHE = /* @__PURE__ */ new WeakMap();
+function computeRelationKeys(field, context) {
   const fkFields = normalizeKeyList(field.foreignKey);
   if (fkFields.length === 0) {
     throw new Error(
@@ -5465,6 +5518,13 @@ function resolveRelationKeys(field, context = "include") {
   const parentKeys = field.isForeignKeyLocal ? fkFields : refFields;
   return { childKeys, parentKeys };
 }
+function resolveRelationKeys(field, context = "include") {
+  let cached = RELATION_KEYS_CACHE.get(field);
+  if (cached) return cached;
+  cached = computeRelationKeys(field, context);
+  RELATION_KEYS_CACHE.set(field, cached);
+  return cached;
+}
 
 // src/builder/shared/relation-extraction-utils.ts
 function extractRelationEntries(args, model) {
@@ -5494,6 +5554,18 @@ function extractRelationEntries(args, model) {
 var MAX_INCLUDE_DEPTH = 5;
 var MAX_INCLUDES_PER_LEVEL = 10;
 var MAX_TOTAL_SUBQUERIES = 100;
+var FIELD_BY_NAME_CACHE2 = /* @__PURE__ */ new WeakMap();
+function getFieldMap(model) {
+  let map = FIELD_BY_NAME_CACHE2.get(model);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    for (const f of model.fields) {
+      map.set(f.name, f);
+    }
+    FIELD_BY_NAME_CACHE2.set(model, map);
+  }
+  return map;
+}
 function buildIncludeScope(includePath) {
   if (includePath.length === 0) return "include";
   let scope = "include";
@@ -5513,7 +5585,8 @@ function getRelationTableReference(relModel, dialect) {
   );
 }
 function resolveRelationOrThrow(model, schemaByName, relName) {
-  const field = model.fields.find((f) => f.name === relName);
+  const fieldMap = getFieldMap(model);
+  const field = fieldMap.get(relName);
   if (!isNotNullish(field)) {
     throw new Error(
       `Unknown relation '${relName}' on model ${model.name}. Available relation fields: ${model.fields.filter((f) => f.isRelation).map((f) => f.name).join(", ")}`
@@ -5630,11 +5703,22 @@ function finalizeOrderByForInclude(args) {
 }
 function buildSelectWithNestedIncludes(relArgs, relModel, relAlias, ctx) {
   let relSelect = buildRelationSelect(relArgs, relModel, relAlias);
-  const nestedIncludes = isPlainObject(relArgs) ? buildIncludeSqlInternal(relArgs, __spreadProps(__spreadValues({}, ctx), {
-    model: relModel,
-    parentAlias: relAlias,
-    depth: ctx.depth + 1
-  })) : [];
+  let nestedIncludes = [];
+  if (isPlainObject(relArgs)) {
+    const prevModel = ctx.model;
+    const prevParentAlias = ctx.parentAlias;
+    const prevDepth = ctx.depth;
+    ctx.model = relModel;
+    ctx.parentAlias = relAlias;
+    ctx.depth = prevDepth + 1;
+    try {
+      nestedIncludes = buildIncludeSqlInternal(relArgs, ctx);
+    } finally {
+      ctx.model = prevModel;
+      ctx.parentAlias = prevParentAlias;
+      ctx.depth = prevDepth;
+    }
+  }
   if (isNonEmptyArray(nestedIncludes)) {
     const emptyJson = ctx.dialect === "postgres" ? `'[]'::json` : `json('[]')`;
     const nestedSelects = nestedIncludes.map(
@@ -6031,16 +6115,22 @@ function buildIncludeSqlInternal(args, ctx) {
         `Circular include detected: ${Array.from(ctx.visitSet).join(" -> ")} -> ${relationPath}. Relation '${relationPath}' creates an infinite loop.`
       );
     }
-    const nextIncludePath = [...ctx.includePath, relName];
-    const nextVisitSet = new Set(ctx.visitSet);
-    nextVisitSet.add(relationPath);
-    includes.push(
-      buildSingleInclude(relName, relArgs, resolved.field, resolved.relModel, __spreadProps(__spreadValues({}, ctx), {
-        includePath: nextIncludePath,
-        visitSet: nextVisitSet,
-        depth
-      }))
-    );
+    ctx.includePath.push(relName);
+    ctx.visitSet.add(relationPath);
+    try {
+      includes.push(
+        buildSingleInclude(
+          relName,
+          relArgs,
+          resolved.field,
+          resolved.relModel,
+          ctx
+        )
+      );
+    } finally {
+      ctx.includePath.pop();
+      ctx.visitSet.delete(relationPath);
+    }
   }
   return includes;
 }
@@ -6324,10 +6414,19 @@ function canUseNestedFlatJoin(relArgs, depth) {
   }
   return true;
 }
-function canUseFlatJoinForAll(includeSpec) {
-  for (const value of Object.values(includeSpec)) {
+function canUseFlatJoinForAll(includeSpec, parentModel, schemas) {
+  const modelMap = new Map(schemas.map((m) => [m.name, m]));
+  for (const [relName, value] of Object.entries(includeSpec)) {
     if (value === false) continue;
+    const field = parentModel.fields.find((f) => f.name === relName);
+    if (!field || !field.isRelation) continue;
     if (!canUseNestedFlatJoin(value, 0)) return false;
+    const relModel = modelMap.get(field.relatedModel);
+    if (!relModel) continue;
+    const nestedSpec = extractNestedIncludeSpec(value, relModel);
+    if (Object.keys(nestedSpec).length > 0) {
+      if (!canUseFlatJoinForAll(nestedSpec, relModel, schemas)) return false;
+    }
   }
   return true;
 }
@@ -6424,7 +6523,7 @@ function buildFlatJoinSql(spec) {
   if (Object.keys(includeSpec).length === 0) {
     return { sql: "", requiresReduction: false, includeSpec: {} };
   }
-  if (!canUseFlatJoinForAll(includeSpec)) {
+  if (!canUseFlatJoinForAll(includeSpec, model, schemas)) {
     return { sql: "", requiresReduction: false, includeSpec: {} };
   }
   const baseJoins = whereJoins.length > 0 ? whereJoins.join(" ") : "";
@@ -6470,6 +6569,217 @@ function buildFlatJoinSql(spec) {
   `.trim();
   return { sql, requiresReduction: true, includeSpec };
 }
+
+// src/builder/select/array-agg.ts
+function canUseArrayAggForAll(includeSpec, parentModel, schemas) {
+  const modelMap = new Map(schemas.map((m) => [m.name, m]));
+  for (const [relName, value] of Object.entries(includeSpec)) {
+    if (value === false) continue;
+    const field = parentModel.fields.find((f) => f.name === relName);
+    if (!field || !field.isRelation) continue;
+    if (isPlainObject(value) && hasChildPagination(value)) return false;
+    const relModel = modelMap.get(field.relatedModel);
+    if (!relModel) continue;
+    const nestedSpec = extractNestedIncludeSpec(value, relModel);
+    if (Object.keys(nestedSpec).length > 0) return false;
+  }
+  return true;
+}
+function getRelationModel2(parentModel, relationName, schemas) {
+  const field = parentModel.fields.find((f) => f.name === relationName);
+  if (!(field == null ? void 0 : field.isRelation) || !field.relatedModel) {
+    throw new Error(`Invalid relation ${relationName} on ${parentModel.name}`);
+  }
+  const relModel = schemas.find((m) => m.name === field.relatedModel);
+  if (!relModel) {
+    throw new Error(`Related model ${field.relatedModel} not found`);
+  }
+  return relModel;
+}
+function buildSubqueryRawSelect2(model, alias) {
+  const cols = [];
+  for (const f of model.fields) {
+    if (f.isRelation) continue;
+    cols.push(`${alias}.${quoteColumn(model, f.name)}`);
+  }
+  return cols.length > 0 ? cols.join(SQL_SEPARATORS.FIELD_LIST) : "*";
+}
+function readWhereInput2(relArgs) {
+  if (!isPlainObject(relArgs)) return {};
+  const obj = relArgs;
+  if (!("where" in obj)) return {};
+  const w = obj.where;
+  return isPlainObject(w) ? w : {};
+}
+function buildArrayAggRelation(args) {
+  const {
+    relationName,
+    relArgs,
+    field,
+    relModel,
+    parentModel,
+    parentAlias,
+    schemas,
+    dialect,
+    aliasCounter,
+    params
+  } = args;
+  const isList = typeof field.type === "string" && field.type.endsWith("[]");
+  const { childKeys: relKeyFields, parentKeys: parentKeyFields } = resolveRelationKeys(field, "include");
+  if (relKeyFields.length === 0) return null;
+  const innerAlias = `__aa_r${aliasCounter.count++}`;
+  const joinAlias = `__aa_j${aliasCounter.count++}`;
+  const indices = getFieldIndices(relModel);
+  const scalarSel = extractScalarSelection(relArgs, relModel);
+  const pkFields = getPrimaryKeyFields(relModel);
+  const selectedFields = scalarSel.includeAllScalars ? Array.from(indices.scalarFields.keys()) : [.../* @__PURE__ */ new Set([...pkFields, ...scalarSel.selectedScalarFields])];
+  const pkOrderExpr = pkFields.map((f) => `${innerAlias}.${quoteColumn(relModel, f)}`).join(SQL_SEPARATORS.FIELD_LIST);
+  const pkFilterExpr = `${innerAlias}.${quoteColumn(relModel, pkFields[0])}`;
+  const fkSelectParts = relKeyFields.map(
+    (f, i) => `${innerAlias}.${quoteColumn(relModel, f)} AS "__fk${i}"`
+  );
+  const aggParts = selectedFields.map((fieldName) => {
+    const f = indices.scalarFields.get(fieldName);
+    if (!f) return null;
+    const colRef = `${innerAlias}.${quoteColumn(relModel, fieldName)}`;
+    const alias = `"${relationName}.${f.name}"`;
+    return `array_agg(${colRef} ORDER BY ${pkOrderExpr}) FILTER (WHERE ${pkFilterExpr} IS NOT NULL) AS ${alias}`;
+  }).filter(Boolean);
+  const fkGroupByParts = relKeyFields.map(
+    (f) => `${innerAlias}.${quoteColumn(relModel, f)}`
+  );
+  const relTable = buildTableReference(
+    SQL_TEMPLATES.PUBLIC_SCHEMA,
+    relModel.tableName,
+    dialect
+  );
+  const whereInput = readWhereInput2(relArgs);
+  let whereJoinsSql = "";
+  let whereClauseSql = "";
+  if (Object.keys(whereInput).length > 0) {
+    const aliasGen = createAliasGenerator();
+    const whereResult = buildWhereClause(whereInput, {
+      alias: innerAlias,
+      schemaModels: schemas,
+      model: relModel,
+      params,
+      isSubquery: true,
+      aliasGen,
+      dialect
+    });
+    if (whereResult.joins.length > 0) {
+      whereJoinsSql = " " + whereResult.joins.join(" ");
+    }
+    if (isValidWhereClause(whereResult.clause)) {
+      whereClauseSql = ` ${SQL_TEMPLATES.WHERE} ${whereResult.clause}`;
+    }
+  }
+  const subquery = `SELECT ${fkSelectParts.join(SQL_SEPARATORS.FIELD_LIST)}${SQL_SEPARATORS.FIELD_LIST}${aggParts.join(SQL_SEPARATORS.FIELD_LIST)} FROM ${relTable} ${innerAlias}${whereJoinsSql}${whereClauseSql} GROUP BY ${fkGroupByParts.join(SQL_SEPARATORS.FIELD_LIST)}`;
+  const onParts = parentKeyFields.map(
+    (f, i) => `${joinAlias}."__fk${i}" = ${parentAlias}.${quoteColumn(parentModel, f)}`
+  );
+  const onCondition = onParts.length === 1 ? onParts[0] : `(${onParts.join(" AND ")})`;
+  const joinSql = `LEFT JOIN (${subquery}) ${joinAlias} ON ${onCondition}`;
+  const selectExprs = selectedFields.map((fieldName) => {
+    const f = indices.scalarFields.get(fieldName);
+    if (!f) return null;
+    return `${joinAlias}."${relationName}.${f.name}"`;
+  }).filter(Boolean);
+  return {
+    joinSql,
+    selectExprs,
+    relationName,
+    isList,
+    scalarFieldNames: selectedFields
+  };
+}
+function buildArrayAggSql(spec) {
+  const {
+    select: select2,
+    from,
+    whereClause,
+    whereJoins,
+    orderBy,
+    dialect,
+    model,
+    schemas,
+    args,
+    params
+  } = spec;
+  const entries = extractRelationEntries(args, model);
+  const includeSpec = {};
+  for (const e of entries) {
+    includeSpec[e.name] = e.value;
+  }
+  if (Object.keys(includeSpec).length === 0) {
+    return {
+      sql: "",
+      requiresReduction: false,
+      includeSpec: {},
+      isArrayAgg: false
+    };
+  }
+  if (!canUseArrayAggForAll(includeSpec, model, schemas)) {
+    return {
+      sql: "",
+      requiresReduction: false,
+      includeSpec: {},
+      isArrayAgg: false
+    };
+  }
+  const baseJoins = whereJoins.length > 0 ? whereJoins.join(" ") : "";
+  const baseWhere = whereClause && whereClause !== "1=1" ? `WHERE ${whereClause}` : "";
+  const baseOrderBy = orderBy ? `ORDER BY ${orderBy}` : "";
+  const subqueryScalarCols = buildSubqueryRawSelect2(model, from.alias);
+  let baseSubquery = `SELECT ${subqueryScalarCols} FROM ${from.table} ${from.alias}` + (baseJoins ? ` ${baseJoins}` : "") + (baseWhere ? ` ${baseWhere}` : "") + (baseOrderBy ? ` ${baseOrderBy}` : "");
+  baseSubquery = appendPagination(baseSubquery.trim(), spec);
+  const aliasCounter = { count: 0 };
+  const joins = [];
+  const arraySelectExprs = [];
+  for (const [relName, relValue] of Object.entries(includeSpec)) {
+    if (relValue === false) continue;
+    const field = model.fields.find((f) => f.name === relName);
+    if (!field || !isValidRelationField(field)) continue;
+    const relModel = getRelationModel2(model, relName, schemas);
+    const built = buildArrayAggRelation({
+      relationName: relName,
+      relArgs: relValue,
+      field,
+      relModel,
+      parentModel: model,
+      parentAlias: from.alias,
+      schemas,
+      dialect,
+      aliasCounter,
+      params
+    });
+    if (!built) continue;
+    joins.push(built.joinSql);
+    arraySelectExprs.push(...built.selectExprs);
+  }
+  if (joins.length === 0) {
+    return {
+      sql: "",
+      requiresReduction: false,
+      includeSpec: {},
+      isArrayAgg: false
+    };
+  }
+  const baseSelect = (select2 != null ? select2 : "").trim();
+  const allSelects = [baseSelect, ...arraySelectExprs].filter((s) => s && s.trim().length > 0).join(SQL_SEPARATORS.FIELD_LIST);
+  if (!allSelects) {
+    throw new Error("Array-agg SELECT requires at least one selected field");
+  }
+  const pkField = getPrimaryKeyField(model);
+  const pkOrder = `${from.alias}.${quoteColumn(model, pkField)} ASC`;
+  const sql = `
+    SELECT ${allSelects}
+    FROM (${baseSubquery}) ${from.alias}
+    ${joins.join(" ")}
+    ORDER BY ${pkOrder}
+  `.trim();
+  return { sql, requiresReduction: true, includeSpec, isArrayAgg: true };
+}
 var SELECT_FIELD_REGEX = /^\s*("(?:[^"]|"")+"|[a-z_][a-z0-9_]*)\s*\.\s*("(?:[^"]|"")+"|[a-z_][a-z0-9_]*)(?:\s+AS\s+("(?:[^"]|"")+"|[a-z_][a-z0-9_]*))?\s*$/i;
 function buildWhereSql(conditions) {
   if (!isNonEmptyArray(conditions)) return "";
@@ -6557,47 +6867,45 @@ function buildOutputColumns(scalarNames, includeNames, hasCount) {
   }
   return formatted;
 }
-function buildWindowOrder(args) {
-  const { baseOrder, idField, fromAlias, model } = args;
-  const fromLower = String(fromAlias).toLowerCase();
-  const orderFields = baseOrder.split(SQL_SEPARATORS.ORDER_BY).map((s) => s.trim().toLowerCase().replace(/\s+/g, " "));
-  const hasIdInOrder = orderFields.some((f) => {
-    return f.includes(`${fromLower}.id`) || f.includes(`${fromLower}."id"`);
-  });
-  if (hasIdInOrder) return baseOrder;
-  const idTiebreaker = idField ? ", " + col(fromAlias, "id", model) + " ASC" : "";
-  return baseOrder + idTiebreaker;
-}
-function extractDistinctOrderEntries(spec) {
-  if (isNotNullish(spec.args.orderBy)) {
-    const normalized = normalizeOrderByInput(
-      spec.args.orderBy,
-      parseOrderByValue
-    );
-    const entries = [];
-    for (const item of normalized) {
-      for (const field in item) {
-        if (!Object.prototype.hasOwnProperty.call(item, field)) continue;
-        const value = item[field];
-        if (typeof value === "string") {
-          entries.push({ field, direction: value });
-          continue;
-        }
-        const obj = value;
-        entries.push({ field, direction: obj.direction, nulls: obj.nulls });
+function getOrderByEntries(spec) {
+  if (!isNotNullish(spec.args.orderBy)) return [];
+  const normalized = normalizeOrderByInput(spec.args.orderBy, parseOrderByValue);
+  const entries = [];
+  for (const item of normalized) {
+    for (const field in item) {
+      if (!Object.prototype.hasOwnProperty.call(item, field)) continue;
+      const value = item[field];
+      if (typeof value === "string") {
+        entries.push({ field, direction: value });
+        continue;
       }
+      const obj = value;
+      entries.push({ field, direction: obj.direction, nulls: obj.nulls });
     }
-    if (entries.length > 0) return entries;
   }
-  if (isNotNullish(spec.distinct) && isNonEmptyArray(spec.distinct)) {
-    return [...spec.distinct].map((f) => ({
-      field: f,
-      direction: "asc"
-    }));
+  return entries;
+}
+function renderOrderBySql(entries, alias, dialect, model) {
+  if (entries.length === 0) return "";
+  const out = [];
+  for (const e of entries) {
+    const dir = e.direction.toUpperCase();
+    const c = col(alias, e.field, model);
+    if (dialect === "postgres") {
+      const nulls = isNotNullish(e.nulls) ? ` NULLS ${e.nulls.toUpperCase()}` : "";
+      out.push(c + " " + dir + nulls);
+    } else if (isNotNullish(e.nulls)) {
+      const isNullExpr = `(${c} IS NULL)`;
+      const nullRankDir = e.nulls === "first" ? "DESC" : "ASC";
+      out.push(isNullExpr + " " + nullRankDir);
+      out.push(c + " " + dir);
+    } else {
+      out.push(c + " " + dir);
+    }
   }
-  return [];
+  return out.join(SQL_SEPARATORS.ORDER_BY);
 }
-function buildFieldNameOrderBy(entries, alias) {
+function renderOrderBySimple(entries, alias) {
   if (entries.length === 0) return "";
   const out = [];
   for (const e of entries) {
@@ -6608,40 +6916,73 @@ function buildFieldNameOrderBy(entries, alias) {
       const nullRankDir = e.nulls === "first" ? "DESC" : "ASC";
       out.push(isNullExpr + " " + nullRankDir);
       out.push(c + " " + dir);
-      continue;
+    } else {
+      out.push(c + " " + dir);
     }
-    out.push(c + " " + dir);
   }
   return out.join(SQL_SEPARATORS.ORDER_BY);
 }
+function ensureIdTiebreakerEntries(entries, model) {
+  var _a3, _b;
+  const idField = (_b = (_a3 = model == null ? void 0 : model.fields) == null ? void 0 : _a3.find) == null ? void 0 : _b.call(
+    _a3,
+    (f) => f.name === "id" && !f.isRelation
+  );
+  if (!idField) return entries;
+  if (entries.some((e) => e.field === "id")) return entries;
+  return [...entries, { field: "id", direction: "asc" }];
+}
+function ensurePostgresDistinctOrderEntries(args) {
+  const { entries, distinct, model } = args;
+  const distinctEntries = [...distinct].map((f) => ({
+    field: f,
+    direction: "asc"
+  }));
+  const canKeepAsIs = entries.length >= distinctEntries.length && distinctEntries.every((de, i) => entries[i].field === de.field);
+  const merged = canKeepAsIs ? entries : [...distinctEntries, ...entries];
+  return ensureIdTiebreakerEntries(merged, model);
+}
+function extractDistinctOrderEntries(spec) {
+  const entries = getOrderByEntries(spec);
+  if (entries.length > 0) return entries;
+  if (isNotNullish(spec.distinct) && isNonEmptyArray(spec.distinct)) {
+    return [...spec.distinct].map((f) => ({
+      field: f,
+      direction: "asc"
+    }));
+  }
+  return [];
+}
 function buildSqliteDistinctQuery(spec, selectWithIncludes, countJoins) {
-  var _a, _b;
-  const { includes, from, whereClause, whereJoins, orderBy, distinct, model } = spec;
+  var _a3, _b;
+  const { includes, from, whereClause, whereJoins, distinct, model } = spec;
   if (!isNotNullish(distinct) || !isNonEmptyArray(distinct)) {
     throw new Error("buildSqliteDistinctQuery requires distinct fields");
   }
   const scalarNames = parseSimpleScalarSelect(spec.select, from.alias);
   const includeNames = includes.map((i) => i.name);
-  const hasCount = Boolean((_b = (_a = spec.args) == null ? void 0 : _a.select) == null ? void 0 : _b._count);
+  const hasCount = Boolean((_b = (_a3 = spec.args) == null ? void 0 : _a3.select) == null ? void 0 : _b._count);
   const outerSelectCols = buildOutputColumns(
     scalarNames,
     includeNames,
     hasCount
   );
   const distinctCols = buildDistinctColumns([...distinct], from.alias, model);
-  const fallbackOrder = [...distinct].map((f) => col(from.alias, f, model) + " ASC").join(SQL_SEPARATORS.FIELD_LIST);
-  const idField = model.fields.find(
-    (f) => f.name === "id" && !f.isRelation
-  );
-  const baseOrder = isNonEmptyString(orderBy) ? orderBy : fallbackOrder;
-  const windowOrder = buildWindowOrder({
-    baseOrder,
-    idField,
-    fromAlias: from.alias,
+  const baseEntries = getOrderByEntries(spec);
+  const fallbackEntries = [...distinct].map((f) => ({
+    field: f,
+    direction: "asc"
+  }));
+  const resolvedEntries = baseEntries.length > 0 ? baseEntries : fallbackEntries;
+  const windowEntries = ensureIdTiebreakerEntries(resolvedEntries, model);
+  const windowOrder = renderOrderBySql(
+    windowEntries,
+    from.alias,
+    "sqlite",
     model
-  });
+  );
   const outerEntries = extractDistinctOrderEntries(spec);
-  const outerOrder = buildFieldNameOrderBy(outerEntries, '"__tp_distinct"');
+  const outerOrder = renderOrderBySimple(outerEntries, '"__tp_distinct"');
   const joins = buildJoinsSql(whereJoins, countJoins);
   const conditions = [];
   if (whereClause && whereClause !== "1=1") conditions.push(whereClause);
@@ -6692,12 +7033,12 @@ function resolveCountSelect(countSelectRaw, model) {
   return null;
 }
 function buildIncludeColumns(spec) {
-  var _a, _b;
+  var _a3, _b;
   const { select: select2, includes, dialect, model, schemas, from, params } = spec;
   const baseSelect = (select2 != null ? select2 : "").trim();
   let countCols = "";
   let countJoins = [];
-  const countSelectRaw = (_b = (_a = spec.args) == null ? void 0 : _a.select) == null ? void 0 : _b._count;
+  const countSelectRaw = (_b = (_a3 = spec.args) == null ? void 0 : _a3.select) == null ? void 0 : _b._count;
   if (countSelectRaw) {
     const resolvedCountSelect = resolveCountSelect(countSelectRaw, model);
     if (resolvedCountSelect && Object.keys(resolvedCountSelect).length > 0) {
@@ -6856,37 +7197,6 @@ function extractIncludeSpec(args) {
 function hasNestedIncludes(includeSpec) {
   return Object.keys(includeSpec).length > 0;
 }
-function splitOrderByTerms(orderBy) {
-  const raw = orderBy.trim();
-  if (raw.length === 0) return [];
-  return raw.split(SQL_SEPARATORS.ORDER_BY).map((s) => s.trim()).filter((s) => s.length > 0);
-}
-function hasIdInOrderBy(orderBy, fromAlias) {
-  const lower = orderBy.toLowerCase();
-  const aliasLower = fromAlias.toLowerCase();
-  return lower.includes(`${aliasLower}.id `) || lower.includes(`${aliasLower}."id"`);
-}
-function ensureIdTiebreakerOrderBy(orderBy, fromAlias, model) {
-  var _a, _b;
-  const idField = (_b = (_a = model == null ? void 0 : model.fields) == null ? void 0 : _a.find) == null ? void 0 : _b.call(
-    _a,
-    (f) => f.name === "id" && !f.isRelation
-  );
-  if (!idField) return orderBy;
-  if (hasIdInOrderBy(orderBy, fromAlias)) return orderBy;
-  const t = col(fromAlias, "id", model) + " ASC";
-  return isNonEmptyString(orderBy) ? orderBy + ", " + t : t;
-}
-function ensurePostgresDistinctOrderBy(args) {
-  const { orderBy, distinct, fromAlias, model } = args;
-  const distinctTerms = distinct.map((f) => col(fromAlias, f, model) + " ASC");
-  const existing = splitOrderByTerms(orderBy);
-  const canKeepAsIs = existing.length >= distinctTerms.length && distinctTerms.every(
-    (term, i) => existing[i].toLowerCase().startsWith(term.split(" ASC")[0].toLowerCase())
-  );
-  const merged = canKeepAsIs ? orderBy : [...distinctTerms, ...existing].join(SQL_SEPARATORS.ORDER_BY);
-  return ensureIdTiebreakerOrderBy(merged, fromAlias, model);
-}
 function constructFinalSql(spec) {
   const {
     select: select2,
@@ -6901,7 +7211,6 @@ function constructFinalSql(spec) {
     params,
     dialect,
     model,
-    includes,
     schemas,
     pagination,
     args
@@ -6913,7 +7222,24 @@ function constructFinalSql(spec) {
   const includeSpec = extractIncludeSpec(args);
   const hasIncludes = hasNestedIncludes(includeSpec);
   const hasPagination = isNotNullish(pagination.take);
-  const shouldUseFlatJoin = dialect === "postgres" && hasPagination && hasIncludes && canUseFlatJoinForAll(includeSpec);
+  const takeValue = typeof pagination.take === "number" ? pagination.take : null;
+  const isLargeTake = takeValue !== null && takeValue > 50;
+  const shouldUseArrayAgg = dialect === "postgres" && hasIncludes && method === "findMany" && hasPagination && isLargeTake && canUseArrayAggForAll(includeSpec, model, schemas);
+  if (shouldUseArrayAgg) {
+    const aaResult = buildArrayAggSql(spec);
+    if (aaResult.sql) {
+      const baseSqlResult = finalizeSql(aaResult.sql, params, dialect);
+      return {
+        sql: baseSqlResult.sql,
+        params: baseSqlResult.params,
+        paramMappings: baseSqlResult.paramMappings,
+        requiresReduction: true,
+        includeSpec: aaResult.includeSpec,
+        isArrayAgg: true
+      };
+    }
+  }
+  const shouldUseFlatJoin = dialect === "postgres" && hasPagination && hasIncludes && canUseFlatJoinForAll(includeSpec, model, schemas);
   if (shouldUseFlatJoin) {
     const flatResult = buildFlatJoinSql(spec);
     if (flatResult.sql) {
@@ -6959,12 +7285,13 @@ function constructFinalSql(spec) {
   pushWhere(parts, conditions);
   let finalOrderBy = orderBy;
   if (dialect === "postgres" && isNonEmptyArray(distinct)) {
-    finalOrderBy = ensurePostgresDistinctOrderBy({
-      orderBy: orderBy || "",
+    const currentEntries = getOrderByEntries(spec);
+    const mergedEntries = ensurePostgresDistinctOrderEntries({
+      entries: currentEntries.length > 0 ? currentEntries : [],
       distinct: [...distinct],
-      fromAlias: from.alias,
       model
     });
+    finalOrderBy = renderOrderBySql(mergedEntries, from.alias, dialect, model);
   }
   if (isNonEmptyString(finalOrderBy))
     parts.push(SQL_TEMPLATES.ORDER_BY, finalOrderBy);
@@ -6990,11 +7317,11 @@ function mapFirstOrderByByField(existing) {
   return m;
 }
 function buildPostgresDistinctOrderBy(distinctFields, existing) {
-  var _a;
+  var _a3;
   const firstByField = mapFirstOrderByByField(existing);
   const next = [];
   for (const f of distinctFields) {
-    next.push((_a = firstByField.get(f)) != null ? _a : { [f]: "asc" });
+    next.push((_a3 = firstByField.get(f)) != null ? _a3 : { [f]: "asc" });
   }
   const distinctSet = new Set(distinctFields);
   for (const obj of existing) {
@@ -7820,10 +8147,10 @@ function isPrismaMethod(v) {
   return v === "findMany" || v === "findFirst" || v === "findUnique" || v === "aggregate" || v === "groupBy" || v === "count";
 }
 function resolveMethod(directive) {
-  var _a, _b;
+  var _a3, _b;
   const m = directive == null ? void 0 : directive.method;
   if (isPrismaMethod(m)) return m;
-  const pm = (_b = (_a = directive == null ? void 0 : directive.query) == null ? void 0 : _a.processed) == null ? void 0 : _b.method;
+  const pm = (_b = (_a3 = directive == null ? void 0 : directive.query) == null ? void 0 : _a3.processed) == null ? void 0 : _b.method;
   if (isPrismaMethod(pm)) return pm;
   return "findMany";
 }
@@ -7984,7 +8311,7 @@ function extractIncludeSpec2(processed, modelDef) {
   return includeSpec;
 }
 function buildAndNormalizeSql(args) {
-  var _a;
+  var _a3;
   const {
     method,
     processed,
@@ -8010,13 +8337,15 @@ function buildAndNormalizeSql(args) {
     sqlResult.paramMappings,
     dialect
   );
-  const includeSpec = (_a = sqlResult.includeSpec && isPlainObject(sqlResult.includeSpec) ? sqlResult.includeSpec : null) != null ? _a : extractIncludeSpec2(processed, modelDef);
+  const includeSpec = (_a3 = sqlResult.includeSpec && isPlainObject(sqlResult.includeSpec) ? sqlResult.includeSpec : null) != null ? _a3 : extractIncludeSpec2(processed, modelDef);
   const requiresReduction = sqlResult.requiresReduction === true;
+  const isArrayAgg = sqlResult.isArrayAgg === true;
   return {
     sql: normalized.sql,
     paramMappings: normalized.paramMappings,
     requiresReduction,
-    includeSpec
+    includeSpec,
+    isArrayAgg
   };
 }
 function finalizeDirective(args) {
@@ -8027,11 +8356,12 @@ function finalizeDirective(args) {
     normalizedMappings,
     dialect,
     requiresReduction,
-    includeSpec
+    includeSpec,
+    isArrayAgg
   } = args;
   const params = normalizedMappings.map((m) => {
-    var _a;
-    return (_a = m.value) != null ? _a : void 0;
+    var _a3;
+    return (_a3 = m.value) != null ? _a3 : void 0;
   });
   validateParamConsistencyByDialect(normalizedSql, params, dialect);
   const { staticParams, dynamicKeys, paramOrder } = buildParamsFromMappings(normalizedMappings);
@@ -8044,6 +8374,7 @@ function finalizeDirective(args) {
     paramMappings: normalizedMappings,
     requiresReduction,
     includeSpec,
+    isArrayAgg,
     originalDirective: directive
   };
 }
@@ -8077,7 +8408,8 @@ function generateSQL(directive) {
     normalizedMappings: built.paramMappings,
     dialect,
     requiresReduction: built.requiresReduction,
-    includeSpec: built.includeSpec
+    includeSpec: built.includeSpec,
+    isArrayAgg: built.isArrayAgg
   });
 }
 
@@ -8732,7 +9064,8 @@ function processModelDirectives(modelName, result, config) {
         dynamicKeys: sqlDirective.dynamicKeys,
         paramMappings: sqlDirective.paramMappings,
         requiresReduction: sqlDirective.requiresReduction || false,
-        includeSpec: sqlDirective.includeSpec || {}
+        includeSpec: sqlDirective.includeSpec || {},
+        isArrayAgg: sqlDirective.isArrayAgg || false
       });
     } catch (error) {
       if (!config.skipInvalid) throw error;
@@ -8760,9 +9093,9 @@ function processAllModelDirectives(directiveResults, config) {
 }
 function generateClient(options) {
   return __async(this, null, function* () {
-    var _a;
+    var _a3;
     const { datamodel, outputDir, config, datasourceUrl } = options;
-    const runtimeImportPath = (_a = options.runtimeImportPath) != null ? _a : "prisma-sql";
+    const runtimeImportPath = (_a3 = options.runtimeImportPath) != null ? _a3 : "prisma-sql";
     setGlobalDialect(config.dialect);
     const models = schemaParser.convertDMMFToModels(datamodel);
     const directiveResults = schemaParser.processAllDirectives(
@@ -8842,8 +9175,6 @@ function generateClient(options) {
 }
 function generateImports(runtimeImportPath) {
   return `import { 
-  transformAggregateRow, 
-  extractCountValue, 
   buildSQL, 
   buildBatchSql, 
   parseBatchResults, 
@@ -8855,7 +9186,6 @@ function generateImports(runtimeImportPath) {
   planQueryStrategy, 
   executeWhereInSegments,
   buildReducerConfig,
-  reduceFlatRows,
   type PrismaMethod, 
   type Model, 
   type BatchQuery, 
@@ -8863,13 +9193,11 @@ function generateImports(runtimeImportPath) {
   type TransactionQuery, 
   type TransactionOptions,
   getOrPrepareStatement,
-  shouldSqliteUseGet,
   normalizeParams,
   executePostgresQuery,
   executeSqliteQuery,
   executeRaw,
-} from ${JSON.stringify(runtimeImportPath)}
-import { RELATION_STATS } from './planner.generated'`;
+} from ${JSON.stringify(runtimeImportPath)}`;
 }
 function generateCoreTypes() {
   return `class DeferredQuery {
@@ -8998,6 +9326,7 @@ const QUERIES: Record<string, Record<string, Record<string, {
   paramMappings: any[]
   requiresReduction: boolean
   includeSpec: Record<string, any>
+  isArrayAgg: boolean
 }>>> = ${formatQueries(queries)}
 
 const DIALECT = ${JSON.stringify(dialect)}
@@ -9220,9 +9549,10 @@ function generateExtension(runtimeImportPath) {
     requiresReduction: boolean,
     includeSpec: Record<string, any> | undefined,
     model: any | undefined,
+    isArrayAgg?: boolean,
   ): Promise<unknown[]> {
     if (DIALECT === 'postgres') {
-      return executePostgresQuery(client, sql, params, method, requiresReduction, includeSpec, model, MODELS)
+      return executePostgresQuery(client, sql, params, method, requiresReduction, includeSpec, model, MODELS, isArrayAgg)
     }
     
     return executeSqliteQuery(client, sql, params, method, requiresReduction, includeSpec, model, MODELS)
@@ -9293,7 +9623,6 @@ function generateExtension(runtimeImportPath) {
           method,
           args: transformedArgs,
           allModels: MODELS,
-          relationStats: RELATION_STATS as any,
           dialect: DIALECT,
         })
 
@@ -9304,6 +9633,7 @@ function generateExtension(runtimeImportPath) {
         let prebaked = false
         let requiresReduction = false
         let includeSpec: Record<string, any> | undefined
+        let isArrayAgg = false
 
         if (prebakedQuery) {
           sql = prebakedQuery.sql
@@ -9311,17 +9641,19 @@ function generateExtension(runtimeImportPath) {
           prebaked = true
           requiresReduction = prebakedQuery.requiresReduction || false
           includeSpec = prebakedQuery.includeSpec
+          isArrayAgg = prebakedQuery.isArrayAgg || false
         } else {
           const result = buildSQL(model, MODELS, method, plan.filteredArgs, DIALECT)
           sql = result.sql
           params = result.params as unknown[]
           requiresReduction = result.requiresReduction || false
           includeSpec = result.includeSpec
+          isArrayAgg = result.isArrayAgg || false
         }
 
         if (debug) {
           const strategy = DIALECT === 'postgres'
-            ? (requiresReduction ? 'STREAMING REDUCTION' : 'STREAMING')
+            ? (isArrayAgg ? 'ARRAY AGG' : requiresReduction ? 'STREAMING REDUCTION' : 'STREAMING')
             : (requiresReduction ? 'BUFFERED REDUCTION' : 'DIRECT')
           
           const whereInMode = plan.whereInSegments.length > 0
@@ -9334,63 +9666,75 @@ function generateExtension(runtimeImportPath) {
           console.log('  Params:', params)
         }
 
-        let results = await executeQuery(sql, params, method, requiresReduction, includeSpec, model)
-        
-        const duration = Date.now() - startTime
+        if (plan.whereInSegments.length > 0) {
+          if (DIALECT === 'postgres') {
+            const { executeWhereInSegmentsStreaming } = await import(${JSON.stringify(runtimeImportPath)})
+            
+            const results = await executeWhereInSegmentsStreaming({
+              segments: plan.whereInSegments,
+              parentSql: sql,
+              parentParams: normalizeParams(params),
+              parentModel: model,
+              allModels: MODELS,
+              modelMap: MODEL_MAP,
+              dialect: DIALECT,
+              execute: async (sql: string, params: unknown[]) => {
+                const results: any[] = []
+                await client.unsafe(sql, normalizeParams(params)).forEach((row: any) => {
+                  results.push(row)
+                })
+                return results
+              },
+            })
 
-        onQuery?.({
-          model: modelName,
-          method,
-          sql,
-          params,
-          duration,
-          prebaked,
-        })
+            if (plan.injectedParentKeys.length > 0) {
+              for (const row of results) {
+                for (const key of plan.injectedParentKeys) {
+                  delete row[key]
+                }
+              }
+            }
 
-        let transformed = transformQueryResults(method, results)
+            const duration = Date.now() - startTime
+            onQuery?.({ model: modelName, method, sql, params, duration, prebaked })
 
-        if (plan.whereInSegments.length > 0) {
-          const resultArray = Array.isArray(transformed) ? transformed : [transformed]
+            return transformQueryResults(method, results)
+          } else {
+            const parentRows = await executeQuery(sql, params, method, requiresReduction, includeSpec, model, isArrayAgg) as any[]
 
-          if (resultArray.length > 0 && resultArray[0] != null) {
-            if (DIALECT === 'postgres') {
-              const { executeWhereInSegmentsStreaming } = await import(${JSON.stringify(runtimeImportPath)})
-              
-              const streamResults = await executeWhereInSegmentsStreaming({
-                segments: plan.whereInSegments,
-                parentSql: sql,
-                parentParams: params,
-                parentModel: model,
-                allModels: MODELS,
-                modelMap: MODEL_MAP,
-                dialect: DIALECT,
-                execute: async (sql: string, params: unknown[]) => {
-                  const results: any[] = []
-                  await client.unsafe(sql, normalizeParams(params)).forEach((row: any) => {
-                    results.push(row)
-                  })
-                  return results
-                },
-                batchSize: 100,
-                maxConcurrency: 10
-              })
-              
-              transformed = Array.isArray(transformed) ? streamResults : streamResults[0]
-            } else {
+            if (parentRows.length > 0) {
               await executeWhereInSegments({
                 segments: plan.whereInSegments,
-                parentRows: resultArray,
+                parentRows,
                 parentModel: model,
                 allModels: MODELS,
                 modelMap: MODEL_MAP,
                 dialect: DIALECT,
                 execute: executeWhereInQuery,
               })
+
+              if (plan.injectedParentKeys.length > 0) {
+                for (const row of parentRows) {
+                  for (const key of plan.injectedParentKeys) {
+                    delete row[key]
+                  }
+                }
+              }
             }
+
+            const duration = Date.now() - startTime
+            onQuery?.({ model: modelName, method, sql, params, duration, prebaked })
+
+            return transformQueryResults(method, parentRows)
           }
         }
 
-        return transformed
+        const results = await executeQuery(sql, params, method, requiresReduction, includeSpec, model, isArrayAgg)
+        
+        const duration = Date.now() - startTime
+        onQuery?.({ model: modelName, method, sql, params, duration, prebaked })
+
+        return transformQueryResults(method, results)
       } catch (error) {
         const msg = error instanceof Error ? error.message : String(error)
         console.warn(\`[prisma-sql] \${modelName}.\${method} acceleration failed: \${msg}\`)
@@ -9431,7 +9775,6 @@ function generateExtension(runtimeImportPath) {
         method: 'findMany',
         args: transformedArgs,
         allModels: MODELS,
-        relationStats: RELATION_STATS as any,
         dialect: DIALECT,
       })
       
@@ -9442,23 +9785,39 @@ function generateExtension(runtimeImportPath) {
       let params: unknown[]
       let requiresReduction = false
       let includeSpec: Record<string, any> | undefined
+      let isArrayAgg = false
       
       if (prebakedQuery) {
         sql = prebakedQuery.sql
         params = resolveParamsFromMappings(plan.filteredArgs, prebakedQuery.paramMappings)
         requiresReduction = prebakedQuery.requiresReduction
         includeSpec = prebakedQuery.includeSpec
+        isArrayAgg = prebakedQuery.isArrayAgg || false
       } else {
         const result = buildSQL(model, MODELS, 'findMany', plan.filteredArgs, DIALECT)
         sql = result.sql
         params = result.params as unknown[]
         requiresReduction = result.requiresReduction || false
         includeSpec = result.includeSpec
+        isArrayAgg = result.isArrayAgg || false
       }
       
       const normalizedParams = normalizeParams(params)
       
-      if (requiresReduction && includeSpec) {
+      if (isArrayAgg && includeSpec) {
+        const { buildArrayAggReducerConfig, reduceArrayAggRows } = await import(${JSON.stringify(runtimeImportPath)})
+        const config = buildArrayAggReducerConfig(model, includeSpec, MODELS)
+        const results: any[] = []
+
+        await client.unsafe(sql, normalizedParams).forEach((row: any) => {
+          results.push(row)
+        })
+
+        const reduced = reduceArrayAggRows(results, config)
+        for (const item of reduced) {
+          yield item
+        }
+      } else if (requiresReduction && includeSpec) {
         const { createProgressiveReducer } = await import(${JSON.stringify(runtimeImportPath)})
         const config = buildReducerConfig(model, includeSpec, MODELS)
         const reducer = createProgressiveReducer(config)
@@ -9721,8 +10080,7 @@ function generateCode(models, queries, dialect, datamodel, runtimeImportPath) {
     generateDataConstants(cleanModels, mappings, fieldTypes, queries, dialect),
     generateTransformLogic(),
     generateExtension(runtimeImportPath),
-    generateTypeExports(),
-    `export * from './planner.generated'`
+    generateTypeExports()
   ].join("\n\n");
 }
 function formatQueries(queries) {
@@ -9742,6 +10100,7 @@ function formatQueries(queries) {
       paramMappings: ${JSON.stringify(query.paramMappings)},
       requiresReduction: ${query.requiresReduction || false},
       includeSpec: ${JSON.stringify(query.includeSpec || {})},
+      isArrayAgg: ${query.isArrayAgg || false},
     }`);
       }
       methodEntries.push(`    ${JSON.stringify(method)}: {
@@ -9767,9 +10126,9 @@ function getDialectFromProvider(provider) {
   );
 }
 function getOutputDir(options) {
-  var _a, _b;
+  var _a3, _b;
   const schemaDir = path.dirname(options.schemaPath);
-  if ((_a = options.generator.output) == null ? void 0 : _a.value) {
+  if ((_a3 = options.generator.output) == null ? void 0 : _a3.value) {
     return path.resolve(schemaDir, options.generator.output.value);
   }
   const clientGenerator = options.otherGenerators.find(