knex 0.95.13 → 1.0.1

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-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/index.js

@@ -89,13 +89,9 @@ class Client_MySQL extends Client {
   }
 
   validateConnection(connection) {
-    if (
-      connection.state === 'connected' ||
-      connection.state === 'authenticated'
-    ) {
-      return true;
-    }
-    return false;
+    return (
+      connection.state === 'connected' || connection.state === 'authenticated'
+    );
   }
 
   // Grab a connection, run the query via the MySQL streaming interface,

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) {
@@ -146,13 +150,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';

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

@@ -19,7 +19,7 @@ class TableCompiler_MySQL extends TableCompiler {
       : 'create table ';
     const { client } = this;
     let conn = {};
-    const columnsSql = ' (' + columns.sql.join(', ') + ')';
+    const columnsSql = ' (' + columns.sql.join(', ') + this._addChecks() + ')';
     let sql =
       createStatement +
       this.tableName() +
@@ -42,14 +42,18 @@ class TableCompiler_MySQL extends TableCompiler {
 
     if (this.single.comment) {
       const comment = this.single.comment || '';
-      if (comment.length > 60)
+      const MAX_COMMENT_LENGTH = 1024;
+      if (comment.length > MAX_COMMENT_LENGTH)
         this.client.logger.warn(
-          'The max length for a table comment is 60 characters'
+          `The max length for a table comment is ${MAX_COMMENT_LENGTH} characters`
         );
       sql += ` comment = '${comment}'`;
     }
 
     this.pushQuery(sql);
+    if (like) {
+      this.addColumns(columns, this.addColumnsPrefix);
+    }
   }
 
   // Compiles the comment on the table.
@@ -249,11 +253,31 @@ class TableCompiler_MySQL extends TableCompiler {
     constraintName = constraintName
       ? this.formatter.wrap(constraintName)
       : this.formatter.wrap(`${this.tableNameRaw}_pkey`);
+
+    const primaryCols = columns;
+    let incrementsCols = [];
+    if (this.grouped.columns) {
+      incrementsCols = this._getIncrementsColumnNames();
+      if (incrementsCols) {
+        incrementsCols.forEach((c) => {
+          if (!primaryCols.includes(c)) {
+            primaryCols.unshift(c);
+          }
+        });
+      }
+    }
     this.pushQuery(
       `alter table ${this.tableName()} add primary key ${constraintName}(${this.formatter.columnize(
-        columns
+        primaryCols
       )})`
     );
+    if (incrementsCols.length) {
+      this.pushQuery(
+        `alter table ${this.tableName()} modify column ${this.formatter.columnize(
+          incrementsCols
+        )} int unsigned not null auto_increment`
+      );
+    }
   }
 
   unique(columns, indexName) {

package/lib/dialects/mysql2/index.js

@@ -15,10 +15,13 @@ class Client_MySQL2 extends Client_MySQL {
     return require('mysql2');
   }
   validateConnection(connection) {
-    if (connection._fatalError) {
-      return false;
-    }
-    return true;
+    return (
+      connection &&
+      !connection._fatalError &&
+      !connection._protocolError &&
+      !connection._closing &&
+      !connection.stream.destroyed
+    );
   }
 }