knex 0.95.12-rc4 → 0.95.13

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Master (Unreleased)
 
+# 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:
+
+- New dialect: CockroachDB #4742
+- New dialect: pg-native #4327
+- CockroachDB: add support for upsert #4767
+- PostgreSQL: Support SELECT .. FOR NO KEY UPDATE / KEY SHARE row level locking clauses #4755
+- PostgreSQL: Add support for 'CASCADE' in PostgreSQL 'DROP SCHEMA' queries #4713
+- MySQL: Add storage engine index Type support to index() and unique() schema #4756
+- MSSQL: Support table.primary, table.unique variant with options object #4710
+- SQLite: Add setNullable support to SQLite #4684
+- Add geometry column building #4776
+- Add support for creating table copies #1373
+- Implement support for views and materialized views #1626
+- Implement partial index support #4768
+- Support for 'is null' in 'order by' #3667
+
+### Bug fixes:
+
+- Fix support for Oracle connections passed via knex.connection() #4757
+- Avoid inserting multiple locks if a migration lock already exists #4694
+
+### Typings:
+
+- Some TableBuilder methods return wrong types #4764
+- Update JoinRaw bindings type to accept arrays #4752
+- fix onDelete/onUpdate for ColumnBuilder #4656
+
 # 0.95.11 - 03 September, 2021
 
 ### New features:

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

@@ -0,0 +1,11 @@
+const QueryBuilder = require('../../query/querybuilder');
+const isEmpty = require('lodash/isEmpty');
+
+module.exports = class QueryBuilder_CockroachDB extends QueryBuilder {
+  upsert(values, returning, options) {
+    this._method = 'upsert';
+    if (!isEmpty(returning)) this.returning(returning, options);
+    this._single.upsert = values;
+    return this;
+  }
+};

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

@@ -1,9 +1,63 @@
 const QueryCompiler_PG = require('../postgres/query/pg-querycompiler');
+const isEmpty = require('lodash/isEmpty');
+const { columnize: columnize_ } = require('../../formatter/wrappingFormatter');
 
 class QueryCompiler_CRDB extends QueryCompiler_PG {
   truncate() {
     return `truncate ${this.tableName}`;
   }
+
+  upsert() {
+    let sql = this._upsert();
+    if (sql === '') return sql;
+    const { returning } = this.single;
+    if (returning) sql += this._returning(returning);
+    return {
+      sql: sql,
+      returning,
+    };
+  }
+
+  _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 upsertData = this._prepInsert(upsertValues);
+    if (typeof upsertData === 'string') {
+      sql += upsertData;
+    } else {
+      if (upsertData.columns.length) {
+        sql += `(${columnize_(
+          upsertData.columns,
+          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;
+  }
 }
 
 module.exports = QueryCompiler_CRDB;

package/lib/dialects/cockroachdb/index.js

@@ -5,6 +5,7 @@ const Transaction = require('../postgres/execution/pg-transaction');
 const QueryCompiler = require('./crdb-querycompiler');
 const TableCompiler = require('./crdb-tablecompiler');
 const ViewCompiler = require('./crdb-viewcompiler');
+const QueryBuilder = require('./crdb-querybuilder');
 
 // Always initialize with the "QueryBuilder" and "QueryCompiler"
 // objects, which extend the base 'lib/query/builder' and
@@ -26,6 +27,10 @@ class Client_CockroachDB extends Client_PostgreSQL {
     return new ViewCompiler(this, ...arguments);
   }
 
+  queryBuilder() {
+    return new QueryBuilder(this);
+  }
+
   _parseVersion(versionString) {
     return versionString.split(' ')[2];
   }

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

@@ -219,14 +219,22 @@ class TableCompiler_MSSQL extends TableCompiler {
     );
   }
 
-  index(columns, indexName) {
+  index(columns, indexName, options) {
     indexName = indexName
       ? this.formatter.wrap(indexName)
       : this._indexCommand('index', this.tableNameRaw, columns);
+
+    let predicate;
+    if (isObject(options)) {
+      ({ predicate } = options);
+    }
+    const predicateQuery = predicate
+      ? ' ' + this.client.queryCompiler(predicate).where()
+      : '';
     this.pushQuery(
       `CREATE INDEX ${indexName} ON ${this.tableName()} (${this.formatter.columnize(
         columns
-      )})`
+      )})${predicateQuery}`
     );
   }
 

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

@@ -3,7 +3,7 @@
 // MySQL Table Builder & Compiler
 // -------
 const TableCompiler = require('../../../schema/tablecompiler');
-const { isObject } = require('../../../util/is');
+const { isObject, isString } = require('../../../util/is');
 
 // Table Compiler
 // ------
@@ -211,14 +211,28 @@ class TableCompiler_MySQL extends TableCompiler {
     );
   }
 
