objection 3.7.0 → 3.9.0

package/lib/queryBuilder/operations/eager/WhereInEagerOperation.js

@@ -3,7 +3,8 @@
 const promiseUtils = require('../../../utils/promiseUtils');
 
 const { EagerOperation } = require('./EagerOperation');
-const { isMsSql, isOracle, isSqlite } = require('../../../utils/knexUtils');
+const { LimitPerParentOperation } = require('../LimitPerParentOperation');
+const { isMsSql, isOracle, isSqlite, hasWindowFunctions } = require('../../../utils/knexUtils');
 const { isObject, asArray, flatten, chunk } = require('../../../utils/objectUtils');
 const { ValidationErrorType } = require('../../../model/ValidationError');
 const { createModifier } = require('../../../utils/createModifier');
@@ -85,7 +86,9 @@ class WhereInEagerOperation extends EagerOperation {
 
   async fetchRelation(builder, models, relation, expr) {
     const modelClass = builder.resultModelClass();
-    const batchSize = this.batchSize(builder.knex());
+    const batchSize = this.shouldFetchPerParent(builder, models, relation, expr)
+      ? 1
+      : this.batchSize(builder.knex());
     const modelBatches = chunk(models, batchSize);
 
     const result = await promiseUtils.map(
@@ -136,9 +139,32 @@ class WhereInEagerOperation extends EagerOperation {
       }
     }
 
+    if (this.graphOptions.limitPerParent) {
+      queryBuilder.addOperation(
+        new LimitPerParentOperation('limitPerParent', { findOperation }),
+        [],
+      );
+    }
+
     return queryBuilder;
   }
 
+  // Without window functions, the related models can only be limited per
+  // parent with one query per parent.
+  shouldFetchPerParent(builder, models, relation, expr) {
+    if (this.graphOptions.limitPerParent && !hasWindowFunctions(builder.knex())) {
+      // Build the query to find its limits, also those of the relation's
+      // `modify` and of `onBuildKnex()` hooks. This runs its modifiers and
+      // build hooks once more than for fetching the relation.
+      const query = this.fetchRelationBatch(builder, models, relation, expr);
+      query.executeOnBuild();
+      const knexQuery = query.executeOnBuildKnex(query.knex().queryBuilder());
+      return !!query.findOperation(LimitPerParentOperation)?.getRange(knexQuery, query);
+    } else {
+      return false;
+    }
+  }
+
   shouldSkipFetched(models, relation, expr) {
     if (!this.graphOptions.skipFetched) {
       return false;

package/lib/queryBuilder/operations/jsonApi/postgresJsonApi.js

@@ -3,7 +3,7 @@
 const parser = require('../../../utils/parseFieldExpression');
 const { asArray, isObject, isString } = require('../../../utils/objectUtils');
 const { isKnexRaw, isKnexQueryBuilder, isPostgres } = require('../../../utils/knexUtils');
-const { deprecate } = require('../../../utils/deprecate');
+const { warnOnce } = require('../../../utils/warnings');
 
 /**
  * @typedef {String} FieldExpression
@@ -47,10 +47,10 @@ const { deprecate } = require('../../../utils/deprecate');
 
 // JSON field expressions and the `whereJson*()` methods generate Postgres-only
 // SQL (ditojs#113). As some of it happens to run on other databases, only warn.
-// TODO: Consider throwing an error instead in objection 4.0.
+// TODO: Consider throwing an error instead in objection 4.0 (#272).
 function warnIfNotPostgres(knex) {
   if (!isPostgres(knex)) {
-    deprecate(
+    warnOnce(
       'JSON field expressions and the whereJson*() methods of objection are only supported ' +
         'on PostgreSQL. Use the JSON methods of knex like whereJsonPath() or jsonExtract() ' +
         'with other databases.',

package/lib/queryBuilder/operations/select/SelectOperation.js

@@ -25,6 +25,8 @@ class SelectOperation extends ObjectionToKnexConvertingOperation {
     // The selections that aggregates select, by their aliases. `null` for
     // non-aggregate operations.
     this.aggregateSelections = AGGREGATE_METHODS.has(name) ? [] : null;
+    // `distinctOn()` makes the rows distinct on its columns, it doesn't select them.
+    this.isDistinctOn = name === 'distinctOn';
   }
 
   onAdd(builder, args) {
@@ -38,11 +40,13 @@ class SelectOperation extends ObjectionToKnexConvertingOperation {
 
     const ret = super.onAdd(builder, selections);
 
-    for (const selection of selections) {
-      const selectionInstance = Selection.create(selection);
+    if (!this.isDistinctOn) {
+      for (const selection of selections) {
+        const selectionInstance = Selection.create(selection);
 
-      if (selectionInstance) {
-        this.selections.push(selectionInstance);
+        if (selectionInstance) {
+          this.selections.push(selectionInstance);
+        }
       }
     }
 

package/lib/queryBuilder/operations/select/Selection.js

@@ -80,7 +80,7 @@ class Selection {
         return false;
       } else {
         return (
-          selectionToTest.column === selectionInBuilder.column &&
+          isSameIdentifier(builder, selectionToTest.column, selectionInBuilder.column) &&
           (selectionToTest.table === null ||
             isSameTable(builder, selectionToTest.table, selectionInBuilderTable))
         );
@@ -97,30 +97,49 @@ Object.defineProperties(Selection.prototype, {
   },
 });
 
-// Table names that only differ in a way that knex's `wrapIdentifier` mapping
-// (for example `knexSnakeCaseMappers()`) cancels out refer to the same table:
+// Identifiers that only differ in a way that knex's `wrapIdentifier` mapping
+// (for example `knexSnakeCaseMappers()`) cancels out are the same identifier:
 // `dataExtension` and `data_extension` both end up as `data_extension`.
-function isSameTable(builder, table1, table2) {
-  if (table1 === table2) {
+function isSameIdentifier(builder, identifier1, identifier2) {
+  if (identifier1 === identifier2) {
     return true;
-  } else if (!table1 || !table2) {
+  } else if (!identifier1 || !identifier2) {
     return false;
+  } else {
+    return mapIdentifier(builder, identifier1) === mapIdentifier(builder, identifier2);
   }
+}
 
-  const knex = builder.unsafeKnex();
-  const wrapIdentifier = knex && knex.client && knex.client.config.wrapIdentifier;
-
-  if (!wrapIdentifier) {
+// As in SQL, a table name without a schema refers to the table with a schema:
+// `persons` and `public.persons` are the same table.
+function isSameTable(builder, table1, table2) {
+  if (isSameIdentifier(builder, table1, table2)) {
+    return true;
+  } else if (!table1 || !table2 || hasSchema(table1) === hasSchema(table2)) {
     return false;
+  } else {
+    return isSameIdentifier(builder, withoutSchema(table1), withoutSchema(table2));
   }
+}
+
+function hasSchema(table) {
+  return table.includes('.');
+}
 
-  const mapTable = (table) =>
-    table
-      .split('.')
-      .map((part) => wrapIdentifier(part, identity))
-      .join('.');
+function withoutSchema(table) {
+  return table.slice(table.lastIndexOf('.') + 1);
+}
+
+function mapIdentifier(builder, identifier) {
+  const knex = builder.unsafeKnex();
+  const wrapIdentifier = knex && knex.client && knex.client.config.wrapIdentifier;
 
-  return mapTable(table1) === mapTable(table2);
+  return wrapIdentifier
+    ? identifier
+        .split('.')
+        .map((part) => wrapIdentifier(part, identity))
+        .join('.')
+    : identifier;
 }
 
 function identity(value) {
@@ -211,4 +230,8 @@ function createSelectionFromString(selection) {
 
 module.exports = {
   Selection,
+  isSameIdentifier,
+  isSameTable,
+  mapIdentifier,
+  withoutSchema,
 };

package/lib/queryBuilder/parsers/relationExpressionParser.js

@@ -4,6 +4,8 @@
 
 'use strict';
 
+const { warnOnce } = require('../../utils/warnings');
+
 class peg$SyntaxError extends SyntaxError {
   constructor(message, expected, found, location) {
     super(message);
@@ -944,11 +946,11 @@ function peg$parse(input, options) {
 
   function assertDuplicateRelation(node, expr) {
     if (Object.prototype.hasOwnProperty.call(node, expr.$name)) {
-      console.warn(
-        `Duplicate relation "${expr.$name}" in a relation expression. You should use "a.[b, c]" instead of "[a.b, a.c]". This will cause an error in objection 2.0`,
+      warnOnce(
+        `Duplicate relation "${expr.$name}" in a relation expression, only the last one is used. Use "a.[b, c]" instead of "[a.b, a.c]". This will throw an error in objection 4.0.`,
       );
 
-      // TODO: enable for v2.0.
+      // Throws in objection 4.0, see ditojs/objection#53.
       // const err = new Error();
       // err.duplicateRelationName = expr.$name;
       // throw err;

package/lib/queryBuilder/parsers/relationExpressionParser.pegjs

@@ -1,9 +1,13 @@
+{{
+  const { warnOnce } = require('../../utils/warnings');
+}}
+
 {
   function assertDuplicateRelation(node, expr) {
     if (Object.prototype.hasOwnProperty.call(node, expr.$name)) {
-      console.warn(`Duplicate relation "${expr.$name}" in a relation expression. You should use "a.[b, c]" instead of "[a.b, a.c]". This will cause an error in objection 2.0`);
+      warnOnce(`Duplicate relation "${expr.$name}" in a relation expression, only the last one is used. Use "a.[b, c]" instead of "[a.b, a.c]". This will throw an error in objection 4.0.`);
 
-      // TODO: enable for v2.0.
+      // Throws in objection 4.0, see ditojs/objection#53.
       // const err = new Error();
       // err.duplicateRelationName = expr.$name;
       // throw err;

package/lib/queryBuilder/whereGroups.js

@@ -5,21 +5,23 @@ const { isObject, isFunction } = require('../utils/objectUtils');
 const { isKnexRaw } = require('../utils/knexUtils');
 
 // Where operations of a query can come from different sources: the user, a
-// relation's owner condition, the relation's `modify`/`filter` and so on. Each
-// source forms its own "where group". All operations the user adds belong to
-// the default group, and `addWhereGroup` assigns the operations added inside
-// its callback to a new, separate group.
+// relation's owner condition, the relation's `modify`/`filter`, the id
+// condition of `patchAndFetchById()` and `$query()` and so on. Each source
+// forms its own "where group". All operations the user adds belong to the
+// default group, and `addWhereGroup` assigns the operations added inside its
+// callback to a new, separate group.
 //
 // Knex simply joins all where clauses with their `and` or `or` boolean. Since
 // `and` binds tighter than `or`, a user's `orWhere` would escape the relation's
 // owner condition: `where "ownerId" in (1) and a or b`. This would find, update
 // and delete rows of other owners too. See issues #2191 and #1909.
 //
-// To prevent this, `wrapWhereGroups` is called after all `onBuild` hooks have
-// run. If a query contains more than one where group, every group that may
-// contain an `or` at its top level is wrapped in parentheses, so that the
-// groups are always ANDed together: `where "ownerId" in (1) and (a or b)`.
-// Groups without an `or` are left alone so that their SQL doesn't change.
+// To prevent this, the where groups are computed when the knex query is built.
+// If a query contains more than one where group, every group that may contain
+// an `or` at its top level is wrapped in parentheses, so that the groups are
+// always ANDed together: `where "ownerId" in (1) and (a or b)`. Groups without
+// an `or` are left alone so that their SQL doesn't change. The operations
+// aren't moved, so that a built query can be cloned and built again.
 function addWhereGroup(builder, callback) {
   const parentWhereGroup = builder._whereGroup;
   builder._whereGroup = {};
@@ -31,7 +33,17 @@ function addWhereGroup(builder, callback) {
   }
 }
 
-function wrapWhereGroups(builder) {
+// Assign an operation that isn't added through a builder, like the result of
+// `toFindOperation()`, to a new, separate group.
+function assignWhereGroup(operation) {
+  operation.whereGroup = {};
+  return operation;
+}
+
+// Return a map from each where operation that needs to be wrapped in
+// parentheses to the `WhereGroupOperation` that builds its group in place of
+// the group's first operation, or to null for the group's other operations.
+function getWhereGroupOperations(builder) {
   const WhereSelector = builder.constructor.WhereSelector;
   const whereOps = new Set();
   const groups = new Map();
@@ -56,17 +68,21 @@ function wrapWhereGroups(builder) {
     ops.push(op);
   });
 
-  if (groups.size < 2) {
-    return builder;
-  }
+  const whereGroupOps = new Map();
+
+  if (groups.size > 1) {
+    for (const ops of groups.values()) {
+      if (ops.some(mayContainTopLevelOr)) {
+        for (const op of ops) {
+          whereGroupOps.set(op, null);
+        }
 
-  for (const [group, ops] of groups) {
-    if (ops.some(mayContainTopLevelOr)) {
-      wrapOperations(builder, group, ops);
+        whereGroupOps.set(ops[0], new WhereGroupOperation('where', { operations: ops }));
+      }
     }
   }
 
-  return builder;
+  return whereGroupOps;
 }
 
 function getWhereGroup(op) {
@@ -80,10 +96,6 @@ function getWhereGroup(op) {
 }
 
 function mayContainTopLevelOr(op) {
-  if (op instanceof WhereGroupOperation) {
-    return false;
-  }
-
   // orWhere, orWhereIn, orWhereRaw, orWhereExists, orWhereJsonSupersetOf etc.
   if (/^or[A-Z]/.test(op.name)) {
     return true;
@@ -101,25 +113,8 @@ function isRaw(arg) {
   return isKnexRaw(arg) || (isObject(arg) && isFunction(arg.toKnexRaw));
 }
 
-function wrapOperations(builder, group, ops) {
-  const groupOp = new WhereGroupOperation('where');
-  groupOp.whereGroup = group;
-
-  builder.replaceOperation(ops[0], groupOp);
-
-  for (let i = 1; i < ops.length; ++i) {
-    builder.removeOperation(ops[i]);
-  }
-
-  for (const op of ops) {
-    op.parentOperation = null;
-    op.adderHookName = null;
-  }
-
-  groupOp.operations = ops;
-}
-
 module.exports = {
   addWhereGroup,
-  wrapWhereGroups,
+  assignWhereGroup,
+  getWhereGroupOperations,
 };

package/lib/queryBuilder/withoutOrder.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const { FirstOperation } = require('./operations/FirstOperation');
+const { isMsSql } = require('../utils/knexUtils');
+
+// Removes the order of a subquery that only selects or joins rows. The order
+// can come from a relation's `modify` or an `onBuild` hook of the context, so
+// it's removed when the subquery is built.
+function withoutOrder(subquery) {
+  return subquery.onBuild(clearUnsupportedOrder);
+}
+
+// Without a limit, an order doesn't matter in subqueries and updates, and SQL
+// Server rejects it there. With a limit it decides the rows, so we keep it, and
+// SQL Server rejects an update rather than updating arbitrary rows.
+function clearUnsupportedOrder(builder) {
+  if (isMsSql(builder.knex()) && !hasLimit(builder)) {
+    builder.clearOrder();
+  }
+}
+
+function hasLimit(builder) {
+  return (
+    builder.has(/limit|offset/) ||
+    // `first()` only adds its limit when the knex query is built.
+    builder.findOperation(FirstOperation)?.shouldLimit(builder)
+  );
+}
+
+module.exports = {
+  withoutOrder,
+  clearUnsupportedOrder,
+};

package/lib/relations/Relation.js

@@ -11,6 +11,7 @@ const { get, isFunction } = require('../utils/objectUtils');
 const { mapAfterAllReturn } = require('../utils/promiseUtils');
 const { createModifier } = require('../utils/createModifier');
 const { addWhereGroup } = require('../queryBuilder/whereGroups');
+const { withoutOrder } = require('../queryBuilder/withoutOrder');
 
 class Relation {
   constructor(relationName, OwnerClass) {
@@ -157,6 +158,8 @@ class Relation {
     if (relatedJoinSelect.isSelectAll()) {
       // No need to join a subquery if the query is `select * from "RelatedTable"`.
       relatedJoinSelect = aliasedTableName(relatedTable, relatedTableAlias);
+    } else {
+      withoutOrder(relatedJoinSelect);
     }
 
     return builder[joinOperation](relatedJoinSelect, (join) => {

package/lib/relations/RelationFindOperation.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { FindOperation } = require('../queryBuilder/operations/FindOperation');
-const { deprecate } = require('../utils/deprecate');
+const { warnOnce } = require('../utils/warnings');
 
 class RelationFindOperation extends FindOperation {
   constructor(name, opt) {
@@ -76,6 +76,14 @@ class RelationFindOperation extends FindOperation {
     return super.onAfter3(builder, related);
   }
 
+  // The expressions of the result rows in `table` that hold the keys of their
+  // owners, including json references:
+  ownerKeys(builder, table) {
+    return this.relation.relatedProp
+      .refs(builder)
+      .map((ref) => ref.table(table).toKnexRaw(builder));
+  }
+
   warnOnInvalidOwnerProps() {
     this.warnOnMissingOwnerProps();
 
@@ -88,7 +96,7 @@ class RelationFindOperation extends FindOperation {
   // `select()`, silently get no related models (#1832). Only `undefined`
   // is reported, as `null` is a legit value for a missing relation, and
   // owner props that may legitimately be unset are skipped (#132).
-  // TODO: Consider throwing an error instead in objection 4.0.
+  // TODO: Consider throwing an error instead in objection 4.0 (#272).
   warnOnMissingOwnerProps() {
     const { ownerProp } = this.relation;
 
@@ -98,7 +106,7 @@ class RelationFindOperation extends FindOperation {
       }
 
       if (this.owner.modelArray.some((owner) => ownerProp.getProp(owner, c) === undefined)) {
-        deprecate(
+        warnOnce(
           `Fetching relation "${this.relation.name}" of ${this.relation.ownerModelClass.name}: ` +
             `some owner models are missing the join property "${ownerProp.propDescription(c)}", ` +
             'so no related models are found for them. Select the column in the owner query.',
@@ -120,7 +128,7 @@ class RelationFindOperation extends FindOperation {
 
     for (let c = 0, lc = ownerProp.size; c < lc; ++c) {
       if (this.owner.modelArray.some((owner) => Array.isArray(ownerProp.getProp(owner, c)))) {
-        deprecate(
+        warnOnce(
           `Fetching relation "${this.relation.name}" of ${this.relation.ownerModelClass.name}: ` +
             `the join property "${ownerProp.propDescription(c)}" of some owner models holds ` +
             'an array, which is not supported, so no related models are found for them. ' +
@@ -139,7 +147,7 @@ class RelationFindOperation extends FindOperation {
 
     for (let c = 0, lc = relatedProp.size; c < lc; ++c) {
       if (related.some((rel) => relatedProp.getProp(rel, c) === undefined)) {
-        deprecate(
+        warnOnce(
           `Fetching relation "${this.relation.name}" of ${this.relation.ownerModelClass.name}: ` +
             `some related models are missing the join property "${relatedProp.propDescription(c)}", ` +
             'so they are not assigned to any owner. Check that the relation mapping uses the ' +

package/lib/relations/RelationOwner.js

@@ -2,6 +2,7 @@
 
 const { isObject, asArray, asSingle, uniqBy } = require('../utils/objectUtils');
 const { normalizeIds } = require('../utils/normalizeIds');
+const { valuesKey } = require('../model/modelValues');
 
 const Type = {
   Models: 'Models',
@@ -123,7 +124,7 @@ class RelationOwner {
       return null;
     }
 
-    return uniqBy(props, join);
+    return uniqBy(props, valuesKey);
   }
 
   _getPropsFromIdentifiers(relation, ownerProp) {
@@ -218,10 +219,6 @@ function containsNonNull(arr) {
   return false;
 }
 
-function join(id) {
-  return id.map((x) => (Buffer.isBuffer(x) ? x.toString('hex') : x)).join(',');
-}
-
 function isIdProp(relationProp) {
   const idProp = relationProp.modelClass.getIdRelationProperty();
   return idProp.props.every((prop, i) => prop === relationProp.props[i]);

package/lib/relations/RelationProperty.js

@@ -2,7 +2,7 @@
 
 const { asArray, isObject, uniqBy, get, set } = require('../utils/objectUtils');
 const { ref: createRef } = require('../queryBuilder/ReferenceBuilder');
-const { propToStr, PROP_KEY_PREFIX } = require('../model/modelValues');
+const { valuesKey } = require('../model/modelValues');
 
 class ModelNotFoundError extends Error {
   constructor(tableName) {
@@ -86,20 +86,9 @@ class RelationProperty {
     }
   }
 
-  // Creates a concatenated string from the property values of the given object.
+  // Creates a key from the property values of the given object.
   propKey(obj) {
-    const size = this.size;
-    let key = PROP_KEY_PREFIX;
-
-    for (let i = 0; i < size; ++i) {
-      key += propToStr(this.getProp(obj, i));
-
-      if (i !== size - 1) {
-        key += ',';
-      }
-    }
-
-    return key;
+    return valuesKey(this.getProps(obj));
   }
 
   // Returns the property values of the given object as an array.

package/lib/relations/belongsToOne/BelongsToOneInsertOperation.js

@@ -2,6 +2,7 @@
 
 const { RelationInsertOperation } = require('../RelationInsertOperation');
 const { BelongsToOneRelateOperation } = require('./BelongsToOneRelateOperation');
+const { InsertGraphOperation } = require('../../queryBuilder/operations/InsertGraphOperation');
 
 class BelongsToOneInsertOperation extends RelationInsertOperation {
   onAdd(builder, args) {
@@ -17,7 +18,10 @@ class BelongsToOneInsertOperation extends RelationInsertOperation {
   async onAfter1(builder, ret) {
     const inserted = await super.onAfter1(builder, ret);
 
-    if (!builder.isExecutable()) {
+    // A query resolved without executing it, e.g. with `resolve()`, inserted
+    // nothing. `insertGraph()` resolves the query itself, but always inserts
+    // the graph.
+    if (!builder.isExecutable() && !builder.has(InsertGraphOperation)) {
       return inserted;
     }
 

package/lib/relations/manyToMany/ManyToManyModifyMixin.js

@@ -2,6 +2,7 @@
 
 const { ManyToManyFindOperation } = require('./find/ManyToManyFindOperation');
 const { addWhereGroup } = require('../../queryBuilder/whereGroups');
+const { withoutOrder } = require('../../queryBuilder/withoutOrder');
 
 // This mixin contains the shared code for all modify operations (update, delete, relate, unrelate)
 // for ManyToManyRelation operations.
@@ -40,8 +41,18 @@ const ManyToManyModifyMixin = (Operation) => {
         // We can now remove the where and join statements from the main query.
         this.removeFiltersFromMainQuery(builder);
 
-        // Add a single where clause that uses the created subquery.
-        addWhereGroup(builder, () => this.applyModifyFilterForRelatedTable(builder));
+        // Add a single where clause that uses the created subquery. Updates
+        // that modify the join rows too are executed in batches of the ids
+        // that `onAfterBuild` fetches, see `queryBatches()` (#161).
+        addWhereGroup(builder, () =>
+          this.modifiesJoinTable
+            ? builder.where((whereBuilder) =>
+                builder._queryBatch
+                  ? this.applyIdFilterForRelatedTable(whereBuilder, builder._queryBatch)
+                  : this.applyModifyFilterForRelatedTable(whereBuilder),
+              )
+            : this.applyModifyFilterForRelatedTable(builder),
+        );
       }
 
       return super.onBuild(builder);
@@ -63,7 +74,7 @@ const ManyToManyModifyMixin = (Operation) => {
         .copyFrom(builder, builderClass.WhereSelector)
         .copyFrom(builder, builderClass.JoinSelector);
 
-      return modifyFilterSubquery.clearSelect();
+      return withoutOrder(modifyFilterSubquery.clearSelect());
     }
 
     removeFiltersFromMainQuery(builder) {
@@ -80,6 +91,11 @@ const ManyToManyModifyMixin = (Operation) => {
       return builder.whereInComposite(idRefs, subquery);
     }
 
+    applyIdFilterForRelatedTable(builder, ids) {
+      const idRefs = this.relation.relatedModelClass.getIdRelationProperty().refs(builder);
+      return builder.whereInComposite(idRefs, ids);
+    }
+
     // Only modifies the join rows that match the filters (#1853).
     applyModifyFilterForJoinTable(builder) {
       const joinTableOwnerRefs = this.relation.joinTableOwnerProp.refs(builder);
@@ -108,11 +124,13 @@ const ManyToManyModifyMixin = (Operation) => {
         });
       });
 
-      return relation
-        .applyModify(subquery)
-        .copyFrom(builder, builderClass.WhereSelector)
-        .copyFrom(builder, builderClass.JoinSelector)
-        .select(1);
+      return withoutOrder(
+        relation
+          .applyModify(subquery)
+          .copyFrom(builder, builderClass.WhereSelector)
+          .copyFrom(builder, builderClass.JoinSelector)
+          .select(1),
+      );
     }
 
     toFindOperation() {
@@ -143,9 +161,13 @@ const ManyToManyModifyMixin = (Operation) => {
 
 class ManyToManyModifyFindOperation extends ManyToManyFindOperation {
   onBuild(builder) {
+    const { modifyOperation } = this.opt;
     super.onBuild(builder);
+
     addWhereGroup(builder, () =>
-      this.opt.modifyOperation.applyModifyFilterForRelatedTable(builder),
+      modifyOperation.relatedIds
+        ? modifyOperation.applyIdFilterForRelatedTable(builder, modifyOperation.relatedIds)
+        : modifyOperation.applyModifyFilterForRelatedTable(builder),
     );
   }
 }

package/lib/relations/manyToMany/ManyToManyRelation.js

@@ -11,6 +11,7 @@ const { mapAfterAllReturn } = require('../../utils/promiseUtils');
 const { isFunction, isObject, isString } = require('../../utils/objectUtils');
 const { createModifier } = require('../../utils/createModifier');
 const { addWhereGroup } = require('../../queryBuilder/whereGroups');
+const { withoutOrder } = require('../../queryBuilder/withoutOrder');
 
 const { ManyToManyFindOperation } = require('./find/ManyToManyFindOperation');
 const { ManyToManyInsertOperation } = require('./insert/ManyToManyInsertOperation');
@@ -113,6 +114,8 @@ class ManyToManyRelation extends Relation {
       .as(joinTableAlias);
     if (joinTableSelect.isSelectAll()) {
       joinTableSelect = aliasedTableName(joinTable, joinTableAlias);
+    } else {
+      withoutOrder(joinTableSelect);
     }
 
     builder.join(joinTableSelect, (join) => {
@@ -144,6 +147,8 @@ class ManyToManyRelation extends Relation {
     if (relatedJoinSelect.isSelectAll()) {
       // No need to join a subquery if the query is `select * from "RelatedTable"`.
       relatedJoinSelect = aliasedTableName(relatedTable, relatedTableAlias);
+    } else {
+      withoutOrder(relatedJoinSelect);
     }
 
     let joinTableSelect = this.joinTableModelClass
@@ -153,6 +158,8 @@ class ManyToManyRelation extends Relation {
       .as(joinTableAlias);
     if (joinTableSelect.isSelectAll()) {
       joinTableSelect = aliasedTableName(this.joinTable, joinTableAlias);
+    } else {
+      withoutOrder(joinTableSelect);
     }
 
     return builder[joinOperation](joinTableSelect, (join) => {