knex 0.95.12 → 1.0.0

package/CHANGELOG.md

@@ -1,5 +1,80 @@
 # Master (Unreleased)
 
+# 1.0.0 - 16 January, 2022
+
+### Breaking changes
+
+- Dropped support for Node 10;
+- Replaced unsupported `sqlite3` driver with `@vscode/sqlite3`;
+- Changed data structure from `RETURNING` operation to be consistent with `SELECT`;
+- Changed Migrator to return list of migrations as objects consistently.
+
+### New features:
+
+- Support fromRaw #4781
+- Support zero precision in timestamp/datetime #4784
+- Support whereLike and whereILike #4779
+- Add JSDoc (TS flavor) to stub files #4809
+- Allow skip binding in limit and offset #4811
+- Support creating a new table in the database based on another table #4821
+- Accept Raw on onIn joins #4830
+- Implement support for custom seed sources #4842
+- Add binary uuid option #4836
+- ForUpdate array parameter #4882
+- Add camel case to timestamps method #4803
+- Advanced JSON support #4859
+- Add type to TypeScript knexfile #4909
+- Checks Constraints Support #4874
+- Support creating multiple PKs with increments #4903
+- Enable wrapIdentifier for SQLite .hasTable #4915
+- MSSQL: Add support for unique constraint #4887
+- SQLite: New dialect, using better-sqlite3 driver #4871
+- SQLite: Switch to @vscode/sqlite3 #4866
+- SQLite: Support createViewOrReplace #4856
+- SQLite: Support RETURNING statements for better-sqlite3 driver #4934
+- PostgreSQL: Support JOIN and USING syntax for Delete Statement #4800
+
+### Bug fixes:
+
+- Fix overzealous warning on use of whereNot with "in" or "between" #4780
+- Fix Union all + first syntax error #4799
+- Make view columns optional in create view like #4829
+- Insert lock row fix during migration #4865
+- Fix for createViewOrReplace #4856
+- SQLite: Fix foreign key constraints when altering a table #4189
+- MySQL: Validate connection fix #4794
+- MySQL: Set comment size warning limit to 1024 #4867
+
+### Typings:
+
+- Allow string indexType in index creation #4791
+- Add missing ints typings #4832
+- Returning method types #4881
+- Improve columnInfo type #4868
+
+# 0.95.15 - 22 December, 2021
+
+### Bug fixes:
+
+- Oracle:
+- MariaDB: lock row fix during migration in MariaDB and Oracle #4865
+
+# 0.95.14 - 09 November, 2021
+
+### Bug fixes:
+
+- MySQL: mysql2 dialect validate connection fix #4794
+
+# 0.95.13 - 02 November, 2021
+
+### Bug fixes:
+
+- PostgreSQL: Support zero precision in timestamp/datetime #4784
+
+### Typings:
+
+- Allow string indexType in index creation #4791
+
 # 0.95.12 - 28 October, 2021
 
 ### New features:

package/UPGRADING.md

@@ -1,5 +1,12 @@
 ## Upgrading to new knex.js versions
 
+### Upgrading to version 1.0.0+
+
+* Node.js older than 12 is no longer supported, make sure to update your environment;
+* If you are using `sqlite3` driver, please replace it with `@vscode/sqlite3`;
+* `RETURNING` operations now always return an object with column names;
+* Migrator now returns list of migrations as objects.
+
 ### Upgrading to version 0.95.0+
 
 * TypeScript type exports changed significantly. While `import Knex from 'knex';` used to import the knex instantiation function, the namespace and the interface for the knex instantiation function/object, there is now a clear distinction between them:

package/lib/client.js

@@ -30,6 +30,7 @@ const Logger = require('./logger');
 const { POOL_CONFIG_OPTIONS } = require('./constants');
 const ViewBuilder = require('./schema/viewbuilder.js');
 const ViewCompiler = require('./schema/viewcompiler.js');
+const isPlainObject = require('lodash/isPlainObject');
 
 const debug = require('debug')('knex:client');
 
@@ -51,6 +52,7 @@ class Client extends EventEmitter {
         `Using 'this.dialect' to identify the client is deprecated and support for it will be removed in the future. Please use configuration option 'client' instead.`
       );
     }