-  index(columns, indexName, indexType) {
+  index(columns, indexName, options) {
+    let storageEngineIndexType;
+    let indexType;
+
+    if (isString(options)) {
+      indexType = options;
+    } else if (isObject(options)) {
+      ({ indexType, storageEngineIndexType } = options);
+    }
+
     indexName = indexName
       ? this.formatter.wrap(indexName)
       : this._indexCommand('index', this.tableNameRaw, columns);
+    storageEngineIndexType = storageEngineIndexType
+      ? ` using ${storageEngineIndexType}`
+      : '';
     this.pushQuery(
       `alter table ${this.tableName()} add${
         indexType ? ` ${indexType}` : ''
-      } index ${indexName}(${this.formatter.columnize(columns)})`
+      } index ${indexName}(${this.formatter.columnize(
+        columns
+      )})${storageEngineIndexType}`
     );
   }
 
@@ -243,9 +257,10 @@ class TableCompiler_MySQL extends TableCompiler {
   }
 
   unique(columns, indexName) {
+    let storageEngineIndexType;
     let deferrable;
     if (isObject(indexName)) {
-      ({ indexName, deferrable } = indexName);
+      ({ indexName, deferrable, storageEngineIndexType } = indexName);
     }
     if (deferrable && deferrable !== 'not deferrable') {
       this.client.logger.warn(
@@ -255,10 +270,13 @@ class TableCompiler_MySQL extends TableCompiler {
     indexName = indexName
       ? this.formatter.wrap(indexName)
       : this._indexCommand('unique', this.tableNameRaw, columns);
+    storageEngineIndexType = storageEngineIndexType
+      ? ` using ${storageEngineIndexType}`
+      : '';
     this.pushQuery(
       `alter table ${this.tableName()} add unique ${indexName}(${this.formatter.columnize(
         columns
-      )})`
+      )})${storageEngineIndexType}`
     );
   }
 

package/lib/dialects/postgres/query/pg-querycompiler.js

@@ -147,20 +147,26 @@ class QueryCompiler_PG extends QueryCompiler {
     return sql.join(', ');
   }
 
