knex 0.95.14 → 1.0.2

package/lib/query/querybuilder.js

@@ -118,25 +118,82 @@ class Builder extends EventEmitter {
 
   // With
   // ------
+  isValidStatementArg(statement) {
+    return (
+      typeof statement === 'function' ||
+      statement instanceof Builder ||
+      (statement && statement.isRawInstance)
+    );
+  }
+
+  _validateWithArgs(alias, statementOrColumnList, nothingOrStatement, method) {
+    const [query, columnList] =
+      typeof nothingOrStatement === 'undefined'
+        ? [statementOrColumnList, undefined]
+        : [nothingOrStatement, statementOrColumnList];
+    if (typeof alias !== 'string') {
+      throw new Error(`${method}() first argument must be a string`);
+    }
+
+    if (this.isValidStatementArg(query) && typeof columnList === 'undefined') {
+      // Validated as two-arg variant (alias, statement).
+      return;
+    }
+
+    // Attempt to interpret as three-arg variant (alias, columnList, statement).
+    const isNonEmptyNameList =
+      Array.isArray(columnList) &&
+      columnList.length > 0 &&
+      columnList.every((it) => typeof it === 'string');
+    if (!isNonEmptyNameList) {
+      throw new Error(
+        `${method}() second argument must be a statement or non-empty column name list.`
+      );
+    }
+
+    if (this.isValidStatementArg(query)) {
+      return;
+    }
+    throw new Error(
+      `${method}() third argument must be a function / QueryBuilder or a raw when its second argument is a column name list`
+    );
+  }
 
   with(alias, statementOrColumnList, nothingOrStatement) {
-    validateWithArgs(alias, statementOrColumnList, nothingOrStatement, 'with');
+    this._validateWithArgs(
+      alias,
+      statementOrColumnList,
+      nothingOrStatement,
+      'with'
+    );
     return this.withWrapped(alias, statementOrColumnList, nothingOrStatement);
   }
 
+  withMaterialized(alias, statementOrColumnList, nothingOrStatement) {
+    throw new Error('With materialized is not supported by this dialect');
+  }
+
+  withNotMaterialized(alias, statementOrColumnList, nothingOrStatement) {
+    throw new Error('With materialized is not supported by this dialect');
+  }
+
   // Helper for compiling any advanced `with` queries.
-  withWrapped(alias, statementOrColumnList, nothingOrStatement) {
+  withWrapped(alias, statementOrColumnList, nothingOrStatement, materialized) {
     const [query, columnList] =
       typeof nothingOrStatement === 'undefined'
         ? [statementOrColumnList, undefined]
         : [nothingOrStatement, statementOrColumnList];
-    this._statements.push({
+    const statement = {
       grouping: 'with',
       type: 'withWrapped',
       alias: alias,
       columnList,
       value: query,
-    });
+    };
+    if (materialized !== undefined) {
+      statement.materialized = materialized;
+    }
+    this._statements.push(statement);
     return this;
   }
 
@@ -144,7 +201,7 @@ class Builder extends EventEmitter {
   // ------
 
   withRecursive(alias, statementOrColumnList, nothingOrStatement) {
-    validateWithArgs(
+    this._validateWithArgs(
       alias,
       statementOrColumnList,
       nothingOrStatement,
@@ -246,7 +303,6 @@ class Builder extends EventEmitter {
 
   // Adds a join clause to the query, allowing for advanced joins
   // with an anonymous function as the second argument.
-  // function(table, first, operator, second)
   join(table, first, ...args) {
     let join;
     const schema =
@@ -269,6 +325,12 @@ class Builder extends EventEmitter {
     return this;
   }
 
+  using(tables) {
+    throw new Error(
+      "'using' function is only available in PostgreSQL dialect with Delete statements."
+    );
+  }
+
   // JOIN blocks:
   innerJoin(...args) {
     return this._joinType('inner').join(...args);
@@ -429,7 +491,7 @@ class Builder extends EventEmitter {
 
   // Adds an `not where` clause to the query.
   whereNot(column, ...args) {
-    if (args.length >= 1) {
+    if (args.length >= 2) {
       if (args[0] === 'in' || args[0] === 'between') {
         this.client.logger.warn(
           'whereNot is not suitable for "in" and "between" type subqueries. You should use "not in" and "not between" instead.'
@@ -611,6 +673,29 @@ class Builder extends EventEmitter {
     return this._bool('or').whereNotBetween(column, values);
   }
 
+  _whereLike(type, column, value) {
+    this._statements.push({
+      grouping: 'where',
+      type: type,
+      column,
+      value: value,
+      not: this._not(),
+      bool: this._bool(),
+      asColumn: this._asColumnFlag,
+    });
+    return this;
+  }
+
+  // Adds a `where like` clause to the query.
+  whereLike(column, value) {
+    return this._whereLike('whereLike', column, value);
+  }
+
+  // Adds a `where ilike` clause to the query.
+  whereILike(column, value) {
+    return this._whereLike('whereILike', column, value);
+  }
+
   // Adds a `group by` clause to the query.
   groupBy(item) {
     if (item && item.isRawInstance) {
@@ -920,8 +1005,18 @@ class Builder extends EventEmitter {
     return this._bool('or').havingRaw(sql, bindings);
   }
 
+  // set the skip binding parameter (= insert the raw value in the query) for an attribute.
+  _setSkipBinding(attribute, options) {
+    let skipBinding = options;
+    if (isObject(options)) {
+      skipBinding = options.skipBinding;
+    }
+    this._single.skipBinding = this._single.skipBinding || {};
+    this._single.skipBinding[attribute] = skipBinding;
+  }
+
   // Only allow a single "offset" to be set for the current query.
-  offset(value) {
+  offset(value, options) {
     if (value == null || value.isRawInstance || value instanceof Builder) {
       // Builder for backward compatibility
       this._single.offset = value;
@@ -935,16 +1030,18 @@ class Builder extends EventEmitter {
         this._single.offset = val;
       }
     }
+    this._setSkipBinding('offset', options);
     return this;
   }
 
   // Only allow a single "limit" to be set for the current query.
-  limit(value) {
+  limit(value, options) {
     const val = parseInt(value, 10);
     if (isNaN(val)) {
       this.client.logger.warn('A valid integer must be provided to limit');
     } else {
       this._single.limit = val;
+      this._setSkipBinding('limit', options);
     }
     return this;
   }
@@ -1192,7 +1289,11 @@ class Builder extends EventEmitter {
   // Set a lock for update constraint.
   forUpdate(...tables) {
     this._single.lock = lockMode.forUpdate;
-    this._single.lockTables = tables;
+    if (tables.length === 1 && Array.isArray(tables[0])) {
+      this._single.lockTables = tables[0];
+    } else {
+      this._single.lockTables = tables;
+    }
     return this;
   }
 
@@ -1266,6 +1367,11 @@ class Builder extends EventEmitter {
     return this;
   }
 
+  fromRaw(sql, bindings) {
+    const raw = sql.isRawInstance ? sql : this.client.raw(sql, bindings);
+    return this.from(raw);
+  }
+
   // Passes query to provided callback function, useful for e.g. composing
   // domain-specific helpers
   modify(callback) {
@@ -1279,6 +1385,179 @@ class Builder extends EventEmitter {
     );
   }
 
+  // JSON support functions
+  _json(nameFunction, params) {
+    this._statements.push({
+      grouping: 'columns',
+      type: 'json',
+      method: nameFunction,
+      params: params,
+    });
+    return this;
+  }
+
+  jsonExtract() {
+    const column = arguments[0];
+    let path;
+    let alias;
+    let singleValue = true;
+
+    // We use arguments to have the signatures :
+    // - column (string or array)
+    // - column + path
+    // - column + path + alias
+    // - column + path + alias + singleValue
+    // - column array + singleValue
+    if (arguments.length >= 2) {
+      path = arguments[1];
+    }
+    if (arguments.length >= 3) {
+      alias = arguments[2];
+    }
+    if (arguments.length === 4) {
+      singleValue = arguments[3];
+    }
+    if (
+      arguments.length === 2 &&
+      Array.isArray(arguments[0]) &&
+      isBoolean(arguments[1])
+    ) {
+      singleValue = arguments[1];
+    }
+    return this._json('jsonExtract', {
+      column: column,
+      path: path,
+      alias: alias,
+      singleValue, // boolean used only in MSSQL to use function for extract value instead of object/array.
+    });
+  }
+
+  jsonSet(column, path, value, alias) {
+    return this._json('jsonSet', {
+      column: column,
+      path: path,
+      value: value,
+      alias: alias,
+    });
+  }
+
+  jsonInsert(column, path, value, alias) {
+    return this._json('jsonInsert', {
+      column: column,
+      path: path,
+      value: value,
+      alias: alias,
+    });
+  }
+
+  jsonRemove(column, path, alias) {
+    return this._json('jsonRemove', {
+      column: column,
+      path: path,
+      alias: alias,
+    });
+  }
+
+  // Wheres for JSON
+  _isJsonObject(jsonValue) {
+    return isObject(jsonValue) && !(jsonValue instanceof Builder);
+  }
+
+  _whereJsonWrappedValue(type, column, value) {
+    const whereJsonClause = {
+      grouping: 'where',
+      type: type,
+      column,
+      value: value,
+      not: this._not(),
+      bool: this._bool(),
+      asColumn: this._asColumnFlag,
+    };
+    if (arguments[3]) {
+      whereJsonClause.operator = arguments[3];
+    }
+    if (arguments[4]) {
+      whereJsonClause.jsonPath = arguments[4];
+    }
+    this._statements.push(whereJsonClause);
+  }
+
+  whereJsonObject(column, value) {
+    this._whereJsonWrappedValue('whereJsonObject', column, value);
+    return this;
+  }
+
+  orWhereJsonObject(column, operator, value) {
+    return this._bool('or').whereJsonObject(column, operator, value);
+  }
+
+  whereNotJsonObject(column, value) {
+    this._not(true)._whereJsonWrappedValue('whereJsonObject', column, value);
+    return this;
+  }
+
+  orWhereNotJsonObject(column, operator, value) {
+    return this._not(true)._bool('or').whereJsonObject(column, operator, value);
+  }
+
+  whereJsonPath(column, path, operator, value) {
+    this._whereJsonWrappedValue('whereJsonPath', column, value, operator, path);
+    return this;
+  }
+
+  orWhereJsonPath(column, operator, value) {
+    return this._bool('or').whereJsonPath(column, operator, value);
+  }
+
+  // Json superset wheres
+  whereJsonSupersetOf(column, value) {
+    this._whereJsonWrappedValue('whereJsonSupersetOf', column, value);
+    return this;
+  }
+
+  whereJsonNotSupersetOf(column, value) {
+    this._not(true).whereJsonSupersetOf(column, value);
+    return this;
+  }
+
+  orWhereJsonSupersetOf(column, value) {
+    this._whereJsonWrappedValue('whereJsonSupersetOf', column, value);
+    return this;
+  }
+
+  orWhereJsonNotSupersetOf(column, value) {
+    this._not(true)._bool('or').whereJsonSupersetOf(column, value);
+    return this;
+  }
+
+  // Json subset wheres
+  whereJsonSubsetOf(column, value) {
+    this._whereJsonWrappedValue('whereJsonSubsetOf', column, value);
+    return this;
+  }
+
+  whereJsonNotSubsetOf(column, value) {
+    this._not(true).whereJsonSubsetOf(column, value);
+    return this;
+  }
+
+  orWhereJsonSubsetOf(column, value) {
+    this._whereJsonWrappedValue('whereJsonSubsetOf', column, value);
+    return this;
+  }
+
+  orWhereJsonNotSubsetOf(column, value) {
+    this._not(true)._bool('or').whereJsonSubsetOf(column, value);
+    return this;
+  }
+
+  whereJsonHasNone(column, values) {
+    this._not(true).whereJsonHasAll(column, values);
+    return this;
+  }
+
+  // end of wheres for JSON
+
   _analytic(alias, second, third) {
     let analytic;
     const { schema } = this._single;
@@ -1434,49 +1713,6 @@ class Builder extends EventEmitter {
   }
 }
 
-const isValidStatementArg = (statement) =>
-  typeof statement === 'function' ||
-  statement instanceof Builder ||
-  (statement && statement.isRawInstance);
-
-const validateWithArgs = function (
-  alias,
-  statementOrColumnList,
-  nothingOrStatement,
-  method
-) {
-  const [query, columnList] =
-    typeof nothingOrStatement === 'undefined'
-      ? [statementOrColumnList, undefined]
-      : [nothingOrStatement, statementOrColumnList];
-  if (typeof alias !== 'string') {
-    throw new Error(`${method}() first argument must be a string`);
-  }
-
-  if (isValidStatementArg(query) && typeof columnList === 'undefined') {
-    // Validated as two-arg variant (alias, statement).
-    return;
-  }
-
-  // Attempt to interpret as three-arg variant (alias, columnList, statement).
-  const isNonEmptyNameList =
-    Array.isArray(columnList) &&
-    columnList.length > 0 &&
-    columnList.every((it) => typeof it === 'string');
-  if (!isNonEmptyNameList) {
-    throw new Error(
-      `${method}() second argument must be a statement or non-empty column name list.`
-    );
-  }
-
-  if (isValidStatementArg(query)) {
-    return;
-  }
-  throw new Error(
-    `${method}() third argument must be a function / QueryBuilder or a raw when its second argument is a column name list`
-  );
-};
-
 Builder.prototype.select = Builder.prototype.columns;
 Builder.prototype.column = Builder.prototype.columns;
 Builder.prototype.andWhereNot = Builder.prototype.whereNot;
@@ -1486,6 +1722,9 @@ Builder.prototype.andWhereColumn = Builder.prototype.whereColumn;
 Builder.prototype.andWhereRaw = Builder.prototype.whereRaw;
 Builder.prototype.andWhereBetween = Builder.prototype.whereBetween;
 Builder.prototype.andWhereNotBetween = Builder.prototype.whereNotBetween;
+Builder.prototype.andWhereJsonObject = Builder.prototype.whereJsonObject;
+Builder.prototype.andWhereNotJsonObject = Builder.prototype.whereJsonObject;
+Builder.prototype.andWhereJsonPath = Builder.prototype.whereJsonPath;
 Builder.prototype.andHaving = Builder.prototype.having;
 Builder.prototype.andHavingIn = Builder.prototype.havingIn;
 Builder.prototype.andHavingNotIn = Builder.prototype.havingNotIn;