knex 0.95.13 → 1.0.1

package/lib/query/querybuilder.js

@@ -246,7 +246,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 +268,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 +434,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 +616,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 +948,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 +973,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 +1232,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 +1310,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 +1328,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;
@@ -1486,6 +1708,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;