-  forUpdate() {
+  _lockingClause(lockMode) {
     const tables = this.single.lockTables || [];
 
-    return (
-      'for update' + (tables.length ? ' of ' + this._tableNames(tables) : '')
-    );
+    return lockMode + (tables.length ? ' of ' + this._tableNames(tables) : '');
+  }
+
+  forUpdate() {
+    return this._lockingClause('for update');
   }
 
   forShare() {
-    const tables = this.single.lockTables || [];
+    return this._lockingClause('for share');
+  }
+
+  forNoKeyUpdate() {
+    return this._lockingClause('for no key update');
+  }
 
-    return (
-      'for share' + (tables.length ? ' of ' + this._tableNames(tables) : '')
-    );
+  forKeyShare() {
+    return this._lockingClause('for key share');
   }
 
   skipLocked() {

package/lib/dialects/postgres/schema/pg-columncompiler.js

@@ -72,22 +72,16 @@ class ColumnCompiler_PG extends ColumnCompiler {
       useTz = !withoutTz;
     }
     useTz = typeof useTz === 'boolean' ? useTz : true;
-    precision = precision ? '(' + precision + ')' : '';
+    precision =
+      precision !== undefined && precision !== null
+        ? '(' + precision + ')'
+        : '';
 
     return `${useTz ? 'timestamptz' : 'timestamp'}${precision}`;
   }
 
   timestamp(withoutTz = false, precision) {
-    let useTz;
-    if (isObject(withoutTz)) {
-      ({ useTz, precision } = withoutTz);
-    } else {
-      useTz = !withoutTz;
-    }
-    useTz = typeof useTz === 'boolean' ? useTz : true;
-    precision = precision ? '(' + precision + ')' : '';
-
-    return `${useTz ? 'timestamptz' : 'timestamp'}${precision}`;
+    return this.datetime(withoutTz, precision);
   }
 
   // Modifiers:

package/lib/dialects/postgres/schema/pg-tablecompiler.js

@@ -5,7 +5,7 @@
 
 const has = require('lodash/has');
 const TableCompiler = require('../../../schema/tablecompiler');
-const { isObject } = require('../../../util/is');
+const { isObject, isString } = require('../../../util/is');
 
 class TableCompiler_PG extends TableCompiler {
   constructor(client, tableBuilder) {
@@ -161,17 +161,32 @@ class TableCompiler_PG extends TableCompiler {
     );
   }
 
-  index(columns, indexName, indexType) {
+  index(columns, indexName, options) {
     indexName = indexName
       ? this.formatter.wrap(indexName)
       : this._indexCommand('index', this.tableNameRaw, columns);
+
+    let predicate;
+    let indexType;
+
+    if (isString(options)) {
+      indexType = options;
+    } else if (isObject(options)) {
+      ({ indexType, predicate } = options);
+    }
+
+    const predicateQuery = predicate
+      ? ' ' + this.client.queryCompiler(predicate).where()
+      : '';
+
     this.pushQuery(
       `create index ${indexName} on ${this.tableName()}${
         (indexType && ` using ${indexType}`) || ''
       }` +
         ' (' +
         this.formatter.columnize(columns) +
-        ')'
+        ')' +
+        `${predicateQuery}`
     );
   }
 

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

@@ -61,6 +61,18 @@ class QueryCompiler_Redshift extends QueryCompiler_PG {
     return '';
   }
 
+  forNoKeyUpdate() {
+    this.client.logger.warn('table lock is not supported by redshift dialect');
+    return '';
+  }
+
+  forKeyShare() {
+    this.client.logger.warn(
+      'lock for share is not supported by redshift dialect'
+    );
+    return '';
+  }
+
   // Compiles a columnInfo query
   columnInfo() {
     const column = this.single.columnInfo;

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

@@ -11,7 +11,7 @@ class TableCompiler_Redshift extends TableCompiler_PG {
     super(...arguments);
   }
 
-  index(columns, indexName, indexType) {
+  index(columns, indexName, options) {
     this.client.logger.warn(
       'Redshift does not support the creation of indexes.'
     );

package/lib/dialects/sqlite3/query/sqlite-querycompiler.js

@@ -27,7 +27,9 @@ class QueryCompiler_SQLite3 extends QueryCompiler {
 
     // The locks are not applicable in SQLite3
     this.forShare = emptyStr;
+    this.forKeyShare = emptyStr;
     this.forUpdate = emptyStr;
+    this.forNoKeyUpdate = emptyStr;
   }
 
   // SQLite requires us to build the multi-row insert as a listing of select with

package/lib/dialects/sqlite3/schema/sqlite-tablecompiler.js

@@ -145,13 +145,21 @@ class TableCompiler_SQLite3 extends TableCompiler {
   }
 
   // Compile a plain index key command.
-  index(columns, indexName) {
+  index(columns, indexName, options) {
     indexName = indexName
       ? this.formatter.wrap(indexName)
       : this._indexCommand('index', this.tableNameRaw, columns);
     columns = this.formatter.columnize(columns);
+
+    let predicate;
+    if (isObject(options)) {
+      ({ predicate } = options);
+    }
+    const predicateQuery = predicate
+      ? ' ' + this.client.queryCompiler(predicate).where()
+      : '';
     this.pushQuery(
-      `create index ${indexName} on ${this.tableName()} (${columns})`
+      `create index ${indexName} on ${this.tableName()} (${columns})${predicateQuery}`
     );
   }
 

package/lib/query/constants.js

@@ -5,6 +5,8 @@ module.exports = {
   lockMode: {
     forShare: 'forShare',
     forUpdate: 'forUpdate',
+    forNoKeyUpdate: 'forNoKeyUpdate',
+    forKeyShare: 'forKeyShare',
   },
   waitMode: {
     skipLocked: 'skipLocked',

package/lib/query/querybuilder.js

@@ -46,7 +46,12 @@ const CLEARABLE_STATEMENTS = new Set([
   'counter',
   'counters',
 ]);
-const LOCK_MODES = new Set([lockMode.forShare, lockMode.forUpdate]);
+const LOCK_MODES = new Set([
+  lockMode.forShare,
+  lockMode.forUpdate,
+  lockMode.forNoKeyUpdate,
+  lockMode.forKeyShare,
+]);
 
 // Typically called from `knex.builder`,
 // start a new query building chain.
@@ -1198,6 +1203,20 @@ class Builder extends EventEmitter {
     return this;
   }
 
+  // Set a lock for no key update constraint.
+  forNoKeyUpdate(...tables) {
+    this._single.lock = lockMode.forNoKeyUpdate;
+    this._single.lockTables = tables;
+    return this;
+  }
+
+  // Set a lock for key share constraint.
+  forKeyShare(...tables) {
+    this._single.lock = lockMode.forKeyShare;
+    this._single.lockTables = tables;
+    return this;
+  }
+
   // Skips locked rows when using a lock constraint.
   skipLocked() {
     if (!this._isSelectQuery()) {
@@ -1254,6 +1273,12 @@ class Builder extends EventEmitter {
     return this;
   }
 
+  upsert(values, returning, options) {
+    throw new Error(
+      `Upsert is not yet supported for dialect ${this.client.dialect}`
+    );
+  }
+
   _analytic(alias, second, third) {
     let analytic;
     const { schema } = this._single;

package/lib/schema/columncompiler.js

@@ -142,6 +142,9 @@ ColumnCompiler.prototype.date = 'date';
 ColumnCompiler.prototype.datetime = 'datetime';
 ColumnCompiler.prototype.time = 'time';
 ColumnCompiler.prototype.timestamp = 'timestamp';
+ColumnCompiler.prototype.geometry = 'geometry';
+ColumnCompiler.prototype.geography = 'geography';
+ColumnCompiler.prototype.point = 'point';
 ColumnCompiler.prototype.enu = 'varchar';
 ColumnCompiler.prototype.bit = ColumnCompiler.prototype.json = 'text';
 ColumnCompiler.prototype.uuid = 'char(36)';

package/lib/schema/tablebuilder.js

@@ -218,6 +218,11 @@ const columnTypes = [
   'time',
   'year',
 
+  // Geometry
+  'geometry',
+  'geography',
+  'point',
+
   // String
   'char',
   'varchar',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knex",
-  "version": "0.95.12-rc4",
+  "version": "0.95.13",
   "description": "A batteries-included SQL query & schema builder for PostgresSQL, MySQL, CockroachDB, MSSQL and SQLite3",
   "main": "knex",
   "types": "types/index.d.ts",
@@ -17,7 +17,7 @@
     "lint:everything": "npm run lint:types && npm run lint",
     "test:unit": "npm run test:unit-only && npm run test:cli",
     "test:unit-only": "mocha --exit -t 10000 --config test/mocha-unit-config-test.js",
-    "test:db": "mocha --exit -t 10000 --config test/mocha-integration-config-test.js && npm run test:tape",
+    "test:db": "mocha --exit -t 10000 --config test/mocha-integration-config-test.js",
     "test:db:coverage": "nyc mocha --exit --check-leaks -t 10000 --config test/mocha-integration-config-test.js && npm run test:tape",
     "test:db:no-oracle": "cross-env DB=\"mssql mysql mysql2 postgres sqlite3\" mocha --exit -t 10000 --config test/mocha-integration-config-test.js && npm run test:tape",
     "test": "mocha --exit -t 10000 --config test/mocha-all-config-test.js && npm run test:tape && npm run test:cli",
@@ -33,8 +33,8 @@
     "test:pgnative": "cross-env DB=pgnative npm run test:db",
     "test:tape": "node test/tape/index.js | tap-spec",
     "test:cli": "cross-env KNEX_PATH=../knex.js KNEX=bin/cli.js jake -f test/jake/Jakefile",
-    "db:start": "docker-compose -f scripts/docker-compose.yml up --build -d mysql oracledbxe postgres mssql && docker-compose -f scripts/docker-compose.yml up waitmssql waitmysql waitpostgres waitoracledbxe",
-    "db:start:no-oracle": "docker-compose -f scripts/docker-compose.yml up --build -d mysql postgres mssql && docker-compose -f scripts/docker-compose.yml up waitmssql waitmysql waitpostgres",
+    "db:start": "docker-compose -f scripts/docker-compose.yml up --build -d mysql oracledbxe postgres mssql cockroachdb pgnative && docker-compose -f scripts/docker-compose.yml up waitmssql waitmysql waitpostgres waitoracledbxe",
+    "db:start:no-oracle": "docker-compose -f scripts/docker-compose.yml up --build -d mysql postgres mssql cockroachdb pgnative && docker-compose -f scripts/docker-compose.yml up waitmssql waitmysql waitpostgres",
     "db:stop": "docker-compose -f scripts/docker-compose.yml down",
     "db:start:postgres": "docker-compose -f scripts/docker-compose.yml up --build -d postgres && docker-compose -f scripts/docker-compose.yml up waitpostgres",
     "db:stop:postgres": "docker-compose -f scripts/docker-compose.yml down",
@@ -101,10 +101,10 @@
     "cli-testlab": "^2.2.0",
     "coveralls": "^3.1.1",
     "cross-env": "^7.0.3",
-    "dtslint": "4.1.6",
-    "eslint": "^7.32.0",
+    "dtslint": "4.2.0",
+    "eslint": "^8.1.0",
     "eslint-config-prettier": "^8.3.0",
-    "eslint-plugin-import": "^2.24.2",
+    "eslint-plugin-import": "^2.25.2",
     "husky": "^4.3.8",
     "jake": "^8.1.1",
     "JSONStream": "^1.3.5",
@@ -128,8 +128,8 @@
     "tedious": "^12.2.0",
     "toxiproxy-node-client": "^2.0.6",
     "ts-node": "^10.2.1",
-    "tsd": "^0.17.0",
-    "typescript": "4.4.3"
+    "tsd": "^0.18.0",
+    "typescript": "4.4.4"
   },
   "buildDependencies": [
     "rimraf"

package/scripts/docker-compose.yml

@@ -2,7 +2,7 @@ version: '3'
 
 services:
   mssql:
-    image: mcr.microsoft.com/mssql/server:2017-latest
+    image: mcr.microsoft.com/mssql/server:2019-latest
     ports:
       - '21433:1433'
     environment:

package/types/index.d.ts

@@ -456,10 +456,11 @@ export declare namespace Knex {
 
   type DbRecordArr<TRecord> = Readonly<MaybeArray<DbRecord<TRecord>>>;
 
-  export type CompositeTableType<TBase, TInsert = TBase, TUpdate = Partial<TInsert>> = {
+  export type CompositeTableType<TBase, TInsert = TBase, TUpdate = Partial<TInsert>, TUpsert = Partial<TInsert>> = {
     base: TBase,
     insert: TInsert,
     update: TUpdate,
+    upsert: TUpsert,
   };
 
   type TableNames = keyof Tables;
@@ -714,6 +715,75 @@ export declare namespace Knex {
         : DbRecordArr<TRecord> | ReadonlyArray<DbRecordArr<TRecord>>
     ): QueryBuilder<TRecord, TResult2>;
 
+    upsert(
+      data: TRecord extends CompositeTableType<unknown>
+        ? ResolveTableType<TRecord, 'upsert'> | ReadonlyArray<ResolveTableType<TRecord, 'upsert'>>
+        : DbRecordArr<TRecord> | ReadonlyArray<DbRecordArr<TRecord>>,
+      returning: '*',
+      options?: DMLOptions
+    ): QueryBuilder<TRecord, DeferredKeySelection<TRecord, never>[]>;
+    upsert<
+      TKey extends StrKey<ResolveTableType<TRecord>>,
+      TResult2 = DeferredIndex.Augment<
+        UnwrapArrayMember<TResult>,
+        ResolveTableType<TRecord>,
+        TKey
+        >[]
+      >(
+      data: TRecord extends CompositeTableType<unknown>
+        ? ResolveTableType<TRecord, 'upsert'> | ReadonlyArray<ResolveTableType<TRecord, 'upsert'>>
+        : DbRecordArr<TRecord> | ReadonlyArray<DbRecordArr<TRecord>>,
+      returning: TKey,
+      options?: DMLOptions
+    ): QueryBuilder<TRecord, TResult2>;
+    upsert<
+      TKey extends StrKey<ResolveTableType<TRecord>>,
+      TResult2 = DeferredKeySelection.Augment<
+        UnwrapArrayMember<TResult>,
+        ResolveTableType<TRecord>,
+        TKey
+        >[]
+      >(
+      data: TRecord extends CompositeTableType<unknown>
+        ? ResolveTableType<TRecord, 'upsert'> | ReadonlyArray<ResolveTableType<TRecord, 'upsert'>>
+        : DbRecordArr<TRecord> | ReadonlyArray<DbRecordArr<TRecord>>,
+      returning: readonly TKey[],
+      options?: DMLOptions
+    ): QueryBuilder<TRecord, TResult2>;
+    upsert<
+      TKey extends string,
+      TResult2 = DeferredIndex.Augment<
+        UnwrapArrayMember<TResult>,
+        TRecord,
+        TKey
+        >[]
+      >(
+      data: TRecord extends CompositeTableType<unknown>
+        ? ResolveTableType<TRecord, 'upsert'> | ReadonlyArray<ResolveTableType<TRecord, 'upsert'>>
+        : DbRecordArr<TRecord> | ReadonlyArray<DbRecordArr<TRecord>>,
+      returning: TKey,
+      options?: DMLOptions
+    ): QueryBuilder<TRecord, TResult2>;
+    upsert<
+      TKey extends string,
+      TResult2 = DeferredIndex.Augment<
+        UnwrapArrayMember<TResult>,
+        TRecord,
+        TKey
+        >[]
+      >(
+      data: TRecord extends CompositeTableType<unknown>
+        ? ResolveTableType<TRecord, 'upsert'> | ReadonlyArray<ResolveTableType<TRecord, 'upsert'>>
+        : DbRecordArr<TRecord> | ReadonlyArray<DbRecordArr<TRecord>>,
+      returning: readonly TKey[],
+      options?: DMLOptions
+    ): QueryBuilder<TRecord, TResult2>;
+    upsert<TResult2 = number[]>(
+      data: TRecord extends CompositeTableType<unknown>
+        ? ResolveTableType<TRecord, 'upsert'> | ReadonlyArray<ResolveTableType<TRecord, 'upsert'>>
+        : DbRecordArr<TRecord> | ReadonlyArray<DbRecordArr<TRecord>>
+    ): QueryBuilder<TRecord, TResult2>;
+
     modify<TRecord2 extends {} = any, TResult2 extends {} = any>(
       callback: QueryCallbackWithArgs<TRecord, any>,
       ...args: any[]
@@ -1740,6 +1810,12 @@ export declare namespace Knex {
     forShare(...tableNames: string[]): QueryBuilder<TRecord, TResult>;
     forShare(tableNames: readonly string[]): QueryBuilder<TRecord, TResult>;
 
+    forNoKeyUpdate(...tableNames: string[]): QueryBuilder<TRecord, TResult>;
+    forNoKeyUpdate(tableNames: readonly string[]): QueryBuilder<TRecord, TResult>;
+
+    forKeyShare(...tableNames: string[]): QueryBuilder<TRecord, TResult>;
+    forKeyShare(tableNames: readonly string[]): QueryBuilder<TRecord, TResult>;
+
     skipLocked(): QueryBuilder<TRecord, TResult>;
     noWait(): QueryBuilder<TRecord, TResult>;
 
@@ -1914,7 +1990,7 @@ export declare namespace Knex {
     ): ColumnBuilder;
     dropColumn(columnName: string): TableBuilder;
     dropColumns(...columnNames: string[]): TableBuilder;
-    renameColumn(from: string, to: string): ColumnBuilder;
+    renameColumn(from: string, to: string): TableBuilder;
     integer(columnName: string, length?: number): ColumnBuilder;
     tinyint(columnName: string, length?: number): ColumnBuilder;
     bigInteger(columnName: string): ColumnBuilder;
@@ -1946,7 +2022,10 @@ export declare namespace Knex {
     timestamps(
       useTimestampType?: boolean,
       makeDefaultNow?: boolean
-    ): ColumnBuilder;
+    ): void;
+    geometry(columnName: string): ColumnBuilder;
+    geography(columnName: string): ColumnBuilder;
+    point(columnName: string): ColumnBuilder;
     binary(columnName: string, length?: number): ColumnBuilder;
     enum(
       columnName: string,
@@ -1961,7 +2040,7 @@ export declare namespace Knex {
     json(columnName: string): ColumnBuilder;
     jsonb(columnName: string): ColumnBuilder;
     uuid(columnName: string): ColumnBuilder;
-    comment(val: string): TableBuilder;
+    comment(val: string): void;
     specificType(columnName: string, type: string): ColumnBuilder;
     primary(columnNames: readonly string[], options?: Readonly<{constraintName?: string, deferrable?: deferrableType}>): TableBuilder;
     /** @deprecated */
@@ -1971,9 +2050,14 @@ export declare namespace Knex {
       indexName?: string,
       indexType?: string
     ): TableBuilder;
+    index(
+      columnNames: string | readonly (string | Raw)[],
+      indexName?: string,
+      options?: Readonly<{indexType?: string, storageEngineIndexType?: storageEngineIndexType, predicate?: QueryBuilder}>
+    ): TableBuilder;
     setNullable(column: string): TableBuilder;
     dropNullable(column: string): TableBuilder;
-    unique(columnNames: readonly (string | Raw)[], options?: Readonly<{indexName?: string, deferrable?: deferrableType}>): TableBuilder;
+    unique(columnNames: readonly (string | Raw)[], options?: Readonly<{indexName?: string, storageEngineIndexType?: string, deferrable?: deferrableType}>): TableBuilder;
     /** @deprecated */
     unique(columnNames: readonly (string | Raw)[], indexName?: string): TableBuilder;
     foreign(column: string, foreignKeyName?: string): ForeignConstraintBuilder;
@@ -1985,7 +2069,7 @@ export declare namespace Knex {
     dropUnique(columnNames: readonly (string | Raw)[], indexName?: string): TableBuilder;
     dropPrimary(constraintName?: string): TableBuilder;
     dropIndex(columnNames: string | readonly (string | Raw)[], indexName?: string): TableBuilder;
-    dropTimestamps(): ColumnBuilder;
+    dropTimestamps(): TableBuilder;
     queryContext(context: any): TableBuilder;
   }
 
@@ -2017,6 +2101,8 @@ export declare namespace Knex {
   }
 
   type deferrableType = 'not deferrable' | 'immediate' | 'deferred';
+  type storageEngineIndexType = 'hash' | 'btree';
+
   interface ColumnBuilder {
     index(indexName?: string): ColumnBuilder;
     primary(options?: Readonly<{constraintName?: string, deferrable?: deferrableType}>): ColumnBuilder;
@@ -2046,9 +2132,34 @@ export declare namespace Knex {
   }
 
   interface PostgreSqlColumnBuilder extends ColumnBuilder {
+    index(
+      indexName?: string,
+      options?: Readonly<{indexType?: string, predicate?: QueryBuilder}>
+    ): ColumnBuilder;
     index(indexName?: string, indexType?: string): ColumnBuilder;
   }
 
+  interface SqlLiteColumnBuilder extends ColumnBuilder {
+    index(
+      indexName?: string,
+      options?: Readonly<{predicate?: QueryBuilder}>
+    ): ColumnBuilder;
+  }
+
+  interface MsSqlColumnBuilder extends ColumnBuilder {
+    index(
+      indexName?: string,
+      options?: Readonly<{predicate?: QueryBuilder}>
+    ): ColumnBuilder;
+  }
+
+  interface MySqlColumnBuilder extends ColumnBuilder {
+    index(
+      indexName?: string,
+      options?: Readonly<{indexType?: string, storageEngineIndexType?: storageEngineIndexType}>
+    ): ColumnBuilder;
+  }
+
   // patched ColumnBuilder methods to return ReferencingColumnBuilder with new methods
   // relies on ColumnBuilder returning only ColumnBuilder
   type ReferencingColumnBuilder = {