velocious 1.0.582 → 1.0.583

package/README.md

@@ -23,8 +23,8 @@
 * Gap-less positional lists with automatic reordering via `actsAsList`, including models with numeric, string, or UUID primary keys (see [docs/acts-as-list.md](docs/acts-as-list.md))
 * Rails-style nested-attribute writes on frontend-model `save()` (see [docs/nested-attributes.md](docs/nested-attributes.md))
 * Async-aware test-data factories with inherited traits, graph-first native association autosave, metadata-aware override precedence, callbacks, sequences, and linting (see [docs/factories.md](docs/factories.md))
-* Per-row association counts via `.withCount(...)`, including cohort-safe intersected filters and safe batching of structurally identical aggregates, on frontend and backend queries (see [docs/with-count.md](docs/with-count.md))
-* Consumer-defined per-row SQL aggregates/computations via `.queryData(...)`, with compatible projections sharing a roundtrip while preserving declared alias-overwrite order, on frontend and backend queries (see [docs/query-data.md](docs/query-data.md))
+* Per-row association counts via `.withCount(...)`, including cohort-safe intersected filters, safe batching of structurally identical aggregates, and automatic IN-list chunking for large parent sets, on frontend and backend queries (see [docs/with-count.md](docs/with-count.md))
+* Consumer-defined per-row SQL aggregates/computations via `.queryData(...)`, with compatible projections sharing a roundtrip while preserving declared alias-overwrite order and automatic IN-list chunking for large parent sets, on frontend and backend queries (see [docs/query-data.md](docs/query-data.md))
 * Per-record ability checks via `.abilities(...)` on frontend queries + `record.can(action)` (see [docs/abilities.md](docs/abilities.md))
 * Translated model attributes with current-locale relationship sorting (see [docs/translations.md](docs/translations.md))
 * Cross-process broadcast bus for `broadcastToChannel` via `velocious beacon`, including background job runner processes (see [docs/beacon.md](docs/beacon.md))

package/build/configuration-types.js

@@ -75,6 +75,8 @@
  * @property {boolean} [multipleStatements] - (MySQL) Opt in to multi-statement queries so a whole structure SQL dump loads in one round-trip via `StructureSqlLoader`. Off by default; ordinary queries otherwise reject stacked statements.
  * @property {number} [maxRowsPerInsert] - Maximum rows per `INSERT ... VALUES (...), (...), ...` statement generated by `Record.insertMultiple`. Defaults to 500.
  * @property {number} [maxInsertSqlBytes] - Maximum serialized SQL size, in bytes, for a single `INSERT ... VALUES (...), (...), ...` statement. Defaults to 1 MiB (1048576).
+ * @property {number} [maxInClauseValues] - Maximum values in a single `IN (...)` cohort used by preloads, association counts, and queryData aggregates. Defaults to 999.
+ * @property {number} [maxQuerySqlBytes] - Maximum serialized SQL size, in bytes, for a single cohort query used by preloads, association counts, and queryData aggregates. Defaults to 1 MiB (1048576).
  * @property {string} [password] - Password for the database user.
  * @property {number} [port] - Database port.
  * @property {string} [primaryKeyType] - Default type for implicit migration primary keys and references. Defaults to `uuid`.

package/build/database/drivers/base.js

@@ -806,10 +806,82 @@ export default class VelociousDatabaseDriversBase {
     return optionalPositiveInteger(this.getArgs().maxInsertSqlBytes, "maxInsertSqlBytes") ?? 1048576
   }
 
