objection 3.6.0 → 3.8.0

package/lib/queryBuilder/transformations/WrapMysqlModifySubqueryTransformation.js

@@ -2,8 +2,6 @@
 
 const { QueryTransformation } = require('./QueryTransformation');
 const { isMySql } = require('../../utils/knexUtils');
-const { once } = require('../../utils/objectUtils');
-const getJoinBuilder = once(() => require('../JoinBuilder').JoinBuilder);
 
 /**
  * Mysql doesn't allow queries like this:
@@ -32,11 +30,10 @@ class WrapMysqlModifySubqueryTransformation extends QueryTransformation {
       return query;
     }
 
-    // This transformation should not apply to join builder, otherwise it causes:
-    // "TypeError: parentQuery.isUpdate is not a function"
-    const JoinBuilder = getJoinBuilder();
-    if (parentQuery instanceof JoinBuilder) {
-      return query;
+    // Subqueries in where groups and join clauses are converted with a
+    // partial builder as their parent. Use the query that they belong to.
+    while (parentQuery.isPartial() && parentQuery.parentQuery()) {
+      parentQuery = parentQuery.parentQuery();
     }
 
     // This transformation only applies to update and delete queries.

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) {
@@ -103,6 +104,7 @@ class Relation {
     relation.joinTableRelatedProp = this.joinTableRelatedProp;
     relation.joinTableBeforeInsert = this.joinTableBeforeInsert;
     relation.joinTableExtras = this.joinTableExtras;
+    relation.joinTableModify = this.joinTableModify;
 
     return relation;
   }
@@ -156,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) {
@@ -12,7 +12,6 @@ class RelationFindOperation extends FindOperation {
     this.alwaysReturnArray = false;
     this.assignResultToOwner = true;
     this.relationProperty = opt.relationProperty || this.relation.name;
-    this.omitProps = [];
     this.alias = null;
   }
 
@@ -21,10 +20,9 @@ class RelationFindOperation extends FindOperation {
     this.relation.findQuery(builder, this.owner);
 
     if (this.owner.isModels) {
-      this.warnOnMissingOwnerProps();
+      this.warnOnInvalidOwnerProps();
 
       if (this.assignResultToOwner) {
-        this.warnOnArrayOwnerProps();
         this.selectMissingJoinColumns(builder);
       }
     }
@@ -70,11 +68,6 @@ class RelationFindOperation extends FindOperation {
 
   onAfter3(builder, related) {
     const isOneToOne = this.relation.isOneToOne();
-    const intOpt = builder.internalOptions();
-
-    if (!intOpt.keepImplicitJoinProps) {
-      this.omitImplicitJoinProps(related);
-    }
 
     if (!this.alwaysReturnArray && isOneToOne && related.length <= 1) {
       related = related[0] || undefined;
@@ -83,6 +76,19 @@ class RelationFindOperation extends FindOperation {
     return super.onAfter3(builder, related);
   }
 
+  // The columns of the result rows that hold the keys of their owners:
+  ownerKeyColumns() {
+    return this.relation.relatedProp.cols;
+  }
+
+  warnOnInvalidOwnerProps() {
+    this.warnOnMissingOwnerProps();
+
+    if (this.assignResultToOwner) {
+      this.warnOnArrayOwnerProps();
+    }
+  }
+
   // Owner models without the join columns, e.g. loaded with a partial
   // `select()`, silently get no related models (#1832). Only `undefined`
   // is reported, as `null` is a legit value for a missing relation, and
@@ -97,7 +103,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.',
@@ -111,15 +117,19 @@ class RelationFindOperation extends FindOperation {
   // assigned to their owners, so all owners silently get no related models
   // (#2667). `$relatedQuery()` without assigning the results isn't affected.
   warnOnArrayOwnerProps() {
-    const { ownerProp } = this.relation;
+    const { ownerProp, joinTable } = this.relation;
+    // Relations through a join table already are the alternative to arrays.
+    const advice = joinTable
+      ? 'Map the relation from a column that holds a single key instead.'
+      : 'Use a ManyToManyRelation through a join table instead.';
 
     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. ' +
-            'Use a ManyToManyRelation through a join table instead.',
+            advice,
         );
       }
     }
@@ -134,7 +144,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 ' +
@@ -154,7 +164,7 @@ class RelationFindOperation extends FindOperation {
       const col = relatedProp.cols[c];
 
       if (!builder.hasSelectionAs(fullCol, col) && addedSelects.indexOf(fullCol) === -1) {
-        this.omitProps.push(prop);
+        this.omitFromResult(builder, prop);
         addedSelects.push(fullCol);
       }
     }
@@ -170,34 +180,12 @@ class RelationFindOperation extends FindOperation {
     }
   }
 
-  omitImplicitJoinProps(related) {
-    const relatedModelClass = this.relation.relatedModelClass;
-
-    if (!this.omitProps.length || !related) {
-      return related;
-    }
-
-    if (!Array.isArray(related)) {
-      return this.omitImplicitJoinPropsFromOne(relatedModelClass, related);
-    }
-
-    if (!related.length) {
-      return related;
-    }
-
-    for (let i = 0, l = related.length; i < l; ++i) {
-      this.omitImplicitJoinPropsFromOne(relatedModelClass, related[i]);
-    }
-
-    return related;
-  }
-
-  omitImplicitJoinPropsFromOne(relatedModelClass, model) {
-    for (let c = 0, lc = this.omitProps.length; c < lc; ++c) {
-      relatedModelClass.omitImpl(model, this.omitProps[c]);
+  // Omits a property that was selected only to assign the related models to
+  // their owners from the result, before any `runAfter()` hooks are called.
+  omitFromResult(builder, prop) {
+    if (!builder.internalOptions().keepImplicitJoinProps) {
+      builder.addInternalSelection(prop);
     }
-
-    return model;
   }
 
   clone() {
@@ -206,7 +194,6 @@ class RelationFindOperation extends FindOperation {
     clone.alwaysReturnArray = this.alwaysReturnArray;
     clone.assignResultToOwner = this.assignResultToOwner;
     clone.relationProperty = this.relationProperty;
-    clone.omitProps = this.omitProps.slice();
     clone.alias = this.alias;
 
     return clone;

package/lib/relations/belongsToOne/BelongsToOneDeleteOperation.js

@@ -3,8 +3,10 @@
 const { RelationDeleteOperation } = require('../RelationDeleteOperation');
 
 class BelongsToOneDeleteOperation extends RelationDeleteOperation {
-  onAfter1(_, result) {
-    if (this.owner.isModels) {
+  onAfter1(builder, result) {
+    // A query resolved without executing it, e.g. with `none()`, deleted
+    // nothing, so the owners are left untouched.
+    if (this.owner.isModels && !builder.isExplicitlyResolvedOrRejected()) {
       const ownerProp = this.relation.ownerProp;
 
       for (const owner of this.owner.modelArray) {

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.
@@ -16,26 +17,42 @@ const ManyToManyModifyMixin = (Operation) => {
     constructor(...args) {
       super(...args);
       this.modifyFilterSubquery = null;
+      this.joinRowFilterSubquery = null;
       this.skipRelationFilter = false;
     }
 
-    // Updates of rows that are known to be related, like the patches of
-    // `upsertGraph()`, keep their own filters (#135).
+    // Unrelate doesn't execute the main query, and updates of rows that are
+    // known to be related, like the patches of `upsertGraph()`, keep their own
+    // filters (#135).
     get modifyMainQuery() {
-      return !this.skipRelationFilter;
+      return !this.modifiesJoinTableOnly && !this.skipRelationFilter;
     }
 
     // At this point `builder` should only have the user's own wheres and joins. There can
     // be other operations (like orderBy) too, but those are meaningless with modify operations.
     onBuild(builder) {
-      this.modifyFilterSubquery = this.createModifyFilterSubquery(builder);
+      if (this.modifiesJoinTable && !this.skipRelationFilter) {
+        this.joinRowFilterSubquery = this.createJoinRowFilterSubquery(builder);
+      }
 
       if (this.modifyMainQuery) {
+        this.modifyFilterSubquery = this.createModifyFilterSubquery(builder);
+
         // 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);
@@ -57,7 +74,7 @@ const ManyToManyModifyMixin = (Operation) => {
         .copyFrom(builder, builderClass.WhereSelector)
         .copyFrom(builder, builderClass.JoinSelector);
 
-      return modifyFilterSubquery.clearSelect();
+      return withoutOrder(modifyFilterSubquery.clearSelect());
     }
 
     removeFiltersFromMainQuery(builder) {
@@ -74,22 +91,46 @@ const ManyToManyModifyMixin = (Operation) => {
       return builder.whereInComposite(idRefs, subquery);
     }
 
-    // Modifies the join rows of all related rows that match the filters. If the filters
-    // reference join table columns, this also modifies join rows that don't match them
-    // but share a related row with one that does (#1853). The dialect specific mixins
-    // override this to only modify the join rows that match the filters themselves.
+    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);
-      const joinTableRelatedRefs = this.relation.joinTableRelatedProp.refs(builder);
-
-      const relatedRefs = this.relation.relatedProp.refs(builder);
       const ownerValues = this.owner.getProps(this.relation);
 
-      const subquery = this.modifyFilterSubquery.clone().select(relatedRefs);
-
       return builder
-        .whereInComposite(joinTableRelatedRefs, subquery)
-        .whereInComposite(joinTableOwnerRefs, ownerValues);
+        .whereInComposite(joinTableOwnerRefs, ownerValues)
+        .whereExists(this.joinRowFilterSubquery);
+    }
+
+    // Selects the related rows of a join row that match the filters. The join
+    // table isn't joined, so that the filters on its columns apply to the join
+    // row of the outer query.
+    createJoinRowFilterSubquery(builder) {
+      const { relation } = this;
+      const builderClass = builder.constructor;
+      const subquery = relation.relatedModelClass.query().childQueryOf(builder);
+      const joinTableRef = builder.tableRefFor(relation.joinTable);
+
+      addWhereGroup(subquery, () => {
+        relation.relatedProp.forEach((i) => {
+          const relatedRef = relation.relatedProp.ref(subquery, i);
+          const joinTableRelatedRef = relation.joinTableRelatedProp.ref(subquery, i);
+
+          subquery.where(relatedRef, joinTableRelatedRef.table(joinTableRef));
+        });
+      });
+
+      return withoutOrder(
+        relation
+          .applyModify(subquery)
+          .copyFrom(builder, builderClass.WhereSelector)
+          .copyFrom(builder, builderClass.JoinSelector)
+          .select(1),
+      );
     }
 
     toFindOperation() {
@@ -111,6 +152,7 @@ const ManyToManyModifyMixin = (Operation) => {
     clone() {
       const clone = super.clone();
       clone.modifyFilterSubquery = this.modifyFilterSubquery;
+      clone.joinRowFilterSubquery = this.joinRowFilterSubquery;
       clone.skipRelationFilter = this.skipRelationFilter;
       return clone;
     }
@@ -119,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/ManyToManyMySqlModifyMixin.js

@@ -1,66 +1,55 @@
 'use strict';
 
 const { ManyToManyModifyMixin } = require('./ManyToManyModifyMixin');
-const { isObject } = require('../../utils/objectUtils');
 
 // We need to override this mixin for mysql because mysql doesn't allow a
-// statement that modifies the join table to read the related table in a
-// subquery, if a trigger on the join table modifies the related table:
+// statement that modifies the join table to read the join table in a
+// subquery (ER_UPDATE_TABLE_USED), e.g. through the user's filters, or the
+// related table if a trigger on the join table modifies it
+// (ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG).
 //
-//   ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG
-//
-// So the join rows that match the filters are fetched in a separate query
-// before the main query, which then only modifies these rows (#1853). Mysql
-// has no row ids and the join table's primary key isn't known, so the rows are
-// identified by the values of all their columns.
+// So the owner and related ids of the join rows that match the filters are
+// fetched in a separate query before the statement, which then only modifies
+// the join rows with these ids. Unlike the subquery, these can't tell apart
+// join rows that only differ in their other columns (#1853).
 //
 // https://stackoverflow.com/a/2314264/3729316
 const ManyToManyMySqlModifyMixin = (Operation) => {
   return class extends ManyToManyModifyMixin(Operation) {
     applyModifyFilterForJoinTable(builder) {
-      const joinTableOwnerRefs = this.relation.joinTableOwnerProp.refs(builder);
-      const tableRef = builder.tableRefFor(this.relation.getJoinModelClass(builder));
-
+      const { joinTableOwnerProp, joinTableRelatedProp } = this.relation;
       const ownerValues = this.owner.getProps(this.relation);
-      const subquery = this.modifyFilterSubquery.clone().select(`${tableRef}.*`);
+      const subquery = this.joinRowFilterSubquery;
 
       return builder
+        .whereInComposite(joinTableOwnerProp.refs(builder), ownerValues)
         .runBefore(async (_, builder) => {
+          const idRefs = [
+            ...joinTableOwnerProp.refs(builder),
+            ...joinTableRelatedProp.refs(builder),
+          ];
+
           // Fetch the raw rows: no models, so that no hooks run for them.
-          const rows = await subquery.toKnexQuery();
+          const rows = await builder
+            .modelClass()
+            .query()
+            .childQueryOf(builder)
+            .copyFrom(builder, builder.constructor.WhereSelector)
+            .whereExists(subquery)
+            .select(idRefs)
+            .toKnexQuery();
 
-          if (rows.length) {
-            builder.where((builder) => {
-              for (const row of rows) {
-                builder.orWhere((builder) => {
-                  for (const [column, value] of Object.entries(row)) {
-                    builder.whereRaw('?? <=> ?', [
-                      `${tableRef}.${column}`,
-                      toComparableValue(value),
-                    ]);
-                  }
-                });
-              }
-            });
-          } else {
-            // Still execute the query so that it returns the expected
-            // result for the dialect, e.g. a count of 0 for deletes.
-            builder.where(false);
-          }
-        })
-        .whereInComposite(joinTableOwnerRefs, ownerValues);
+          // An empty list still executes the query, so that it returns the
+          // expected result for the dialect, e.g. a count of 0 for deletes.
+          builder.whereInComposite(
+            idRefs,
+            rows.map((row) => Object.values(row)),
+          );
+        });
     }
   };
 };
 
-// Some drivers return JSON columns parsed. Mysql parses strings that are
-// compared to JSON columns, so the stringified value matches them again.
-function toComparableValue(value) {
-  return isObject(value) && !(value instanceof Date) && !Buffer.isBuffer(value)
-    ? JSON.stringify(value)
-    : value;
-}
-
 module.exports = {
   ManyToManyMySqlModifyMixin,
 };