knex 0.95.13 → 1.0.1

package/lib/query/querycompiler.js

@@ -144,7 +144,28 @@ class QueryCompiler {
   // inserts using a single query statement.
   insert() {
     const insertValues = this.single.insert || [];
-    let sql = this.with() + `insert into ${this.tableName} `;
+    const sql = this.with() + `insert into ${this.tableName} `;
+    const body = this._insertBody(insertValues);
+    return body === '' ? '' : sql + body;
+  }
+
+  _buildInsertValues(insertData) {
+    let sql = '';
+    let i = -1;
+    while (++i < insertData.values.length) {
+      if (i !== 0) sql += '), (';
+      sql += this.client.parameterize(
+        insertData.values[i],
+        this.client.valueForUndefined,
+        this.builder,
+        this.bindingsHolder
+      );
+    }
+    return sql;
+  }
+
+  _insertBody(insertValues) {
+    let sql = '';
     if (Array.isArray(insertValues)) {
       if (insertValues.length === 0) {
         return '';
@@ -164,18 +185,7 @@ class QueryCompiler {
           this.client,
           this.bindingsHolder
         )}`;
-        sql += ') values (';
-        let i = -1;
-        while (++i < insertData.values.length) {
-          if (i !== 0) sql += '), (';
-          sql += this.client.parameterize(
-            insertData.values[i],
-            this.client.valueForUndefined,
-            this.builder,
-            this.bindingsHolder
-          );
-        }
-        sql += ')';
+        sql += ') values (' + this._buildInsertValues(insertData) + ')';
       } else if (insertValues.length === 1 && insertValues[0]) {
         sql += this._emptyInsertValue;
       } else {
@@ -230,6 +240,8 @@ class QueryCompiler {
           sql.push(this.aggregateRaw(stmt));
         } else if (stmt.type === 'analytic') {
           sql.push(this.analytic(stmt));
+        } else if (stmt.type === 'json') {
+          sql.push(this.json(stmt));
         } else if (stmt.value && stmt.value.length > 0) {
           sql.push(
             columnize_(
@@ -243,8 +255,9 @@ class QueryCompiler {
       }
     }
     if (sql.length === 0) sql = ['*'];
+    const select = this.onlyJson() ? '' : 'select ';
     return (
-      `select ${hints}${distinctClause}` +
+      `${select}${hints}${distinctClause}` +
       sql.join(', ') +
       (this.tableName
         ? ` from ${this.single.only ? 'only ' : ''}${this.tableName}`
@@ -333,6 +346,12 @@ class QueryCompiler {
     })`;
   }
 
+  _joinTable(join) {
+    return join.schema && !(join.table instanceof Raw)
+      ? `${join.schema}.${join.table}`
+      : join.table;
+  }
+
   // Compiles all each of the `join` clauses on the query,
   // including any nested join queries.
   join() {
@@ -342,10 +361,7 @@ class QueryCompiler {
     if (!joins) return '';
     while (++i < joins.length) {
       const join = joins[i];
-      const table =
-        join.schema && !(join.table instanceof Raw)
-          ? `${join.schema}.${join.table}`
-          : join.table;
+      const table = this._joinTable(join);
       if (i > 0) sql += ' ';
       if (join.joinType === 'raw') {
         sql += unwrapRaw_(
@@ -435,6 +451,23 @@ class QueryCompiler {
 
   onIn(statement) {
     if (Array.isArray(statement.column)) return this.multiOnIn(statement);
+
+    let values;
+    if (statement.value instanceof Raw) {
+      values = this.client.parameter(
+        statement.value,
+        this.builder,
+        this.formatter
+      );
+    } else {
+      values = this.client.parameterize(
+        statement.value,
+        undefined,
+        this.builder,
+        this.bindingsHolder
+      );
+    }
+
     return (
       wrap_(
         statement.column,
@@ -445,14 +478,7 @@ class QueryCompiler {
       ) +
       ' ' +
       this._not(statement, 'in ') +
-      this.wrap(
-        this.client.parameterize(
-          statement.value,
-          undefined,
-          this.builder,
-          this.bindingsHolder
-        )
-      )
+      this.wrap(values)
     );
   }
 
@@ -653,24 +679,7 @@ class QueryCompiler {
   }
 
   multiHavingIn(statement) {
-    let i = -1,
-      sql = `(${columnize_(
-        statement.column,
-        this.builder,
-        this.client,
-        this.bindingsHolder
-      )}) `;
-    sql += this._not(statement, 'in ') + '((';
-    while (++i < statement.value.length) {
-      if (i !== 0) sql += '),(';
-      sql += this.client.parameterize(
-        statement.value[i],
-        undefined,
-        this.builder,
-        this.bindingsHolder
-      );
-    }
-    return sql + '))';
+    return this.multiOnIn(statement);
   }
 
   // Compile the "union" queries attached to the main query.
@@ -702,26 +711,44 @@ class QueryCompiler {
   // If we haven't specified any columns or a `tableName`, we're assuming this
   // is only being used for unions.
   onlyUnions() {
-    return !this.grouped.columns && this.grouped.union && !this.tableName;
+    return (
+      (!this.grouped.columns || !!this.grouped.columns[0].value) &&
+      this.grouped.union &&
+      !this.tableName
+    );
+  }
+
+  _getValueOrParameterFromAttribute(attribute, rawValue) {
+    if (this.single.skipBinding[attribute] === true) {
+      return rawValue !== undefined && rawValue !== null
+        ? rawValue
+        : this.single[attribute];
+    }
+    return this.client.parameter(
+      this.single[attribute],
+      this.builder,
+      this.bindingsHolder
+    );
+  }
+
+  onlyJson() {
+    return (
+      !this.tableName &&
+      this.grouped.columns &&
+      this.grouped.columns.length === 1 &&
+      this.grouped.columns[0].type === 'json'
+    );
   }
 
   limit() {
     const noLimit = !this.single.limit && this.single.limit !== 0;
     if (noLimit) return '';
-    return `limit ${this.client.parameter(
-      this.single.limit,
-      this.builder,
-      this.bindingsHolder
-    )}`;
+    return `limit ${this._getValueOrParameterFromAttribute('limit')}`;
   }
 
   offset() {
     if (!this.single.offset) return '';
-    return `offset ${this.client.parameter(
-      this.single.offset,
-      this.builder,
-      this.bindingsHolder
-    )}`;
+    return `offset ${this._getValueOrParameterFromAttribute('offset')}`;
   }
 
   // Compiles a `delete` query.
@@ -882,7 +909,23 @@ class QueryCompiler {
   // Where Clause
   // ------
 
-  whereIn(statement) {
+  _valueClause(statement) {
+    return statement.asColumn
+      ? wrap_(
+          statement.value,
+          undefined,
+          this.builder,
+          this.client,
+          this.bindingsHolder
+        )
+      : this.client.parameter(
+          statement.value,
+          this.builder,
+          this.bindingsHolder
+        );
+  }
+
+  _columnClause(statement) {
     let columns;
     if (Array.isArray(statement.column)) {
       columns = `(${columnize_(
@@ -900,13 +943,33 @@ class QueryCompiler {
         this.bindingsHolder
       );
     }
+    return columns;
+  }
 
+  whereIn(statement) {
     const values = this.client.values(
       statement.value,
       this.builder,
       this.bindingsHolder
     );
-    return `${columns} ${this._not(statement, 'in ')}${values}`;
+    return `${this._columnClause(statement)} ${this._not(
+      statement,
+      'in '
+    )}${values}`;
+  }
+
+  whereLike(statement) {
+    return `${this._columnClause(statement)} ${this._not(
+      statement,
+      'like '
+    )}${this._valueClause(statement)}`;
+  }
+
+  whereILike(statement) {
+    return `${this._columnClause(statement)} ${this._not(
+      statement,
+      'ilike '
+    )}${this._valueClause(statement)}`;
   }
 
   whereNull(statement) {
@@ -942,19 +1005,7 @@ class QueryCompiler {
         this.bindingsHolder
       ) +
       ' ' +
-      (statement.asColumn
-        ? wrap_(
-            statement.value,
-            undefined,
-            this.builder,
-            this.client,
-            this.bindingsHolder
-          )
-        : this.client.parameter(
-            statement.value,
-            this.builder,
-            this.bindingsHolder
-          ))
+      this._valueClause(statement)
     );
   }
 
@@ -1018,11 +1069,33 @@ class QueryCompiler {
     );
   }
 
+  _jsonWrapValue(jsonValue) {
+    if (this.builder._isJsonObject(jsonValue)) {
+      return JSON.stringify(jsonValue);
+    }
+    return jsonValue;
+  }
+
+  _jsonValueClause(statement) {
+    statement.value = this._jsonWrapValue(statement.value);
+    return this._valueClause(statement);
+  }
+
+  whereJsonObject(statement) {
+    return `${this._columnClause(statement)} ${
+      statement.not ? '!=' : '='
+    } ${this._jsonValueClause(statement)}`;
+  }
+
   wrap(str) {
     if (str.charAt(0) !== '(') return `(${str})`;
     return str;
   }
 
+  json(stmt) {
+    return this[stmt.method](stmt.params);
+  }
+
   analytic(stmt) {
     let sql = '';
     const self = this;
@@ -1235,8 +1308,9 @@ class QueryCompiler {
       nullOrder = ' is not null';
     }
 
+    let groupOrder;
     if (value instanceof Raw) {
-      return unwrapRaw_(
+      groupOrder = unwrapRaw_(
         value,
         undefined,
         this.builder,
@@ -1244,10 +1318,25 @@ class QueryCompiler {
         this.bindingsHolder
       );
     } else if (value instanceof QueryBuilder || nulls) {
-      return '(' + formatter.columnize(value) + nullOrder + ')';
+      groupOrder = '(' + formatter.columnize(value) + nullOrder + ')';
     } else {
-      return formatter.columnize(value);
+      groupOrder = formatter.columnize(value);
     }
+    return groupOrder;
+  }
+
+  _groupOrder(item, type) {
+    const column = this._formatGroupsItemValue(item.value, item.nulls);
+    const direction =
+      type === 'order' && item.type !== 'orderByRaw'
+        ? ` ${direction_(
+            item.direction,
+            this.builder,
+            this.client,
+            this.bindingsHolder
+          )}`
+        : '';
+    return column + direction;
   }
 
   // Compiles the `order by` statements.
@@ -1255,17 +1344,7 @@ class QueryCompiler {
     const items = this.grouped[type];
     if (!items) return '';
     const sql = items.map((item) => {
-      const column = this._formatGroupsItemValue(item.value, item.nulls);
-      const direction =
-        type === 'order' && item.type !== 'orderByRaw'
-          ? ` ${direction_(
-              item.direction,
-              this.builder,
-              this.client,
-              this.bindingsHolder
-            )}`
-          : '';
-      return column + direction;
+      return this._groupOrder(item, type);
     });
     return sql.length ? type + ' by ' + sql.join(', ') : '';
   }
@@ -1301,6 +1380,112 @@ class QueryCompiler {
     }
     return this._tableName;
   }
+
+  _jsonPathWrap(extraction) {
+    return this.client.parameter(
+      extraction.path || extraction[1],
+      this.builder,
+      this.bindingsHolder
+    );
+  }
+
+  // Json common functions
+  _jsonExtract(nameFunction, params) {
+    let extractions;
+    if (Array.isArray(params.column)) {
+      extractions = params.column;
+    } else {
+      extractions = [params];
+    }
+    if (!Array.isArray(nameFunction)) {
+      nameFunction = [nameFunction];
+    }
+    return extractions
+      .map((extraction) => {
+        let jsonCol = `${columnize_(
+          extraction.column || extraction[0],
+          this.builder,
+          this.client,
+          this.bindingsHolder
+        )}, ${this._jsonPathWrap(extraction)}`;
+        nameFunction.forEach((f) => {
+          jsonCol = f + '(' + jsonCol + ')';
+        });
+        const alias = extraction.alias || extraction[2];
+        return alias
+          ? this.client.alias(jsonCol, this.formatter.wrap(alias))
+          : jsonCol;
+      })
+      .join(', ');
+  }
+
+  _jsonSet(nameFunction, params) {
+    const jsonSet = `${nameFunction}(${columnize_(
+      params.column,
+      this.builder,
+      this.client,
+      this.bindingsHolder
+    )}, ${this.client.parameter(
+      params.path,
+      this.builder,
+      this.bindingsHolder
+    )}, ${this.client.parameter(
+      params.value,
+      this.builder,
+      this.bindingsHolder
+    )})`;
+    return params.alias
+      ? this.client.alias(jsonSet, this.formatter.wrap(params.alias))
+      : jsonSet;
+  }
+
+  _whereJsonPath(nameFunction, statement) {
+    return `${nameFunction}(${this._columnClause(
+      statement
+    )}, ${this._jsonPathWrap({ path: statement.jsonPath })}) ${operator_(
+      statement.operator,
+      this.builder,
+      this.client,
+      this.bindingsHolder
+    )} ${this._jsonValueClause(statement)}`;
+  }
+
+  _onJsonPathEquals(nameJoinFunction, clause) {
+    return (
+      nameJoinFunction +
+      '(' +
+      wrap_(
+        clause.columnFirst,
+        undefined,
+        this.builder,
+        this.client,
+        this.bindingsHolder
+      ) +
+      ', ' +
+      this.client.parameter(
+        clause.jsonPathFirst,
+        this.builder,
+        this.bindingsHolder
+      ) +
+      ') = ' +
+      nameJoinFunction +
+      '(' +
+      wrap_(
+        clause.columnSecond,
+        undefined,
+        this.builder,
+        this.client,
+        this.bindingsHolder
+      ) +
+      ', ' +
+      this.client.parameter(
+        clause.jsonPathSecond,
+        this.builder,
+        this.bindingsHolder
+      ) +
+      ')'
+    );
+  }
 }
 
 module.exports = QueryCompiler;

package/lib/schema/columnbuilder.js

@@ -42,6 +42,14 @@ const modifiers = [
   'after',
   'comment',
   'collate',
+  'check',
+  'checkPositive',
+  'checkNegative',
+  'checkIn',
+  'checkNotIn',
+  'checkBetween',
+  'checkLength',
+  'checkRegex',
 ];
 
 // Aliases for convenience.

package/lib/schema/columncompiler.js

@@ -9,6 +9,7 @@ const has = require('lodash/has');
 const tail = require('lodash/tail');
 const { toNumber } = require('../util/helpers');
 const { formatDefault } = require('../formatter/formatterUtils');
+const { operator: operator_ } = require('../formatter/wrappingFormatter');
 
 class ColumnCompiler {
   constructor(client, tableCompiler, columnBuilder) {
@@ -29,6 +30,21 @@ class ColumnCompiler {
 
     this.sequence = [];
     this.modifiers = [];
+
+    this.checksCount = 0;
+  }
+
+  _addCheckModifiers() {
+    this.modifiers.push(
+      'check',
+      'checkPositive',
+      'checkNegative',
+      'checkIn',
+      'checkNotIn',
+      'checkBetween',
+      'checkLength',
+      'checkRegex'
+    );
   }
 
   defaults(label) {
@@ -134,6 +150,120 @@ class ColumnCompiler {
   defaultTo(value) {
     return `default ${formatDefault(value, this.type, this.client)}`;
   }
+
+  increments(options = { primaryKey: true }) {
+    return (
+      'integer not null' +
+      (this.tableCompiler._canBeAddPrimaryKey(options) ? ' primary key' : '') +
+      ' autoincrement'
+    );
+  }
+
+  bigincrements(options = { primaryKey: true }) {
+    return this.increments(options);
+  }
+
+  _pushAlterCheckQuery(checkPredicate, constraintName) {
+    let checkName = constraintName;
+    if (!checkName) {
+      this.checksCount++;
+      checkName =
+        this.tableCompiler.tableNameRaw +
+        '_' +
+        this.getColumnName() +
+        '_' +
+        this.checksCount;
+    }
+    this.pushAdditional(function () {
+      this.pushQuery(
+        `alter table ${this.tableCompiler.tableName()} add constraint ${checkName} check(${checkPredicate})`
+      );
+    });
+  }
+
+  _checkConstraintName(constraintName) {
+    return constraintName ? `constraint ${constraintName} ` : '';
+  }
+
+  _check(checkPredicate, constraintName) {
+    if (this.columnBuilder._method === 'alter') {
+      this._pushAlterCheckQuery(checkPredicate, constraintName);
+      return '';
+    }
+    return `${this._checkConstraintName(
+      constraintName
+    )}check (${checkPredicate})`;
+  }
+
+  checkPositive(constraintName) {
+    return this._check(
+      `${this.formatter.wrap(this.getColumnName())} ${operator_(
+        '>',
+        this.columnBuilder,
+        this.bindingsHolder
+      )} 0`,
+      constraintName
+    );
+  }
+
+  checkNegative(constraintName) {
+    return this._check(
+      `${this.formatter.wrap(this.getColumnName())} ${operator_(
+        '<',
+        this.columnBuilder,
+        this.bindingsHolder
+      )} 0`,
+      constraintName
+    );
+  }
+
+  _checkIn(values, constraintName, not) {
+    return this._check(
+      `${this.formatter.wrap(this.getColumnName())} ${
+        not ? 'not ' : ''
+      }in (${values.map((v) => this.client._escapeBinding(v)).join(',')})`,
+      constraintName
+    );
+  }
+
+  checkIn(values, constraintName) {
+    return this._checkIn(values, constraintName);
+  }
+
+  checkNotIn(values, constraintName) {
+    return this._checkIn(values, constraintName, true);
+  }
+
+  checkBetween(intervals, constraintName) {
+    if (
+      intervals.length === 2 &&
+      !Array.isArray(intervals[0]) &&
+      !Array.isArray(intervals[1])
+    ) {
+      intervals = [intervals];
+    }
+    const intervalChecks = intervals
+      .map((interval) => {
+        return `${this.formatter.wrap(
+          this.getColumnName()
+        )} between ${this.client._escapeBinding(
+          interval[0]
+        )} and ${this.client._escapeBinding(interval[1])}`;
+      })
+      .join(' or ');
+    return this._check(intervalChecks, constraintName);
+  }
+
+  checkLength(operator, length, constraintName) {
+    return this._check(
+      `length(${this.formatter.wrap(this.getColumnName())}) ${operator_(
+        operator,
+        this.columnBuilder,
+        this.bindingsHolder
+      )} ${toNumber(length)}`,
+      constraintName
+    );
+  }
 }
 
 ColumnCompiler.prototype.binary = 'blob';
@@ -147,11 +277,8 @@ ColumnCompiler.prototype.geography = 'geography';
 ColumnCompiler.prototype.point = 'point';
 ColumnCompiler.prototype.enu = 'varchar';
 ColumnCompiler.prototype.bit = ColumnCompiler.prototype.json = 'text';
-ColumnCompiler.prototype.uuid = 'char(36)';
-ColumnCompiler.prototype.increments = ({ primaryKey = true } = {}) =>
-  'integer not null' + (primaryKey ? ' primary key' : '') + ' autoincrement';
-ColumnCompiler.prototype.bigincrements = ({ primaryKey = true } = {}) =>
-  'integer not null' + (primaryKey ? ' primary key' : '') + ' autoincrement';
+ColumnCompiler.prototype.uuid = ({ useBinaryUuid = false } = {}) =>
+  useBinaryUuid ? 'binary(16)' : 'char(36)';
 ColumnCompiler.prototype.integer =
   ColumnCompiler.prototype.smallint =
   ColumnCompiler.prototype.mediumint =

package/lib/schema/compiler.js

@@ -106,6 +106,7 @@ class SchemaCompiler {
       sql: Array.isArray(generatedCommands)
         ? generatedCommands
         : [generatedCommands],
+      check: null,
       post: [],
     };
   }