objection 3.2.0 → 3.4.0

package/lib/queryBuilder/operations/InsertOperation.js

@@ -4,7 +4,7 @@ const { QueryBuilderOperation } = require('./QueryBuilderOperation');
 const { StaticHookArguments } = require('../StaticHookArguments');
 const { after, mapAfterAllReturn } = require('../../utils/promiseUtils');
 const { isPostgres, isSqlite, isMySql, isMsSql } = require('../../utils/knexUtils');
-const { isObject } = require('../../utils/objectUtils');
+const { isObject, isString } = require('../../utils/objectUtils');
 
 // Base class for all insert operations.
 class InsertOperation extends QueryBuilderOperation {
@@ -36,35 +36,58 @@ class InsertOperation extends QueryBuilderOperation {
   }
 
   onBuildKnex(knexBuilder, builder) {
-    if (!isSqlite(builder.knex()) && !isMySql(builder.knex()) && !builder.has(/returning/)) {
-      // If the user hasn't specified a `returning` clause, we make sure
-      // that at least the identifier is returned.
-      knexBuilder = knexBuilder.returning(builder.modelClass().getIdColumn());
+    const knex = builder.knex();
+
+    const defaultReturning = getDefaultReturning(builder);
+
+    if (!builder.has(/returning/) && defaultReturning !== null) {
+      if (!isSqlite(knex) && !isMySql(knex)) {
+        // If the user hasn't specified a `returning` clause, we make sure
+        // that at least the identifier is returned. With `onConflict()` the
+        // conflict columns are returned too, so that the returned rows can
+        // be matched to the models when some of the rows are ignored.
+        knexBuilder = knexBuilder.returning(defaultReturning);
+      } else if (isSqlite(knex) && builder.has('onConflict')) {
+        // Without a `returning` clause, SQLite returns the id of the last
+        // inserted row, which belongs to a previous insert if the row was
+        // ignored. Use `returning` to find out what was actually inserted.
+        knexBuilder = knexBuilder.returning(defaultReturning);
+      }
     }
 
     return knexBuilder.insert(this.models.map((model) => model.$toDatabaseJson(builder)));
   }
 
-  onAfter1(_, ret) {
+  onAfter1(builder, ret) {
     if (!Array.isArray(ret) || !ret.length || ret === this.models) {
       // Early exit if there is nothing to do.
       return this.models;
     }
 
+    const isOnConflict = builder.has('onConflict');
+
     if (isObject(ret[0])) {
-      // If the user specified a `returning` clause the result may be an array of objects.
-      // Merge all values of the objects to our models.
-      for (let i = 0, l = this.models.length; i < l; ++i) {
-        this.models[i].$setDatabaseJson(ret[i]);
+      if (isOnConflict && ret.length !== this.models.length) {
+        // With `onConflict()`, ignored rows (and rows not updated because of a
+        // `where` clause after `merge()`) are not returned, so the returned rows
+        // can't be merged to the models based on their position.
+        mergeMatchingRows(builder, this.models, ret);
+      } else {
+        // If the user specified a `returning` clause the result may be an array of objects.
+        // Merge all values of the objects to our models.
+        for (let i = 0, l = this.models.length; i < l; ++i) {
+          this.models[i].$setDatabaseJson(ret[i]);
+        }
       }
-    } else {
+    } else if (builder.modelClass().getIdColumnArray().length > 0) {
       // If the return value is not an array of objects, we assume it is an array of identifiers.
       for (let i = 0, l = this.models.length; i < l; ++i) {
         const model = this.models[i];
 
         // Don't set the id if the model already has one. MySQL and Sqlite don't return the correct
-        // primary key value if the id is not generated in db, but given explicitly.
-        if (!model.$id()) {
+        // primary key value if the id is not generated in db, but given explicitly. With
+        // `onConflict()`, MySQL returns `0` for ignored rows, which is not a valid id.
+        if (!model.$id() && !(isOnConflict && !ret[i])) {
           model.$id(ret[i]);
         }
       }
@@ -92,6 +115,99 @@ class InsertOperation extends QueryBuilderOperation {
   }
 }
 
+// Returns `null` if there's nothing to return, e.g. for models without an `idColumn`.
+function getDefaultReturning(builder) {
+  const idColumns = builder.modelClass().getIdColumnArray();
+  const columns = Array.from(new Set(idColumns.concat(getConflictColumns(builder))));
+
+  if (columns.length === 0) {
+    return null;
+  }
+
+  return columns.length === 1 ? columns[0] : columns;
+}
+
+function getConflictColumns(builder) {
+  if (!builder.has('onConflict')) {
+    return [];
+  }
+
+  const op = builder.findOperation('onConflict');
+  const arg = op.args ? op.args[0] : undefined;
+  const columns = Array.isArray(arg) ? arg : [arg];
+
+  // Raw conflict targets (or no target at all) can't be used for matching.
+  return columns.every(isString) ? columns : [];
+}
+
+// Merges the rows returned by an insert with `onConflict()` into the models with
+// matching key values. Models whose rows were not returned are left untouched.
+function mergeMatchingRows(builder, models, rows) {
+  const jsons = models.map((model) => model.$toDatabaseJson(builder));
+  const idColumns = builder.modelClass().getIdColumnArray();
+
+  // Use the conflict columns, or else the identifiers, to match the rows to
+  // the models. The columns must be present in the input and the result.
+  const keyColumns = [getConflictColumns(builder), idColumns].find((columns) => {
+    return (
+      columns.length > 0 &&
+      columns.every((col) => {
+        return (
+          rows.every((row) => row[col] !== undefined) &&
+          jsons.every((json) => json[col] !== undefined)
+        );
+      })
+    );
+  });
+
+  if (!keyColumns) {
+    throw createMatchError();
+  }
+
+  const createKey = (obj) => JSON.stringify(keyColumns.map((col) => normalizeKey(obj[col])));
+  const indicesByKey = new Map();
+
+  jsons.forEach((json, index) => {
+    const key = createKey(json);
+    const indices = indicesByKey.get(key);
+
+    if (indices) {
+      indices.push(index);
+    } else {
+      indicesByKey.set(key, [index]);
+    }
+  });
+
+  for (const row of rows) {
+    const indices = indicesByKey.get(createKey(row));
+    const index = indices ? indices.shift() : undefined;
+
+    if (index === undefined) {
+      throw createMatchError();
+    }
+
+    models[index].$setDatabaseJson(row);
+  }
+}
+
+function normalizeKey(value) {
+  if (value === null || value === undefined) {
+    return null;
+  } else if (isObject(value)) {
+    return JSON.stringify(value);
+  } else {
+    return String(value);
+  }
+}
+
+function createMatchError() {
+  return new Error(
+    'Could not match the rows returned by an insert with `onConflict()` to the inserted models. ' +
+      'Pass the conflict columns to `onConflict()` and make sure they are returned, or provide ' +
+      'the identifiers of the inserted models.',
+  );
+}
+
 function callBeforeInsert(builder, models) {
   const maybePromise = callInstanceBeforeInsert(builder, models);
   return after(maybePromise, () => callStaticBeforeInsert(builder));

package/lib/queryBuilder/operations/QueryBuilderOperation.js

@@ -41,6 +41,9 @@ class QueryBuilderOperation {
 
     // Operations this operation added in any of its hooks.
     this.childOperations = [];
+
+    // The where group this operation belongs to. See `whereGroups.js`.
+    this.whereGroup = null;
   }
 
   is(OperationClass) {
@@ -217,6 +220,7 @@ class QueryBuilderOperation {
 
     clone.adderHookName = this.adderHookName;
     clone.parentOperation = this.parentOperation;
+    clone.whereGroup = this.whereGroup;
 
     clone.childOperations = this.childOperations.map((childOp) => {
       const childOpClone = childOp.clone();

package/lib/queryBuilder/operations/ReturningOperation.js

@@ -1,14 +1,27 @@
 'use strict';
 
-const { flatten } = require('../../utils/objectUtils');
+const { flatten, isPlainObject } = require('../../utils/objectUtils');
 const { ObjectionToKnexConvertingOperation } = require('./ObjectionToKnexConvertingOperation');
 
-// This class's only purpose is to normalize the arguments into an array.
+// This class's purpose is to normalize the arguments into an array and to
+// pass an optional trailing options object (e.g. `includeTriggerModifications`)
+// on to knex.
 //
 // In knex, if a single column is given to `returning` it returns an array with the that column's value
 // in it. If an array is given with a one item inside, the return value is an object.
 class ReturningOperation extends ObjectionToKnexConvertingOperation {
+  constructor(name, opt) {
+    super(name, opt);
+    this.options = null;
+  }
+
   onAdd(builder, args) {
+    args = Array.from(args);
+
+    if (args.length > 1 && isPlainObject(args[args.length - 1])) {
+      this.options = args.pop();
+    }
+
     args = flatten(args);
 
     // Don't add an empty returning list.
@@ -21,7 +34,19 @@ class ReturningOperation extends ObjectionToKnexConvertingOperation {
 
   onBuildKnex(knexBuilder, builder) {
     // Always pass an array of columns to knex.returning.
-    return knexBuilder.returning(this.getKnexArgs(builder));
+    const columns = this.getKnexArgs(builder);
+
+    if (this.options) {
+      return knexBuilder.returning(columns, this.options);
+    } else {
+      return knexBuilder.returning(columns);
+    }
+  }
+
+  clone() {
+    const clone = super.clone();
+    clone.options = this.options;
+    return clone;
   }
 }
 

package/lib/queryBuilder/operations/UpdateOperation.js

@@ -2,6 +2,7 @@
 
 const { ref } = require('../../queryBuilder/ReferenceBuilder');
 const { isEmpty } = require('../../utils/objectUtils');
+const { toPostgresJsonPathLiteral } = require('../../utils/parseFieldExpression');
 const { isKnexRaw, isKnexQueryBuilder } = require('../../utils/knexUtils');
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
 const { StaticHookArguments } = require('../StaticHookArguments');
@@ -104,7 +105,7 @@ function convertFieldExpressionsToRaw(builder, model, json) {
       // "col" : raw(`jsonb_set("col", '{attr}', to_jsonb("other"#>'{lol}'), true)`)
 
       let parsed = ref(key);
-      let jsonRefs = '{' + parsed.parsedExpr.access.map((it) => it.ref).join(',') + '}';
+      let jsonPath = toPostgresJsonPathLiteral(parsed.parsedExpr.access);
       let valuePlaceholder = '?';
 
       if (isKnexQueryBuilder(val) || isKnexRaw(val)) {
@@ -114,7 +115,7 @@ function convertFieldExpressionsToRaw(builder, model, json) {
       }
 
       convertedJson[parsed.column] = knex.raw(
-        `jsonb_set(??, '${jsonRefs}', ${valuePlaceholder}, true)`,
+        `jsonb_set(??, ${jsonPath}, ${valuePlaceholder}, true)`,
         [convertedJson[parsed.column] || parsed.column, val],
       );
 

package/lib/queryBuilder/operations/UpsertGraphOperation.js

@@ -40,6 +40,11 @@ class UpsertGraphOperation extends QueryBuilderOperation {
     return true;
   }
 
+  onBefore1(builder, result) {
+    GraphUpsert.warnOnConflict(builder, this.name);
+    return result;
+  }
+
   onAfter1(builder) {
     if (hasOtherSqlModifyingQueryBuilderCalls(builder)) {
       throw new Error(

package/lib/queryBuilder/operations/WhereGroupOperation.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+
+// Builds a set of where operations inside a single knex `where(callback)`
+// group, i.e. wraps them in parentheses. See `wrapWhereGroups`.
+class WhereGroupOperation extends QueryBuilderOperation {
+  constructor(name, opt) {
+    super(name, opt);
+    this.operations = [];
+  }
+
+  onBuildKnex(knexBuilder, builder) {
+    const operations = this.operations;
+
+    return knexBuilder.where(function () {
+      let knex = this;
+
+      const build = (op) => {
+        if (op.hasOnBuildKnex()) {
+          knex = builder.callOperationMethod(op, 'onBuildKnex', [knex, builder]) || knex;
+        }
+      };
+
+      for (const op of operations) {
+        build(op);
+        op.forEachDescendantOperation(build);
+      }
+    });
+  }
+
+  clone() {
+    const clone = super.clone();
+    clone.operations = this.operations.map((op) => op.clone());
+    return clone;
+  }
+}
+
+module.exports = {
+  WhereGroupOperation,
+};

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

@@ -9,6 +9,9 @@ class EagerOperation extends QueryBuilderOperation {
 
     this.expression = RelationExpression.create();
     this.graphOptions = this.opt.defaultGraphOptions;
+    // The `joinOperation` options passed to the `withGraphJoined` calls,
+    // together with the expressions of the calls.
+    this.joinOperations = [];
   }
 
   buildFinalExpression(builder) {
@@ -41,6 +44,7 @@ class EagerOperation extends QueryBuilderOperation {
   cloneFrom(eagerOp) {
     this.expression = eagerOp.expression.clone();
     this.graphOptions = Object.assign({}, eagerOp.graphOptions);
+    this.joinOperations = eagerOp.joinOperations.slice();
   }
 
   clone() {

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

@@ -24,6 +24,7 @@ class JoinEagerOperation extends EagerOperation {
       .setExpression(this.buildFinalExpression(builder))
       .setModifiers(this.buildFinalModifiers(builder))
       .setOptions(this.graphOptions)
+      .setJoinOperations(this.joinOperations)
       .fetchColumnInfo(builder);
   }
 
@@ -32,15 +33,10 @@ class JoinEagerOperation extends EagerOperation {
       .setExpression(this.buildFinalExpression(builder))
       .setModifiers(this.buildFinalModifiers(builder))
       .setOptions(this.graphOptions)
+      .setJoinOperations(this.joinOperations)
       .build(builder);
   }
 
-  // Stops the joiner from omitting an internally selected column of the root
-  // table from the result. Returns true if such a selection existed.
-  releaseInternalRootSelection(column) {
-    return !!this.joiner && this.joiner.releaseInternalRootSelection(column);
-  }
-
   onRawResult(builder, rows) {
     return this.joiner.parseResult(builder, rows);
   }

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

@@ -3,7 +3,6 @@
 const promiseUtils = require('../../../utils/promiseUtils');
 
 const { EagerOperation } = require('./EagerOperation');
-const { JoinEagerOperation } = require('./JoinEagerOperation');
 const { isMsSql, isOracle, isSqlite } = require('../../../utils/knexUtils');
 const { isObject, asArray, flatten, chunk } = require('../../../utils/objectUtils');
 const { ValidationErrorType } = require('../../../model/ValidationError');
@@ -16,7 +15,6 @@ class WhereInEagerOperation extends EagerOperation {
     super(name, opt);
 
     this.relationsToFetch = [];
-    this.omitProps = [];
   }
 
   batchSize(knex) {
@@ -51,8 +49,15 @@ class WhereInEagerOperation extends EagerOperation {
       builder.select(selectionsToAdd);
     }
 
+    // Omit the implicitly selected columns from the result once the relations
+    // have been fetched.
+    if (!builder.internalOptions().keepImplicitJoinProps) {
+      for (const prop of selectedProps) {
+        builder.addInternalSelection(prop);
+      }
+    }
+
     this.relationsToFetch = relationsToFetch;
-    this.omitProps = selectedProps;
   }
 
   async onAfter2(builder, result) {
@@ -75,22 +80,6 @@ class WhereInEagerOperation extends EagerOperation {
       { concurrency: modelClass.getConcurrency(builder.unsafeKnex()) },
     );
 
-    const intOpt = builder.internalOptions();
-
-    if (!this.omitProps.length || intOpt.keepImplicitJoinProps) {
-      return result;
-    }
-
-    // Now that relations have been fetched for `models` we can omit the
-    // columns that were implicitly selected by this class.
-    for (let i = 0, l = result.length; i < l; ++i) {
-      const model = result[i];
-
-      for (let c = 0, lc = this.omitProps.length; c < lc; ++c) {
-        modelClass.omitImpl(model, this.omitProps[c]);
-      }
-    }
-
     return result;
   }
 
@@ -205,7 +194,6 @@ class WhereInEagerOperation extends EagerOperation {
     const clone = super.clone();
 
     clone.relationsToFetch = this.relationsToFetch.slice();
-    clone.omitProps = this.omitProps.slice();
 
     return clone;
   }
@@ -238,11 +226,6 @@ function findRelationPropsToSelect(builder, relationsToFetch) {
   const selectionsToAdd = [];
   const selectedProps = [];
 
-  // When mixed with `withGraphJoined`, the join operation may have selected
-  // some of the needed columns internally, in which case it would omit them
-  // from the result models before we get to use them.
-  const joinOp = builder.findOperation(JoinEagerOperation);
-
   // Collect columns that need to be selected for the eager fetch
   // to work that are not currently selected.
   for (const { relation } of relationsToFetch) {
@@ -253,15 +236,9 @@ function findRelationPropsToSelect(builder, relationsToFetch) {
       const prop = ownerProp.props[c];
       const col = ownerProp.cols[c];
 
-      if (!builder.hasSelectionAs(fullCol, col)) {
-        if (selectionsToAdd.indexOf(fullCol) === -1) {
-          selectedProps.push(prop);
-          selectionsToAdd.push(fullCol);
-        }
-      } else if (joinOp && joinOp.releaseInternalRootSelection(col)) {
-        // The join operation no longer omits the column, so we need to
-        // omit the property once the relations have been fetched.
+      if (!builder.hasSelectionAs(fullCol, col) && selectionsToAdd.indexOf(fullCol) === -1) {
         selectedProps.push(prop);
+        selectionsToAdd.push(fullCol);
       }
     }
   }

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

@@ -7,7 +7,7 @@ class WhereJsonHasPostgresOperation extends ObjectionToKnexConvertingOperation {
   onBuildKnex(knexBuilder, builder) {
     const args = this.getKnexArgs(builder);
 
-    const sql = jsonApi.whereJsonFieldRightStringArrayOnLeftQuery(
+    const rawArgs = jsonApi.whereJsonFieldRightStringArrayOnLeftQuery(
       builder.knex(),
       args[0],
       this.opt.operator,
@@ -15,9 +15,9 @@ class WhereJsonHasPostgresOperation extends ObjectionToKnexConvertingOperation {
     );
 
     if (this.opt.bool === 'or') {
-      knexBuilder = knexBuilder.orWhereRaw(sql);
+      knexBuilder = knexBuilder.orWhereRaw(...rawArgs);
     } else {
-      knexBuilder = knexBuilder.whereRaw(sql);
+      knexBuilder = knexBuilder.whereRaw(...rawArgs);
     }
 
     return knexBuilder;

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

@@ -18,7 +18,7 @@ class WhereJsonNotObjectPostgresOperation extends ObjectionToKnexConvertingOpera
         'not',
       );
 
-      builder.orWhereRaw(jsonApi.whereJsonFieldQuery(knex, fieldExpression, 'IS', null));
+      builder.orWhereRaw(...jsonApi.whereJsonFieldQuery(knex, fieldExpression, 'IS', null));
     };
 
     if (this.opt.bool === 'or') {

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

@@ -2,6 +2,7 @@
 
 const parser = require('../../../utils/parseFieldExpression');
 const { asArray, isObject, isString } = require('../../../utils/objectUtils');
+const { isKnexRaw, isKnexQueryBuilder } = require('../../../utils/knexUtils');
 
 /**
  * @typedef {String} FieldExpression
@@ -38,22 +39,24 @@ const { asArray, isObject, isString } = require('../../../utils/objectUtils');
  * 4. Keys containing square brackets and quotes
  *    `objectColumn:['Double."Quote".[]']` and `objectColumn:["Sinlge.'Quote'.[]"]`
  *    Column `{ "Double.\"Quote\".[]" : "I was referred",  "Single.'Quote'.[]" : "Mee too!" }`
+ * 5. Empty keys `objectColumn:[""]` or `objectColumn:['']` Column `{ "" : "I was referred" }`
  * 99. Keys containing dots, square brackets, single quotes and double quotes in one json key is
  *     not currently supported
  */
 
+// Returns the SQL and bindings of a field expression. The column is passed as an
+// identifier binding (`??`), so that knex's `wrapIdentifier` (e.g. used by
+// `knexSnakeCaseMappers()`) is applied to it.
 function parseFieldExpression(expression, extractAsText) {
   let parsed = parser.parseFieldExpression(expression);
-  let middleQuotedColumnName = parsed.columnName.split('.').join('"."');
-  let column = `"${middleQuotedColumnName}"`;
+  let bindings = [parsed.columnName];
   // Reference the bare column when there is no json path, so that Postgres can
   // use indexes on it. `#>> '{}'` is still needed to extract the value as text.
   if (parsed.access.length === 0 && !extractAsText) {
-    return column;
+    return ['??', bindings];
   }
-  let jsonRefs = parsed.access.map((it) => it.ref).join(',');
   let extractor = extractAsText ? '#>>' : '#>';
-  return `${column}${extractor}'{${jsonRefs}}'`;
+  return [`??${extractor}${parser.toPostgresJsonPathLiteral(parsed.access)}`, bindings];
 }
 
 function whereJsonbRefOnLeftJsonbValOrRefOnRight(
@@ -78,36 +81,36 @@ function whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams(
   jsonObjectOrFieldExpression,
   queryPrefix,
 ) {
-  let fieldReference = parseFieldExpression(fieldExpression);
+  let [fieldReference, bindings] = parseFieldExpression(fieldExpression);
+  let [rightHandSql, rightHandBindings] = rightHandExpression(jsonObjectOrFieldExpression);
+  let query = ['(', fieldReference, ')::jsonb', operator, rightHandSql];
 
+  if (queryPrefix) {
+    query.unshift(queryPrefix);
+  }
+
+  return [query.join(' '), [...bindings, ...rightHandBindings]];
+}
+
+function rightHandExpression(jsonObjectOrFieldExpression) {
   if (isString(jsonObjectOrFieldExpression)) {
-    let rightHandReference = parseFieldExpression(jsonObjectOrFieldExpression);
-    let refRefQuery = [
-      '(',
-      fieldReference,
-      ')::jsonb',
-      operator,
-      '(',
-      rightHandReference,
-      ')::jsonb',
-    ];
-    if (queryPrefix) {
-      refRefQuery.unshift(queryPrefix);
-    }
-    return [refRefQuery.join(' ')];
+    let [rightHandReference, bindings] = parseFieldExpression(jsonObjectOrFieldExpression);
+    return [`( ${rightHandReference} )::jsonb`, bindings];
+  } else if (
+    isKnexRaw(jsonObjectOrFieldExpression) ||
+    isKnexQueryBuilder(jsonObjectOrFieldExpression)
+  ) {
+    // ref(), val(), raw() and subqueries, already converted to knex by the operation.
+    return ['( ? )::jsonb', [jsonObjectOrFieldExpression]];
   } else if (isObject(jsonObjectOrFieldExpression)) {
-    let refValQuery = ['(', fieldReference, ')::jsonb', operator, '?::jsonb'];
-    if (queryPrefix) {
-      refValQuery.unshift(queryPrefix);
-    }
-    return [refValQuery.join(' '), JSON.stringify(jsonObjectOrFieldExpression)];
+    return ['?::jsonb', [JSON.stringify(jsonObjectOrFieldExpression)]];
   }
 
   throw new Error('Invalid right hand expression.');
 }
 
 function whereJsonFieldRightStringArrayOnLeftQuery(knex, fieldExpression, operator, keys) {
-  let fieldReference = parseFieldExpression(fieldExpression);
+  let [fieldReference, bindings] = parseFieldExpression(fieldExpression);
   keys = asArray(keys);
 
   let questionMarksArray = keys.map((key) => {
@@ -117,19 +120,19 @@ function whereJsonFieldRightStringArrayOnLeftQuery(knex, fieldExpression, operat
     return '?';
   });
 
-  let rawSqlTemplateString = 'array[' + questionMarksArray.join(',') + ']';
-  let rightHandExpression = knex.raw(rawSqlTemplateString, keys);
-
-  return `${fieldReference} ${operator.replace('?', '\\?')} ${rightHandExpression}`;
+  return [
+    `${fieldReference} ${operator.replace('?', '\\?')} array[${questionMarksArray.join(',')}]`,
+    [...bindings, ...keys],
+  ];
 }
 
 function whereJsonFieldQuery(knex, fieldExpression, operator, value) {
-  let fieldReference = parseFieldExpression(fieldExpression, true);
+  let [fieldReference, bindings] = parseFieldExpression(fieldExpression, true);
   let normalizedOperator = normalizeOperator(knex, operator);
 
   // json type comparison takes json type in string format
   let cast;
-  let escapedValue = knex.raw(' ?', [value]);
+  let valuePlaceholder = '?';
   let type = typeof value;
 
   if (type === 'number') {
@@ -140,12 +143,16 @@ function whereJsonFieldQuery(knex, fieldExpression, operator, value) {
     cast = '::TEXT';
   } else if (value === null) {
     cast = '::TEXT';
-    escapedValue = 'NULL';
+    valuePlaceholder = 'NULL';
   } else {
     throw new Error('Value must be string, number, boolean or null.');
   }
 
-  return `(${fieldReference})${cast} ${normalizedOperator} ${escapedValue}`;
+  // Bind the value so that `?` in it isn't read as a binding placeholder.
+  return [
+    `(${fieldReference})${cast} ${normalizedOperator} ${valuePlaceholder}`,
+    value === null ? bindings : [...bindings, value],
+  ];
 }
 
 function normalizeOperator(knex, operator) {