+  /**
+   * Maximum values in a single `IN (...)` cohort used by preloads, association
+   * counts, and queryData aggregates. The default stays under SQLite's default
+   * `MAX_VARIABLE_NUMBER` compile-time limit.
+   *
+   * Override via `maxInClauseValues` in the database configuration.
+   * @returns {number} - Maximum values per IN clause cohort.
+   */
+  maxInClauseValues() {
+    return optionalPositiveInteger(this.getArgs().maxInClauseValues, "maxInClauseValues") ?? 999
+  }
+
+  /**
+   * Maximum serialized SQL size, in bytes, for a single cohort query used by
+   * preloads, association counts, and queryData aggregates. Cohort chunking
+   * stops when the next value would push the generated string over this threshold.
+   *
+   * Override via `maxQuerySqlBytes` in the database configuration.
+   * @returns {number} - Maximum bytes per cohort query.
+   */
+  maxQuerySqlBytes() {
+    return optionalPositiveInteger(this.getArgs().maxQuerySqlBytes, "maxQuerySqlBytes") ?? 1048576
+  }
+
+  /**
+   * Splits `values` into cohort chunks that stay within both `maxCount` and
+   * `maxBytes` while preserving order.
+   *
+   * A chunk always contains at least one value, even if that single value exceeds
+   * the byte limit, so progress is guaranteed.
+   * @template T
+   * @param {Array<T>} values - Values to chunk.
+   * @param {(values: Array<T>) => string} buildSql - Function that builds the full SQL for a candidate chunk.
+   * @param {{maxCount?: number, maxBytes?: number}} [options] - Chunking bounds.
+   * @returns {Array<Array<T>>} - Value cohorts.
+   */
+  chunkValues(values, buildSql, {maxCount = this.maxInClauseValues(), maxBytes = this.maxQuerySqlBytes()} = {}) {
+    if (values.length === 0) return []
+
+    /**
+     * Chunks.
+     * @type {Array<Array<T>>} */
+    const chunks = []
+    /**
+     * Current chunk.
+     * @type {Array<T>} */
+    let currentChunk = []
+
+    for (const value of values) {
+      const candidate = [...currentChunk, value]
+      const candidateBytes = Buffer.byteLength(buildSql(candidate), "utf8")
+
+      if (currentChunk.length > 0 && (candidate.length > maxCount || candidateBytes > maxBytes)) {
+        chunks.push(currentChunk)
+        currentChunk = [value]
+      } else {
+        currentChunk = candidate
+      }
+    }
+
+    if (currentChunk.length > 0) {
+      chunks.push(currentChunk)
+    }
+
+    return chunks
+  }
+
   /**
    * Splits `rows` into chunks that stay within both {@link maxRowsPerInsert}
    * and {@link maxInsertSqlBytes} while preserving order.
    *
+   * Byte accounting is incremental: `buildSql` is called once with `[]` to
+   * measure the statement prefix and once per row with `[row]` to measure the
+   * row's values tuple. This keeps chunking linear in the number of rows
+   * instead of rebuilding the full multi-row SQL for every candidate.
+   *
    * A chunk always contains at least one row, even if that single row exceeds
    * the byte limit, so progress is guaranteed.
    * @param {Array<Array<ReturnType<typeof JSON.parse>>>} rows - Rows to insert.
@@ -824,6 +896,9 @@ export default class VelociousDatabaseDriversBase {
     const prefix = `${emptySql} VALUES `
     const baseByteLength = Buffer.byteLength(prefix, "utf8")
 
+    /**
+     * Current chunk.
+     * @type {Array<Array<ReturnType<typeof JSON.parse>>>} */
     let currentChunk = []
     let currentBytes = 0
 

package/build/database/query/preloader/belongs-to.js

