knex 0.95.14 → 1.0.2

package/lib/dialects/mssql/query/mssql-querycompiler.js

@@ -6,6 +6,9 @@ const compact = require('lodash/compact');
 const identity = require('lodash/identity');
 const isEmpty = require('lodash/isEmpty');
 const Raw = require('../../../raw.js');
+const {
+  columnize: columnize_,
+} = require('../../../formatter/wrappingFormatter');
 
 const components = [
   'columns',
@@ -100,40 +103,37 @@ class QueryCompiler_MSSQL extends QueryCompiler {
         returning,
       };
     }
+    sql += this._buildInsertData(insertValues, returningSql);
 
+    if (returning) {
+      sql += this._buildReturningSelect(returning);
+    }
+
+    return {
+      sql,
+      returning,
+    };
+  }
+
+  _buildInsertData(insertValues, returningSql) {
+    let sql = '';
     const insertData = this._prepInsert(insertValues);
     if (typeof insertData === 'string') {
       sql += insertData;
     } else {
       if (insertData.columns.length) {
         sql += `(${this.formatter.columnize(insertData.columns)}`;
-        sql += `) ${returningSql}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 +=
+          `) ${returningSql}values (` +
+          this._buildInsertValues(insertData) +
+          ')';
       } else if (insertValues.length === 1 && insertValues[0]) {
         sql += returningSql + this._emptyInsertValue;
       } else {
-        sql = '';
+        return '';
       }
     }
-
-    if (returning) {
-      sql += this._buildReturningSelect(returning);
-    }
-
-    return {
-      sql,
-      returning,
-    };
+    return sql;
   }
 
   standardInsert() {
@@ -155,30 +155,7 @@ class QueryCompiler_MSSQL extends QueryCompiler {
       };
     }
 
-    const insertData = this._prepInsert(insertValues);
-    if (typeof insertData === 'string') {
-      sql += insertData;
-    } else {
-      if (insertData.columns.length) {
-        sql += `(${this.formatter.columnize(insertData.columns)}`;
-        sql += `) ${returningSql}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 += ')';
-      } else if (insertValues.length === 1 && insertValues[0]) {
-        sql += returningSql + this._emptyInsertValue;
-      } else {
-        sql = '';
-      }
-    }
+    sql += this._buildInsertData(insertValues, returningSql);
 
     return {
       sql,
@@ -354,15 +331,17 @@ class QueryCompiler_MSSQL extends 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(this.formatter.columnize(stmt.value));
         }
       }
     }
     if (sql.length === 0) sql = ['*'];
