knex 0.95.14 → 1.0.2

package/lib/query/querycompiler.js

@@ -144,7 +144,34 @@ 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;
+  }
+
+  _onConflictClause(columns) {
+    return columns instanceof Raw
+      ? this.formatter.wrap(columns)
+      : `(${this.formatter.columnize(columns)})`;
+  }
+
+  _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 +191,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 +246,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 +261,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 +352,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 +367,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 +457,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 +484,7 @@ class QueryCompiler {
       ) +
       ' ' +
       this._not(statement, 'in ') +
-      this.wrap(
-        this.client.parameterize(
-          statement.value,
-          undefined,
-          this.builder,
-          this.bindingsHolder
-        )
-      )
+      this.wrap(values)
     );
   }
 
@@ -653,24 +685,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 +717,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 +915,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 +949,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 +1011,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 +1075,37 @@ class QueryCompiler {
     );
   }
 
+  _jsonWrapValue(jsonValue) {
+    if (!this.builder._isJsonObject(jsonValue)) {
+      try {
+        return JSON.stringify(JSON.parse(jsonValue.replace(/\n|\t/g, '')));
+      } catch (e) {
+        return jsonValue;
+      }
+    }
+    return JSON.stringify(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;
@@ -1097,6 +1180,12 @@ class QueryCompiler {
         ) +
         ')'
       : '';
+    const materialized =
+      statement.materialized === undefined
+        ? ''
+        : statement.materialized
+        ? 'materialized '
+        : 'not materialized ';
     return (
       (val &&
         columnize_(
@@ -1106,7 +1195,9 @@ class QueryCompiler {
           this.bindingsHolder
         ) +
           columnList +
-          ' as (' +
+          ' as ' +
+          materialized +
+          '(' +
           val +
           ')') ||
       ''
@@ -1235,8 +1326,9 @@ class QueryCompiler {
       nullOrder = ' is not null';
     }
 
+    let groupOrder;
     if (value instanceof Raw) {
-      return unwrapRaw_(
+      groupOrder = unwrapRaw_(
         value,
         undefined,
         this.builder,
@@ -1244,10 +1336,46 @@ 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;
+  }
+
+  _basicGroupOrder(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;
+  }
+
+  _groupOrder(item, type) {
+    return this._basicGroupOrder(item, type);
+  }
+
+  _groupOrderNulls(item, type) {
+    const column = this._formatGroupsItemValue(item.value);
+    const direction =
+      type === 'order' && item.type !== 'orderByRaw'
+        ? ` ${direction_(
+            item.direction,
+            this.builder,
+            this.client,
+            this.bindingsHolder
+          )}`
+        : '';
+    if (item.nulls && !(item.value instanceof Raw)) {
+      return `${column}${direction ? direction : ''} nulls ${item.nulls}`;
+    }
+    return column + direction;
   }
 
   // Compiles the `order by` statements.
@@ -1255,17 +1383,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 +1419,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.
@@ -102,8 +110,13 @@ AlterMethods.alterType = function (type) {
 };
 
 // Set column method to alter (default is add).
-AlterMethods.alter = function () {
+AlterMethods.alter = function ({
+  alterNullable = true,
+  alterType = true,
+} = {}) {
   this._method = 'alter';
+  this.alterNullable = alterNullable;
+  this.alterType = alterType;
 
   return this;
 };