@@ -87,25 +87,27 @@ export default class VelociousDatabaseQueryPreloaderBelongsTo {
     if (foreignKeyValues.size > 0) {
       await ensureModelClassInitialized(targetModelClass, this.relationship.getConfiguration(), modelsToLoad[0])
 
-      /**
-       * Where args.
-       * @type {Record<string, string | number | Array<string | number>>} */
-      const whereArgs = {}
+      // Build the query once with scope and selection, then clone it per cohort so
+      // the IN-list size stays within driver limits without rebuilding shared state.
+      let baseQuery = preloadQueryForModel(modelsToLoad, targetModelClass)
 
-      whereArgs[primaryKey] = [...foreignKeyValues]
+      baseQuery = this.relationship.applyScope(baseQuery)
+      baseQuery = this.selection.applyToQuery({query: baseQuery, targetModelClass, mappingColumns: [primaryKey]})
 
-      // Load target models to be preloaded on the given models
-      let query = preloadQueryForModel(modelsToLoad, targetModelClass).where(whereArgs)
+      const driver = baseQuery.driver
+      const cohorts = driver.chunkValues([...foreignKeyValues], (chunk) => baseQuery.clone().where({[primaryKey]: chunk}).toSql())
 
-      query = this.relationship.applyScope(query)
-      query = this.selection.applyToQuery({query, targetModelClass, mappingColumns: [primaryKey]})
+      for (const cohort of cohorts) {
+        const cohortQuery = baseQuery.clone().where({[primaryKey]: cohort})
+        const foundTargetModels = await cohortQuery.toArray()
 
-      targetModels = await query.toArray()
+        targetModels.push(...foundTargetModels)
 
-      for (const targetModel of targetModels) {
-        const primaryKeyValue = /** @type {string | number} */ (targetModel.readColumn(primaryKey))
+        for (const targetModel of foundTargetModels) {
+          const primaryKeyValue = /** @type {string | number} */ (targetModel.readColumn(primaryKey))
 
-        targetModelsById[primaryKeyValue] = targetModel
+          targetModelsById[primaryKeyValue] = targetModel
+        }
       }
     }
 
@@ -205,33 +207,32 @@ export default class VelociousDatabaseQueryPreloaderBelongsTo {
 
       await ensureModelClassInitialized(targetModelClass, configuration, this.models[0])
 
-      /**
-       * Where args.
-       * @type {Record<string, string | number | Array<string | number>>} */
-      const whereArgs = {}
+      let baseQuery = preloadQueryForModel(this.models, targetModelClass)
 
-      whereArgs[primaryKey] = [...foreignKeyValuesByType[targetType]]
+      baseQuery = this.relationship.applyScope(baseQuery)
+      baseQuery = this.selection.applyToQuery({query: baseQuery, targetModelClass, mappingColumns: [primaryKey]})
 
-      let query = preloadQueryForModel(this.models, targetModelClass).where(whereArgs)
+      const driver = baseQuery.driver
+      const cohorts = driver.chunkValues([...foreignKeyValuesByType[targetType]], (chunk) => baseQuery.clone().where({[primaryKey]: chunk}).toSql())
 
-      query = this.relationship.applyScope(query)
-      query = this.selection.applyToQuery({query, targetModelClass, mappingColumns: [primaryKey]})
+      targetModelsByTypeAndId[targetType] = {}
 
-      const foundTargetModels = await query.toArray()
+      for (const cohort of cohorts) {
+        const cohortQuery = baseQuery.clone().where({[primaryKey]: cohort})
+        const foundTargetModels = await cohortQuery.toArray()
 
-      targetModels.push(...foundTargetModels)
+        targetModels.push(...foundTargetModels)
 
-      const className = targetModelClass.getModelName()
+        const className = targetModelClass.getModelName()
 
-      if (!targetModelsByClassName[className]) targetModelsByClassName[className] = []
-      targetModelsByClassName[className].push(...foundTargetModels)
+        if (!targetModelsByClassName[className]) targetModelsByClassName[className] = []
+        targetModelsByClassName[className].push(...foundTargetModels)
 
-      targetModelsByTypeAndId[targetType] = {}
+        for (const targetModel of foundTargetModels) {
+          const primaryKeyValue = /** @type {string | number} */ (targetModel.readColumn(primaryKey))
 
-      for (const targetModel of foundTargetModels) {
-        const primaryKeyValue = /** @type {string | number} */ (targetModel.readColumn(primaryKey))
-
-        targetModelsByTypeAndId[targetType][primaryKeyValue] = targetModel
+          targetModelsByTypeAndId[targetType][primaryKeyValue] = targetModel
+        }
       }
     }
 

package/build/database/query/preloader/has-many.js

@@ -155,10 +155,11 @@ export default class VelociousDatabaseQueryPreloaderHasMany {
       modelsByPrimaryKeyValue[primaryKeyValue].push(model)
     }
 
-    // Step 1: Query the through table to build parent→target ID mapping
-    const throughModels = await preloadQueryForModel(modelsToLoad, throughModelClass)
-      .where({[throughForeignKey]: [...modelsPrimaryKeyValues]})
-      .toArray()
+    // Step 1: Query the through table to build parent→target ID mapping.
+    // Chunk the parent PK cohort so the through query's IN-list stays bounded.
+    const throughBaseQuery = preloadQueryForModel(modelsToLoad, throughModelClass)
+    const throughDriver = throughBaseQuery.driver
+    const throughCohorts = throughDriver.chunkValues([...modelsPrimaryKeyValues], (chunk) => throughBaseQuery.clone().where({[throughForeignKey]: chunk}).toSql())
 
     /**
      * Parent to target ids.
@@ -170,28 +171,43 @@ export default class VelociousDatabaseQueryPreloaderHasMany {
      * @type {Set<string | number>} */
     const allTargetIds = new Set()
 
-    for (const throughModel of throughModels) {
-      const parentId = /** @type {string | number} */ (throughModel.readColumn(throughForeignKey))
-      const throughId = /** @type {string | number} */ (throughModel.readColumn(throughModelClass.primaryKey()))
+    for (const cohort of throughCohorts) {
+      const throughQuery = throughBaseQuery.clone().where({[throughForeignKey]: cohort})
+      const throughModels = await throughQuery.toArray()
 
-      if (!(parentId in parentToTargetIds)) parentToTargetIds[parentId] = []
+      for (const throughModel of throughModels) {
+        const parentId = /** @type {string | number} */ (throughModel.readColumn(throughForeignKey))
+        const throughId = /** @type {string | number} */ (throughModel.readColumn(throughModelClass.primaryKey()))
 
-      parentToTargetIds[parentId].push(throughId)
-      allTargetIds.add(throughId)
+        if (!(parentId in parentToTargetIds)) parentToTargetIds[parentId] = []
+
+        parentToTargetIds[parentId].push(throughId)
+        allTargetIds.add(throughId)
+      }
     }
 
-    // Step 2: Load target models by the foreign key that points to the through table
+    // Step 2: Load target models by the foreign key that points to the through table.
+    // Chunk the target ID cohort so the target query's IN-list stays bounded.
     /**
      * Target models.
      * @type {import("../../record/index.js").default[]} */
     let targetModels = []
 
     if (allTargetIds.size > 0) {
-      let query = preloadQueryForModel(modelsToLoad, targetModelClass).where({[targetForeignKey]: [...allTargetIds]})
+      let targetBaseQuery = preloadQueryForModel(modelsToLoad, targetModelClass)
+
+      targetBaseQuery = this.relationship.applyScope(targetBaseQuery)
+      targetBaseQuery = this.selection.applyToQuery({query: targetBaseQuery, targetModelClass, mappingColumns: [targetForeignKey]})
+
+      const targetDriver = targetBaseQuery.driver
+      const targetCohorts = targetDriver.chunkValues([...allTargetIds], (chunk) => targetBaseQuery.clone().where({[targetForeignKey]: chunk}).toSql())
 
-      query = this.relationship.applyScope(query)
-      query = this.selection.applyToQuery({query, targetModelClass, mappingColumns: [targetForeignKey]})
-      targetModels = await query.toArray()
+      for (const cohort of targetCohorts) {
+        const cohortQuery = targetBaseQuery.clone().where({[targetForeignKey]: cohort})
+        const foundTargetModels = await cohortQuery.toArray()
+
+        targetModels.push(...foundTargetModels)
+      }
     }
 
     // Step 3: Index target models by their foreign key (maps to through model ID)
@@ -285,27 +301,35 @@ export default class VelociousDatabaseQueryPreloaderHasMany {
       modelsByPrimaryKeyValue[primaryKeyValue].push(model)
     }
 
-    /**
-     * Where args.
-     * @type {Record<string, string | number | Array<string | number>>} */
-    const whereArgs = {}
+    await ensureModelClassInitialized(targetModelClass, this.relationship.getConfiguration(), modelsToLoad[0])
 
-    whereArgs[foreignKey] = [...modelsPrimaryKeyValues]
+    // Build the query once with the polymorphic type constant (when present),
+    // relationship scope, and selection. The parent ID IN-list is cloned per cohort
+    // so the generated SQL stays within driver limits.
+    let baseQuery = preloadQueryForModel(modelsToLoad, targetModelClass)
 
     if (this.relationship.getPolymorphic()) {
       const typeColumn = this.relationship.getPolymorphicTypeColumn()
 
-      whereArgs[typeColumn] = this.relationship.getModelClass().getModelName()
+      baseQuery = baseQuery.where({[typeColumn]: this.relationship.getModelClass().getModelName()})
     }
 
-    await ensureModelClassInitialized(targetModelClass, this.relationship.getConfiguration(), modelsToLoad[0])
+    baseQuery = this.relationship.applyScope(baseQuery)
+    baseQuery = this.selection.applyToQuery({query: baseQuery, targetModelClass, mappingColumns: [foreignKey]})
 
-    let query = preloadQueryForModel(modelsToLoad, targetModelClass).where(whereArgs)
+    /**
+     * Target models.
+     * @type {import("../../record/index.js").default[]} */
+    const targetModels = []
+    const driver = baseQuery.driver
+    const cohorts = driver.chunkValues([...modelsPrimaryKeyValues], (chunk) => baseQuery.clone().where({[foreignKey]: chunk}).toSql())
 
-    query = this.relationship.applyScope(query)
-    query = this.selection.applyToQuery({query, targetModelClass, mappingColumns: [foreignKey]})
+    for (const cohort of cohorts) {
+      const cohortQuery = baseQuery.clone().where({[foreignKey]: cohort})
+      const foundTargetModels = await cohortQuery.toArray()
 
-    const targetModels = await query.toArray()
+      targetModels.push(...foundTargetModels)
+    }
 
     for (const targetModel of targetModels) {
       const foreignKeyValue = /** @type {string | number} */ (targetModel.readColumn(foreignKey))

package/build/database/query/preloader/has-one.js

@@ -72,28 +72,36 @@ export default class VelociousDatabaseQueryPreloaderHasOne {
 
     if (modelsPrimaryKeyValues.size == 0) return satisfiedTargets
 
-    /**
-     * Where args.
-     * @type {Record<string, string | number | Array<string | number>>} */
-    const whereArgs = {}
+    await ensureModelClassInitialized(targetModelClass, this.relationship.getConfiguration(), this.models[0])
 
-    whereArgs[foreignKey] = [...modelsPrimaryKeyValues]
+    // Load target models to be preloaded on the given models.
+    // Build the query once with the polymorphic type constant (when present),
+    // relationship scope, and selection. The parent ID IN-list is cloned per cohort
+    // so the generated SQL stays within driver limits.
+    let baseQuery = preloadQueryForModel(this.models, targetModelClass)
 
     if (this.relationship.getPolymorphic()) {
       const typeColumn = this.relationship.getPolymorphicTypeColumn()
 
-      whereArgs[typeColumn] = this.relationship.getModelClass().getModelName()
+      baseQuery = baseQuery.where({[typeColumn]: this.relationship.getModelClass().getModelName()})
     }
 
-    await ensureModelClassInitialized(targetModelClass, this.relationship.getConfiguration(), this.models[0])
+    baseQuery = this.relationship.applyScope(baseQuery)
+    baseQuery = this.selection.applyToQuery({query: baseQuery, targetModelClass, mappingColumns: [foreignKey]})
 
-    // Load target models to be preloaded on the given models
-    let query = preloadQueryForModel(this.models, targetModelClass).where(whereArgs)
+    /**
+     * Target models.
+     * @type {import("../../record/index.js").default[]} */
+    const targetModels = []
+    const driver = baseQuery.driver
+    const cohorts = driver.chunkValues([...modelsPrimaryKeyValues], (chunk) => baseQuery.clone().where({[foreignKey]: chunk}).toSql())
 
-    query = this.relationship.applyScope(query)
-    query = this.selection.applyToQuery({query, targetModelClass, mappingColumns: [foreignKey]})
+    for (const cohort of cohorts) {
+      const cohortQuery = baseQuery.clone().where({[foreignKey]: cohort})
+      const foundTargetModels = await cohortQuery.toArray()
 
-    const targetModels = await query.toArray()
+      targetModels.push(...foundTargetModels)
+    }
 
     for (const targetModel of targetModels) {
       const foreignKeyValue = /** @type {string | number} */ (targetModel.readColumn(foreignKey))

package/build/database/query/query-data.js

@@ -227,7 +227,7 @@ export async function runQueryData({rootModelClass, rootModels, entries}) {
   }
 
   for (const {query} of queryGroups) {
-    await executeEntryQuery({primaryKey, query, rootModels})
+    await executeChunkedEntryQuery({primaryKey, query, rootIds, rootModels})
   }
 }
 
@@ -267,13 +267,6 @@ function prepareEntry({entry, entryIndex, primaryKey, rootIds, rootModelClass, s
   const rootTable = rootModelClass.tableName()
   const rootPkSql = `${driver.quoteTable(rootTable)}.${driver.quoteColumn(primaryKey)}`
 
-  /**
-   * Root where.
-   * @type {Record<string, ReturnType<typeof JSON.parse>>} */
-  const rootWhere = {}
-  rootWhere[primaryKey] = rootIds
-  query.where(rootWhere)
-
   const joinDescriptor = buildNestedJoinDescriptor(entry.chain)
 
   if (joinDescriptor !== true) {
@@ -370,3 +363,25 @@ async function executeEntryQuery({primaryKey, query, rootModels}) {
     }
   }
 }
+
+/**
+ * Executes one compatible queryData group in cohorts so the root ID IN-list
+ * stays within driver limits, attaching each selected alias to the matching
+ * root record.
+ * @param {object} args - Options.
+ * @param {string} args.primaryKey - Root model primary key column.
+ * @param {import("./model-class-query.js").default} args.query - Prepared grouped query.
+ * @param {Array<string | number>} args.rootIds - Root primary-key values.
+ * @param {import("../record/index.js").default[]} args.rootModels - Loaded root records.
+ * @returns {Promise<void>}
+ */
+async function executeChunkedEntryQuery({primaryKey, query, rootIds, rootModels}) {
+  const driver = query.driver
+  const cohorts = driver.chunkValues(rootIds, (chunk) => query.clone().where({[primaryKey]: chunk}).toSql())
+
+  for (const cohort of cohorts) {
+    const cohortQuery = query.clone().where({[primaryKey]: cohort})
+
+    await executeEntryQuery({primaryKey, query: cohortQuery, rootModels})
+  }
+}

package/build/database/query/with-count.js

@@ -115,19 +115,19 @@ export async function runWithCount({models, modelClass, entries}) {
   const queryGroups = new Map()
 
   for (const entry of entries) {
-    const countQuery = queryForEntry({entry, modelClass, parentIds, sourceModel})
-    const sql = countQuery.toSql()
+    const {baseQuery, foreignKey} = queryForEntry({entry, modelClass, sourceModel})
+    const sql = baseQuery.toSql()
     const existingGroup = queryGroups.get(sql)
 
     if (existingGroup) {
       existingGroup.entries.push(entry)
     } else {
-      queryGroups.set(sql, {countQuery, entries: [entry]})
+      queryGroups.set(sql, {baseQuery, entries: [entry], foreignKey})
     }
   }
 
-  for (const {countQuery, entries: groupedEntries} of queryGroups.values()) {
-    const counts = await executeCountQuery(countQuery)
+  for (const {baseQuery, entries: groupedEntries, foreignKey} of queryGroups.values()) {
+    const counts = await executeChunkedCountQuery({baseQuery, foreignKey, parentIds})
 
     for (const entry of groupedEntries) attachCounts({counts, entry, models, primaryKey})
   }
@@ -135,14 +135,16 @@ export async function runWithCount({models, modelClass, entries}) {
 
 /**
  * Builds the grouped count query for an entry.
+ *
+ * The returned query does NOT yet filter by parent IDs; callers chunk the
+ * parent cohort and apply the foreign-key IN clause per chunk.
  * @param {object} args - Options.
  * @param {WithCountEntry} args.entry - Entry being evaluated.
  * @param {typeof import("../record/index.js").default} args.modelClass - Parent model class.
- * @param {Array<string | number>} args.parentIds - Primary keys of the loaded parents.
  * @param {import("../record/index.js").default} args.sourceModel - Loaded operation owner.
- * @returns {import("./model-class-query.js").default} - Prepared count query.
+ * @returns {{baseQuery: import("./model-class-query.js").default, foreignKey: string}} - Prepared count query and its foreign key.
  */
-function queryForEntry({entry, modelClass, parentIds, sourceModel}) {
+function queryForEntry({entry, modelClass, sourceModel}) {
   const relationship = modelClass.getRelationshipByName(entry.relationshipName)
 
   if (!relationship) {
@@ -163,7 +165,7 @@ function queryForEntry({entry, modelClass, parentIds, sourceModel}) {
   /**
    * Mandatory cohort conditions.
    * @type {Record<string, ReturnType<typeof JSON.parse>>} */
-  const mandatoryWhereConditions = {[foreignKey]: parentIds}
+  const mandatoryWhereConditions = {}
 
   if (relationship.getPolymorphic && relationship.getPolymorphic()) {
     const typeColumn = relationship.getPolymorphicTypeColumn()
@@ -171,8 +173,12 @@ function queryForEntry({entry, modelClass, parentIds, sourceModel}) {
   }
 
   const baseQuery = sourceModel.queryForModel(targetModelClass)
+
   baseQuery._forceQualifyBaseTable = true
-  baseQuery.where(mandatoryWhereConditions)
+
+  if (Object.keys(mandatoryWhereConditions).length > 0) {
+    baseQuery.where(mandatoryWhereConditions)
+  }
 
   if (entry.where) {
     baseQuery.where(entry.where)
@@ -192,7 +198,7 @@ function queryForEntry({entry, modelClass, parentIds, sourceModel}) {
   countQuery.select(`${qualifiedForeignKey} AS parent_id`)
   countQuery.select("COUNT(*) AS count_value")
 
-  return countQuery
+  return {baseQuery: countQuery, foreignKey}
 }
 
 /**
@@ -219,6 +225,36 @@ async function executeCountQuery(countQuery) {
   return counts
 }
 
+/**
+ * Executes a grouped count query in cohorts so the parent ID IN-list stays
+ * within driver limits, merging per-parent counts across chunks.
+ * @param {object} args - Options.
+ * @param {import("./model-class-query.js").default} args.baseQuery - Prepared count query without parent IDs.
+ * @param {string} args.foreignKey - Foreign key used to join to the parents.
+ * @param {Array<string | number>} args.parentIds - Primary keys of the loaded parents.
+ * @returns {Promise<Map<string | number, number>>} - Map of parent pk → count.
+ */
+async function executeChunkedCountQuery({baseQuery, foreignKey, parentIds}) {
+  const driver = baseQuery.driver
+  const cohorts = driver.chunkValues(parentIds, (chunk) => baseQuery.clone().where({[foreignKey]: chunk}).toSql())
+
+  /**
+   * Counts.
+   * @type {Map<string | number, number>} */
+  const counts = new Map()
+
+  for (const cohort of cohorts) {
+    const cohortQuery = baseQuery.clone().where({[foreignKey]: cohort})
+    const cohortCounts = await executeCountQuery(cohortQuery)
+
+    for (const [parentId, count] of cohortCounts) {
+      counts.set(parentId, count)
+    }
+  }
+
+  return counts
+}
+
 /**
  * Attaches one entry's resolved counts to the loaded models.
  * @param {object} args - Options.

package/build/src/configuration-types.d.ts

@@ -165,6 +165,14 @@ export type DatabaseConfigurationType = {
      * - Maximum serialized SQL size, in bytes, for a single `INSERT ... VALUES (...), (...), ...` statement. Defaults to 1 MiB (1048576).
      */
     maxInsertSqlBytes?: number;
+    /**
+     * - Maximum values in a single `IN (...)` cohort used by preloads, association counts, and queryData aggregates. Defaults to 999.
+     */
+    maxInClauseValues?: number;
+    /**
+     * - Maximum serialized SQL size, in bytes, for a single cohort query used by preloads, association counts, and queryData aggregates. Defaults to 1 MiB (1048576).
+     */
+    maxQuerySqlBytes?: number;
     /**
      * - Password for the database user.
      */
@@ -1645,6 +1653,8 @@ export type ConfigurationArgsType = {
  * @property {boolean} [multipleStatements] - (MySQL) Opt in to multi-statement queries so a whole structure SQL dump loads in one round-trip via `StructureSqlLoader`. Off by default; ordinary queries otherwise reject stacked statements.
  * @property {number} [maxRowsPerInsert] - Maximum rows per `INSERT ... VALUES (...), (...), ...` statement generated by `Record.insertMultiple`. Defaults to 500.
  * @property {number} [maxInsertSqlBytes] - Maximum serialized SQL size, in bytes, for a single `INSERT ... VALUES (...), (...), ...` statement. Defaults to 1 MiB (1048576).
+ * @property {number} [maxInClauseValues] - Maximum values in a single `IN (...)` cohort used by preloads, association counts, and queryData aggregates. Defaults to 999.
+ * @property {number} [maxQuerySqlBytes] - Maximum serialized SQL size, in bytes, for a single cohort query used by preloads, association counts, and queryData aggregates. Defaults to 1 MiB (1048576).
  * @property {string} [password] - Password for the database user.
  * @property {number} [port] - Database port.
  * @property {string} [primaryKeyType] - Default type for implicit migration primary keys and references. Defaults to `uuid`.