+
     const dbClient = this.config.client || this.dialect;
     if (!dbClient) {
       throw new Error(
@@ -392,8 +394,13 @@ class Client extends EventEmitter {
       i = -1;
     while (++i < values.length) {
       if (i > 0) str += ', ';
+      let value = values[i];
+      // json columns can have object in values.
+      if (isPlainObject(value)) {
+        value = JSON.stringify(value);
+      }
       str += this.parameter(
-        values[i] === undefined ? notSetValue : values[i],
+        value === undefined ? notSetValue : value,
         builder,
         bindingsHolder
       );
@@ -442,6 +449,12 @@ class Client extends EventEmitter {
   processPassedConnection(connection) {
     // Default implementation is noop
   }
+
+  toPathForJson(jsonPath) {
+    // By default, we want a json path, so if this function is not overriden,
+    // we return the path.
+    return jsonPath;
+  }
 }
 
 Object.assign(Client.prototype, {

package/lib/constants.js

@@ -16,6 +16,7 @@ const SUPPORTED_CLIENTS = Object.freeze(
     'redshift',
     'sqlite3',
     'cockroachdb',
+    'better-sqlite3',
   ].concat(Object.keys(CLIENT_ALIASES))
 );
 
@@ -29,6 +30,7 @@ const DRIVER_NAMES = Object.freeze({
   Redshift: 'pg-redshift',
   SQLite: 'sqlite3',
   CockroachDB: 'cockroachdb',
+  BetterSQLite3: 'better-sqlite3',
 });
 
 const POOL_CONFIG_OPTIONS = Object.freeze([

package/lib/dialects/better-sqlite3/index.js

@@ -0,0 +1,72 @@
+// better-sqlite3 Client
+// -------
+const Client_SQLite3 = require('../sqlite3');
+
+class Client_BetterSQLite3 extends Client_SQLite3 {
+  _driver() {
+    return require('better-sqlite3');
+  }
+
+  // Get a raw connection from the database, returning a promise with the connection object.
+  async acquireRawConnection() {
+    return new this.driver(this.connectionSettings.filename);
+  }
+
+  // Used to explicitly close a connection, called internally by the pool when
+  // a connection times out or the pool is shutdown.
+  async destroyRawConnection(connection) {
+    return connection.close();
+  }
+
+  // Runs the query on the specified connection, providing the bindings and any
+  // other necessary prep work.
+  async _query(connection, obj) {
+    if (!obj.sql) throw new Error('The query is empty');
+
+    if (!connection) {
+      throw new Error('No connection provided');
+    }
+
+    const statement = connection.prepare(obj.sql);
+    const bindings = this._formatBindings(obj.bindings);
+
+    if (statement.reader) {
+      const response = await statement.all(bindings);
+      obj.response = response;
+      return obj;
+    }
+
+    const response = await statement.run(bindings);
+    obj.response = response;
+    obj.context = {
+      lastID: response.lastInsertRowid,
+      changes: response.changes,
+    };
+
+    return obj;
+  }
+
+  _formatBindings(bindings) {
+    if (!bindings) {
+      return [];
+    }
+    return bindings.map((binding) => {
+      if (binding instanceof Date) {
+        return binding.valueOf();
+      }
+
+      if (typeof binding === 'boolean') {
+        return String(binding);
+      }
+
+      return binding;
+    });
+  }
+}
+
+Object.assign(Client_BetterSQLite3.prototype, {
+  // The "dialect", for reference .
+  driverName: 'better-sqlite3',
+});
+
+module.exports = Client_BetterSQLite3;

package/lib/dialects/cockroachdb/crdb-querycompiler.js

@@ -1,6 +1,9 @@
 const QueryCompiler_PG = require('../postgres/query/pg-querycompiler');
-const isEmpty = require('lodash/isEmpty');
-const { columnize: columnize_ } = require('../../formatter/wrappingFormatter');
+const {
+  columnize: columnize_,
+  wrap: wrap_,
+  operator: operator_,
+} = require('../../formatter/wrappingFormatter');
 
 class QueryCompiler_CRDB extends QueryCompiler_PG {
   truncate() {
@@ -20,43 +23,94 @@ class QueryCompiler_CRDB extends QueryCompiler_PG {
 
   _upsert() {
     const upsertValues = this.single.upsert || [];
-    let sql = this.with() + `upsert into ${this.tableName} `;
-    if (Array.isArray(upsertValues)) {
-      if (upsertValues.length === 0) return '';
-    } else if (typeof upsertValues === 'object' && isEmpty(upsertValues)) {
-      return sql + this._emptyInsertValue;
+    const sql = this.with() + `upsert into ${this.tableName} `;
+    const body = this._insertBody(upsertValues);
+    return body === '' ? '' : sql + body;
+  }
+
+  whereJsonPath(statement) {
+    let castValue = '';
+    if (parseInt(statement.value)) {
+      castValue = '::int';
+    } else if (parseFloat(statement.value)) {
+      castValue = '::float';
+    } else {
+      castValue = " #>> '{}'";
     }
+    return `json_extract_path(${this._columnClause(
+      statement
+    )}, ${this.client.toArrayPathFromJsonPath(
+      statement.jsonPath,
+      this.builder,
+      this.bindingsHolder
+    )})${castValue} ${operator_(
+      statement.operator,
+      this.builder,
+      this.client,
+      this.bindingsHolder
+    )} ${this._jsonValueClause(statement)}`;
+  }
 
-    const upsertData = this._prepInsert(upsertValues);
-    if (typeof upsertData === 'string') {
-      sql += upsertData;
+  // Json common functions
+  _jsonExtract(nameFunction, params) {
+    let extractions;
+    if (Array.isArray(params.column)) {
+      extractions = params.column;
     } else {
-      if (upsertData.columns.length) {
-        sql += `(${columnize_(
-          upsertData.columns,
+      extractions = [params];
+    }
+    return extractions
+      .map((extraction) => {
+        const jsonCol = `json_extract_path(${columnize_(
+          extraction.column || extraction[0],
           this.builder,
           this.client,
           this.bindingsHolder
-        )}`;
-        sql += ') values (';
-        let i = -1;
-        while (++i < upsertData.values.length) {
-          if (i !== 0) sql += '), (';
-          sql += this.client.parameterize(
-            upsertData.values[i],
-            this.client.valueForUndefined,
-            this.builder,
-            this.bindingsHolder
-          );
-        }
-        sql += ')';
-      } else if (upsertValues.length === 1 && upsertValues[0]) {
-        sql += this._emptyInsertValue;
-      } else {
-        sql = '';
-      }
-    }
-    return sql;
+        )}, ${this.client.toArrayPathFromJsonPath(
+          extraction.path || extraction[1],
+          this.builder,
+          this.bindingsHolder
+        )})`;
+        const alias = extraction.alias || extraction[2];
+        return alias
+          ? this.client.alias(jsonCol, this.formatter.wrap(alias))
+          : jsonCol;
+      })
+      .join(', ');
+  }
+
+  _onJsonPathEquals(nameJoinFunction, clause) {
+    return (
+      'json_extract_path(' +
+      wrap_(
+        clause.columnFirst,
+        undefined,
+        this.builder,
+        this.client,
+        this.bindingsHolder
+      ) +
+      ', ' +
+      this.client.toArrayPathFromJsonPath(
+        clause.jsonPathFirst,
+        this.builder,
+        this.bindingsHolder
+      ) +
+      ') = json_extract_path(' +
+      wrap_(
+        clause.columnSecond,
+        undefined,
+        this.builder,
+        this.client,
+        this.bindingsHolder
+      ) +
+      ', ' +
+      this.client.toArrayPathFromJsonPath(
+        clause.jsonPathSecond,
+        this.builder,
+        this.bindingsHolder
+      ) +
+      ')'
+    );
   }
 }
 

package/lib/dialects/cockroachdb/crdb-tablecompiler.js

@@ -7,6 +7,25 @@ class TableCompiler_CRDB extends TableCompiler {
     super(client, tableBuilder);
   }
 
+  addColumns(columns, prefix, colCompilers) {
+    if (prefix === this.alterColumnsPrefix) {
+      // alter columns
+      for (const col of colCompilers) {
+        this.client.logger.warn(
+          'Experimental alter column in use, see issue: https://github.com/cockroachdb/cockroach/issues/49329'
+        );
+        this.pushQuery({
+          sql: 'SET enable_experimental_alter_column_type_general = true',
+          bindings: [],
+        });
+        super._addColumn(col);
+      }
+    } else {
+      // base class implementation for normal add
+      super.addColumns(columns, prefix);
+    }
+  }
+
   dropUnique(columns, indexName) {
     indexName = indexName
       ? this.formatter.wrap(indexName)

package/lib/dialects/cockroachdb/index.js

@@ -58,6 +58,19 @@ class Client_CockroachDB extends Client_PostgreSQL {
       connectionToKill.activeQuery
     );
   }
+
+  toArrayPathFromJsonPath(jsonPath, builder, bindingsHolder) {
+    return jsonPath
+      .replace(/^(\$\.)/, '') // remove the first dollar
+      .replace(/\[([0-9]+)]/, '.$1')
+      .split('.')
+      .map(
+        function (v) {
+          return this.parameter(v, builder, bindingsHolder);
+        }.bind(this)
+      )
+      .join(', ');
+  }
 }
 
 Object.assign(Client_CockroachDB.prototype, {

package/lib/dialects/mssql/index.js

@@ -1,8 +1,6 @@
 // MSSQL Client
 // -------
-const flatten = require('lodash/flatten');
 const map = require('lodash/map');
-const values = require('lodash/values');
 const isNil = require('lodash/isNil');
 
 const Client = require('../../client');
@@ -472,15 +470,6 @@ class Client_MSSQL extends Client {
           if (query.returning === '@@rowcount') {
             return response[0][''];
           }
-
-          if (
-            (Array.isArray(query.returning) && query.returning.length > 1) ||
-            query.returning[0] === '*'
-          ) {
-            return response;
-          }
-          // return an array with values if only one returning value was specified
-          return flatten(map(response, values));
         }
         return response;
       default:

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,