-
+    const select = this.onlyJson() ? '' : 'select ';
     return (
-      `select ${hints}${distinctClause}` +
+      `${select}${hints}${distinctClause}` +
       (top ? top + ' ' : '') +
       sql.join(', ') +
       (this.tableName ? ` from ${this.tableName}` : '')
@@ -502,11 +481,7 @@ class QueryCompiler_MSSQL extends QueryCompiler {
     const noLimit = !this.single.limit && this.single.limit !== 0;
     const noOffset = !this.single.offset;
     if (noLimit || !noOffset) return '';
-    return `top (${this.client.parameter(
-      this.single.limit,
-      this.builder,
-      this.bindingsHolder
-    )})`;
+    return `top (${this._getValueOrParameterFromAttribute('limit')})`;
   }
 
   limit() {
@@ -518,23 +493,106 @@ class QueryCompiler_MSSQL extends QueryCompiler {
     const noOffset = !this.single.offset;
     if (noOffset) return '';
     let offset = `offset ${
-      noOffset
-        ? '0'
-        : this.client.parameter(
-            this.single.offset,
-            this.builder,
-            this.bindingsHolder
-          )
+      noOffset ? '0' : this._getValueOrParameterFromAttribute('offset')
     } rows`;
     if (!noLimit) {
-      offset += ` fetch next ${this.client.parameter(
-        this.single.limit,
-        this.builder,
-        this.bindingsHolder
+      offset += ` fetch next ${this._getValueOrParameterFromAttribute(
+        'limit'
       )} rows only`;
     }
     return offset;
   }
+
+  whereLike(statement) {
+    return `${this._columnClause(
+      statement
+    )} collate SQL_Latin1_General_CP1_CS_AS ${this._not(
+      statement,
+      'like '
+    )}${this._valueClause(statement)}`;
+  }
+
+  whereILike(statement) {
+    return `${this._columnClause(
+      statement
+    )} collate SQL_Latin1_General_CP1_CI_AS ${this._not(
+      statement,
+      'like '
+    )}${this._valueClause(statement)}`;
+  }
+
+  jsonExtract(params) {
+    // JSON_VALUE return NULL if we query object or array
+    // JSON_QUERY return NULL if we query literal/single value
+    return this._jsonExtract(
+      params.singleValue ? 'JSON_VALUE' : 'JSON_QUERY',
+      params
+    );
+  }
+
+  jsonSet(params) {
+    return this._jsonSet('JSON_MODIFY', params);
+  }
+
+  jsonInsert(params) {
+    return this._jsonSet('JSON_MODIFY', params);
+  }
+
+  jsonRemove(params) {
+    const jsonCol = `JSON_MODIFY(${columnize_(
+      params.column,
+      this.builder,
+      this.client,
+      this.bindingsHolder
+    )},${this.client.parameter(
+      params.path,
+      this.builder,
+      this.bindingsHolder
+    )}, NULL)`;
+    return params.alias
+      ? this.client.alias(jsonCol, this.formatter.wrap(params.alias))
+      : jsonCol;
+  }
+
+  whereJsonPath(statement) {
+    return this._whereJsonPath('JSON_VALUE', statement);
+  }
+
+  whereJsonSupersetOf(statement) {
+    throw new Error(
+      'Json superset where clause not actually supported by MSSQL'
+    );
+  }
+
+  whereJsonSubsetOf(statement) {
+    throw new Error('Json subset where clause not actually supported by MSSQL');
+  }
+
+  _getExtracts(statement, operator) {
+    const column = columnize_(
+      statement.column,
+      this.builder,
+      this.client,
+      this.bindingsHolder
+    );
+    return (
+      Array.isArray(statement.values) ? statement.values : [statement.values]
+    )
+      .map(function (value) {
+        return (
+          'JSON_VALUE(' +
+          column +
+          ',' +
+          this.client.parameter(value, this.builder, this.bindingsHolder) +
+          ')'
+        );
+      }, this)
+      .join(operator);
+  }
+
+  onJsonPathEquals(clause) {
+    return this._onJsonPathEquals('JSON_VALUE', clause);
+  }
 }
 
 // Set the QueryBuilder & QueryCompiler on the client object,

package/lib/dialects/mssql/schema/mssql-columncompiler.js

@@ -3,11 +3,13 @@
 const ColumnCompiler = require('../../../schema/columncompiler');
 const { toNumber } = require('../../../util/helpers');
 const { formatDefault } = require('../../../formatter/formatterUtils');
+const { operator: operator_ } = require('../../../formatter/wrappingFormatter');
 
 class ColumnCompiler_MSSQL extends ColumnCompiler {
   constructor(client, tableCompiler, columnBuilder) {
     super(client, tableCompiler, columnBuilder);
     this.modifiers = ['nullable', 'defaultTo', 'first', 'after', 'comment'];
+    this._addCheckModifiers();
   }
 
   // Types
@@ -126,24 +128,57 @@ class ColumnCompiler_MSSQL extends ColumnCompiler {
     });
     return '';
   }
+
+  checkLength(operator, length, constraintName) {
+    return this._check(
+      `LEN(${this.formatter.wrap(this.getColumnName())}) ${operator_(
+        operator,
+        this.columnBuilder,
+        this.bindingsHolder
+      )} ${toNumber(length)}`,
+      constraintName
+    );
+  }
+
+  checkRegex(regex, constraintName) {
+    return this._check(
+      `${this.formatter.wrap(
+        this.getColumnName()
+      )} LIKE ${this.client._escapeBinding('%' + regex + '%')}`,
+      constraintName
+    );
+  }
+
+  increments(options = { primaryKey: true }) {
+    return (
+      'int identity(1,1) not null' +
+      (this.tableCompiler._canBeAddPrimaryKey(options) ? ' primary key' : '')
+    );
+  }
+
+  bigincrements(options = { primaryKey: true }) {
+    return (
+      'bigint identity(1,1) not null' +
+      (this.tableCompiler._canBeAddPrimaryKey(options) ? ' primary key' : '')
+    );
+  }
 }
 
-ColumnCompiler_MSSQL.prototype.increments = ({ primaryKey = true } = {}) =>
-  'int identity(1,1) not null' + (primaryKey ? ' primary key' : '');
-ColumnCompiler_MSSQL.prototype.bigincrements = ({ primaryKey = true } = {}) =>
-  'bigint identity(1,1) not null' + (primaryKey ? ' primary key' : '');
 ColumnCompiler_MSSQL.prototype.bigint = 'bigint';
 ColumnCompiler_MSSQL.prototype.mediumint = 'int';
 ColumnCompiler_MSSQL.prototype.smallint = 'smallint';
 ColumnCompiler_MSSQL.prototype.text = 'nvarchar(max)';
 ColumnCompiler_MSSQL.prototype.mediumtext = 'nvarchar(max)';
 ColumnCompiler_MSSQL.prototype.longtext = 'nvarchar(max)';
-ColumnCompiler_MSSQL.prototype.json = 'nvarchar(max)';
+ColumnCompiler_MSSQL.prototype.json = ColumnCompiler_MSSQL.prototype.jsonb =
+  'nvarchar(max)';
 
 // TODO: mssql supports check constraints as of SQL Server 2008
 // so make enu here more like postgres
 ColumnCompiler_MSSQL.prototype.enu = 'nvarchar(100)';
-ColumnCompiler_MSSQL.prototype.uuid = 'uniqueidentifier';
+ColumnCompiler_MSSQL.prototype.uuid = ({ useBinaryUuid = false } = {}) =>
+  useBinaryUuid ? 'binary(16)' : 'uniqueidentifier';
+
 ColumnCompiler_MSSQL.prototype.datetime = 'datetime2';
 ColumnCompiler_MSSQL.prototype.bool = 'bit';
 

package/lib/dialects/mssql/schema/mssql-compiler.js

@@ -45,14 +45,13 @@ class SchemaCompiler_MSSQL extends SchemaCompiler {
   // Check whether a table exists on the query.
   hasTable(tableName) {
     const formattedTable = this.client.parameter(
-      this.formatter.wrap(prefixedTableName(this.schema, tableName)),
+      prefixedTableName(this.schema, tableName),
       this.builder,
       this.bindingsHolder
     );
-
     const sql =
-      `select object_id from sys.tables ` +
-      `where object_id = object_id(${formattedTable})`;
+      `SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES ` +
+      `WHERE TABLE_NAME = ${formattedTable}`;
     this.pushQuery({ sql, output: (resp) => resp.length > 0 });
   }
 

package/lib/dialects/mssql/schema/mssql-tablecompiler.js

@@ -28,6 +28,7 @@ class TableCompiler_MSSQL extends TableCompiler {
         this.tableName() +
         (this._formatting ? ' (\n    ' : ' (') +
         columns.sql.join(this._formatting ? ',\n    ' : ', ') +
+        this._addChecks() +
         ')';
     }
 
@@ -36,6 +37,9 @@ class TableCompiler_MSSQL extends TableCompiler {
     if (this.single.comment) {
       this.comment(this.single.comment);
     }
+    if (like) {
+      this.addColumns(columns, this.addColumnsPrefix);
+    }
   }
 
   comment(/** @type {string} */ comment) {
@@ -276,13 +280,14 @@ class TableCompiler_MSSQL extends TableCompiler {
    * Create a unique index.
    *
    * @param {string | string[]} columns
-   * @param {string | {indexName: undefined | string, deferrable?: 'not deferrable'|'deferred'|'immediate' }} indexName
+   * @param {string | {indexName: undefined | string, deferrable?: 'not deferrable'|'deferred'|'immediate', useConstraint?: true|false }} indexName
    */
   unique(columns, indexName) {
     /** @type {string | undefined} */
     let deferrable;
+    let useConstraint = false;
     if (isObject(indexName)) {
-      ({ indexName, deferrable } = indexName);
+      ({ indexName, deferrable, useConstraint } = indexName);
     }
     if (deferrable && deferrable !== 'not deferrable') {
       this.client.logger.warn(
@@ -301,13 +306,23 @@ class TableCompiler_MSSQL extends TableCompiler {
       .map((column) => this.formatter.columnize(column) + ' IS NOT NULL')
       .join(' AND ');
 
-    // make unique constraint that allows null https://stackoverflow.com/a/767702/360060
-    // to be more or less compatible with other DBs (if any of the columns is NULL then "duplicates" are allowed)
-    this.pushQuery(
-      `CREATE UNIQUE INDEX ${indexName} ON ${this.tableName()} (${this.formatter.columnize(
-        columns
-      )}) WHERE ${whereAllTheColumnsAreNotNull}`
-    );
+    if (useConstraint) {
+      // mssql supports unique indexes and unique constraints.
+      // unique indexes cannot be used with foreign key relationships hence unique constraints are used instead.
+      this.pushQuery(
+        `ALTER TABLE ${this.tableName()} ADD CONSTRAINT ${indexName} UNIQUE (${this.formatter.columnize(
+          columns
+        )})`
+      );
+    } else {
+      // make unique constraint that allows null https://stackoverflow.com/a/767702/360060
+      // to be more or less compatible with other DBs (if any of the columns is NULL then "duplicates" are allowed)
+      this.pushQuery(
+        `CREATE UNIQUE INDEX ${indexName} ON ${this.tableName()} (${this.formatter.columnize(
+          columns
+        )}) WHERE ${whereAllTheColumnsAreNotNull}`
+      );
+    }
   }
 
   // Compile a drop index command.

package/lib/dialects/mssql/schema/mssql-viewcompiler.js

@@ -1,6 +1,9 @@
 /* eslint max-len: 0 */
 
 const ViewCompiler = require('../../../schema/viewcompiler.js');
+const {
+  columnize: columnize_,
+} = require('../../../formatter/wrappingFormatter');
 
 class ViewCompiler_MSSQL extends ViewCompiler {
   constructor(client, viewCompiler) {
@@ -11,7 +14,18 @@ class ViewCompiler_MSSQL extends ViewCompiler {
     const createStatement = 'CREATE ' + (replace ? 'OR ALTER ' : '') + 'VIEW ';
     let sql = createStatement + this.viewName();
 
-    sql += ' (' + columns.join(', ') + ')';
+    const columnList = columns
+      ? ' (' +
+        columnize_(
+          columns,
+          this.viewBuilder,
+          this.client,
+          this.bindingsHolder
+        ) +
+        ')'
+      : '';
+
+    sql += columnList;
     sql += ' AS ';
     sql += selectQuery.toString();
     this.pushQuery({

package/lib/dialects/mysql/query/mysql-querycompiler.js

@@ -3,6 +3,10 @@
 const identity = require('lodash/identity');
 const QueryCompiler = require('../../../query/querycompiler');
 const { wrapAsIdentifier } = require('../../../formatter/formatterUtils');
+const {
+  columnize: columnize_,
+  wrap: wrap_,
+} = require('../../../formatter/wrappingFormatter');
 
 class QueryCompiler_MySQL extends QueryCompiler {
   constructor(client, builder, formatter) {
@@ -76,12 +80,14 @@ class QueryCompiler_MySQL extends QueryCompiler {
 
   // Update method, including joins, wheres, order & limits.
   update() {
+    const withSQL = this.with();
     const join = this.join();
     const updates = this._prepUpdate(this.single.update);
     const where = this.where();
     const order = this.order();
     const limit = this.limit();
     return (
+      withSQL +
       `update ${this.tableName}` +
       (join ? ` ${join}` : '') +
       ' set ' +
@@ -146,13 +152,95 @@ class QueryCompiler_MySQL extends QueryCompiler {
     const limit =
       this.single.offset && noLimit
         ? '18446744073709551615'
-        : this.client.parameter(
-            this.single.limit,
-            this.builder,
-            this.bindingsHolder
-          );
+        : this._getValueOrParameterFromAttribute('limit');
     return `limit ${limit}`;
   }
+
+  whereLike(statement) {
+    return `${this._columnClause(statement)} ${this._not(
+      statement,
+      'like '
+    )}${this._valueClause(statement)} COLLATE utf8_bin`;
+  }
+
+  whereILike(statement) {
+    return `${this._columnClause(statement)} ${this._not(
+      statement,
+      'like '
+    )}${this._valueClause(statement)}`;
+  }
+
+  // Json functions
+  jsonExtract(params) {
+    return this._jsonExtract(['json_extract', 'json_unquote'], params);
+  }
+
+  jsonSet(params) {
+    return this._jsonSet('json_set', params);
+  }
+
+  jsonInsert(params) {
+    return this._jsonSet('json_insert', params);
+  }
+
+  jsonRemove(params) {
+    const jsonCol = `json_remove(${columnize_(
+      params.column,
+      this.builder,
+      this.client,
+      this.bindingsHolder
+    )},${this.client.parameter(
+      params.path,
+      this.builder,
+      this.bindingsHolder
+    )})`;
+    return params.alias
+      ? this.client.alias(jsonCol, this.formatter.wrap(params.alias))
+      : jsonCol;
+  }
+
+  whereJsonObject(statement) {
+    return this._not(
+      statement,
+      `json_contains(${this._columnClause(statement)}, ${this._jsonValueClause(
+        statement
+      )})`
+    );
+  }
+
+  whereJsonPath(statement) {
+    return this._whereJsonPath('json_extract', statement);
+  }
+
+  whereJsonSupersetOf(statement) {
+    return this._not(
+      statement,
+      `json_contains(${wrap_(
+        statement.column,
+        undefined,
+        this.builder,
+        this.client,
+        this.bindingsHolder
+      )},${this._jsonValueClause(statement)})`
+    );
+  }
+
+  whereJsonSubsetOf(statement) {
+    return this._not(
+      statement,
+      `json_contains(${this._jsonValueClause(statement)},${wrap_(
+        statement.column,
+        undefined,
+        this.builder,
+        this.client,
+        this.bindingsHolder
+      )})`
+    );
+  }
+
+  onJsonPathEquals(clause) {
+    return this._onJsonPathEquals('json_extract', clause);
+  }
 }
 
 // Set the QueryBuilder & QueryCompiler on the client object,

package/lib/dialects/mysql/schema/mysql-columncompiler.js

@@ -18,6 +18,7 @@ class ColumnCompiler_MySQL extends ColumnCompiler {
       'first',
       'after',
     ];
+    this._addCheckModifiers();
   }
 
   // Types
@@ -152,13 +153,39 @@ class ColumnCompiler_MySQL extends ColumnCompiler {
   collate(collation) {
     return collation && `collate '${collation}'`;
   }
+
+  checkRegex(regex, constraintName) {
+    return this._check(
+      `${this.formatter.wrap(
+        this.getColumnName()
+      )} REGEXP ${this.client._escapeBinding(regex)}`,
+      constraintName
+    );
+  }
+
+  increments(options = { primaryKey: true }) {
+    return (
+      'int unsigned not null' +
+      // In MySQL autoincrement are always a primary key. If you already have a primary key, we
+      // initialize this column as classic int column then modify it later in table compiler
+      (this.tableCompiler._canBeAddPrimaryKey(options)
+        ? ' auto_increment primary key'
+        : '')
+    );
+  }
+
+  bigincrements(options = { primaryKey: true }) {
+    return (
+      'bigint unsigned not null' +
+      // In MySQL autoincrement are always a primary key. If you already have a primary key, we
+      // initialize this column as classic int column then modify it later in table compiler
+      (this.tableCompiler._canBeAddPrimaryKey(options)
+        ? ' auto_increment primary key'
+        : '')
+    );
+  }
 }
 
-ColumnCompiler_MySQL.prototype.increments = ({ primaryKey = true } = {}) =>
-  'int unsigned not null auto_increment' + (primaryKey ? ' primary key' : '');
-ColumnCompiler_MySQL.prototype.bigincrements = ({ primaryKey = true } = {}) =>
-  'bigint unsigned not null auto_increment' +
-  (primaryKey ? ' primary key' : '');
 ColumnCompiler_MySQL.prototype.bigint = 'bigint';
 ColumnCompiler_MySQL.prototype.mediumint = 'mediumint';
 ColumnCompiler_MySQL.prototype.smallint = 'smallint';