objection 3.2.0 → 3.3.0

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) {

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

@@ -1,14 +1,21 @@
 'use strict';
 
-const { isString, isObject } = require('../../../utils/objectUtils');
+const { isString, isObject, isPlainObject } = require('../../../utils/objectUtils');
+const { isKnexQueryBuilder, isKnexRaw } = require('../../../utils/knexUtils');
 
 const ALIAS_REGEX = /\s+as\s+/i;
 
+// Matches an alias at the end of a raw sql string: `as "alias"`, `as \`alias\``,
+// `as [alias]`, `as ??`, `as :name:` or `as alias`.
+const RAW_ALIAS_REGEX =
+  /\s+as\s+(?:"([^"]+)"|`([^`]+)`|\[([^\]]+)\]|(\?\?)|:(\w+):|([a-z_][\w$]*))\s*$/i;
+
 class Selection {
   constructor(table, column, alias) {
     this.table = table;
     this.column = column;
     this.alias = alias;
+    this.keepsSelectAll = false;
   }
 
   get name() {
@@ -23,6 +30,12 @@ class Selection {
         return createSelectionFromReference(selection);
       } else if (selection.isObjectionRawBuilder) {
         return createSelectionFromRaw(selection);
+      } else if (selection.isObjectionQueryBuilderBase) {
+        return createSelectionFromQueryBuilder(selection);
+      } else if (isKnexQueryBuilder(selection)) {
+        return createSelectionFromAlias(selection._single.as);
+      } else if (isKnexRaw(selection)) {
+        return createSelectionFromAlias(parseRawAlias(selection.sql, selection.bindings));
       } else {
         return null;
       }
@@ -50,10 +63,11 @@ class Selection {
     if (selectionInBuilder.column === '*') {
       if (selectionInBuilder.table) {
         if (selectionToTest.column === '*') {
-          return selectionToTest.table === selectionInBuilder.table;
+          return isSameTable(builder, selectionToTest.table, selectionInBuilder.table);
         } else {
           return (
-            selectionToTest.table === null || selectionToTest.table === selectionInBuilder.table
+            selectionToTest.table === null ||
+            isSameTable(builder, selectionToTest.table, selectionInBuilder.table)
           );
         }
       } else {
@@ -67,7 +81,8 @@ class Selection {
       } else {
         return (
           selectionToTest.column === selectionInBuilder.column &&
-          (selectionToTest.table === null || selectionToTest.table === selectionInBuilderTable)
+          (selectionToTest.table === null ||
+            isSameTable(builder, selectionToTest.table, selectionInBuilderTable))
         );
       }
     }
@@ -82,6 +97,36 @@ 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:
+// `dataExtension` and `data_extension` both end up as `data_extension`.
+function isSameTable(builder, table1, table2) {
+  if (table1 === table2) {
+    return true;
+  } else if (!table1 || !table2) {
+    return false;
+  }
+
+  const knex = builder.unsafeKnex();
+  const wrapIdentifier = knex && knex.client && knex.client.config.wrapIdentifier;
+
+  if (!wrapIdentifier) {
+    return false;
+  }
+
+  const mapTable = (table) =>
+    table
+      .split('.')
+      .map((part) => wrapIdentifier(part, identity))
+      .join('.');
+
+  return mapTable(table1) === mapTable(table2);
+}
+
+function identity(value) {
+  return value;
+}
+
 function createSelectionFromReference(ref) {
   return new Selection(ref.tableName, ref.column, ref.alias);
 }
@@ -89,6 +134,52 @@ function createSelectionFromReference(ref) {
 function createSelectionFromRaw(raw) {
   if (raw.alias) {
     return new Selection(null, null, raw.alias);
+  } else {
+    return createSelectionFromAlias(parseRawAlias(raw._sql, raw._args));
+  }
+}
+
+function parseRawAlias(sql, bindings) {
+  const match = isString(sql) && RAW_ALIAS_REGEX.exec(sql);
+
+  if (!match) {
+    return null;
+  }
+
+  const [, doubleQuoted, backQuoted, bracketQuoted, binding, namedBinding, unquoted] = match;
+
+  if (binding) {
+    return Array.isArray(bindings) ? bindings[bindings.length - 1] : null;
+  } else if (namedBinding) {
+    if (Array.isArray(bindings) && bindings.length === 1) {
+      // `raw(sql, { name: value })` of objection.
+      bindings = bindings[0];
+    }
+
+    return isPlainObject(bindings) ? bindings[namedBinding] : null;
+  } else if (unquoted) {
+    // Some databases, like postgres, fold unquoted identifiers to lower case
+    // and others don't, so only lower case ones can be used reliably.
+    return unquoted === unquoted.toLowerCase() ? unquoted : null;
+  } else {
+    return doubleQuoted || backQuoted || bracketQuoted;
+  }
+}
+
+// Subqueries aliased using `as()` select a column with the alias as name.
+function createSelectionFromQueryBuilder(builder) {
+  const asOperation = builder.findLastOperation('as');
+  return createSelectionFromAlias(asOperation && asOperation.args[0]);
+}
+
+function createSelectionFromAlias(alias) {
+  if (isString(alias)) {
+    const selection = new Selection(null, null, alias);
+    // These selections weren't recognized in the past. To not change which
+    // other columns `withGraphJoined` selects, they don't count as explicit
+    // selections when deciding whether all columns are selected.
+    selection.keepsSelectAll = true;
+    return selection;
   } else {
     return null;
   }

package/lib/queryBuilder/operations/whereInComposite/WhereInCompositeMsSqlOperation.js

@@ -26,6 +26,12 @@ class WhereInCompositeMsSqlOperation extends ObjectionToKnexConvertingOperation
   }
 
   buildComposite(knex, knexBuilder, columns, values) {
+    if (Array.isArray(values) && values.length === 0) {
+      // knex turns an empty `whereIn` into `1 = 0` and an empty `whereNotIn`
+      // into `1 = 1`.
+      return this.whereIn(knexBuilder, columns, []);
+    }
+
     const helperColumns = columns.map((_, index) => getTempColumn(index));
 
     if (Array.isArray(values)) {

package/lib/queryBuilder/operations/whereInComposite/WhereInCompositeOperation.js

@@ -48,7 +48,11 @@ function buildCompositeArgs(knex, columns, values) {
 }
 
 function buildCompositeValueArgs(columns, values) {
-  if (!Array.isArray(values[0])) {
+  if (values.length === 0) {
+    // knex turns an empty `whereIn` into `1 = 0` and an empty `whereNotIn`
+    // into `1 = 1`.
+    return [columns, []];
+  } else if (!Array.isArray(values[0])) {
     return [columns, [values]];
   } else {
     return [columns, values];

package/lib/queryBuilder/operations/whereInComposite/WhereInCompositeSqliteOperation.js

@@ -54,6 +54,15 @@ function buildCompositeArgs(columns, values) {
     throw new Error(`sqlite doesn't support multi-column where in clauses`);
   }
 
+  if (values.length === 0) {
+    // knex turns an empty `whereIn` into `1 = 0` and an empty `whereNotIn`
+    // into `1 = 1`.
+    return {
+      method: 'whereIn',
+      args: [columns, []],
+    };
+  }
+
   // Sqlite doesn't support the `where in` syntax for multiple columns but
   // we can emulate it using grouped `or` clauses.
   return {