velocious 1.0.582 → 1.0.583

package/src/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/src/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/src/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/src/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.