velocious 1.0.613 → 1.0.614

package/README.md

@@ -7,7 +7,7 @@
 * Connection-scoped advisory locks with automatic cleanup before pooled connections are reused or closed (see [docs/advisory-locks.md](docs/advisory-locks.md))
 * Built-in record auditing for model lifecycle changes (see [docs/auditing.md](docs/auditing.md))
 * Declarative state machines for models, with typed event methods generated into the base model (see [docs/state-machine.md](docs/state-machine.md))
-* Migrations for schema changes and UTC datetime storage (see [docs/database-migrations.md](docs/database-migrations.md))
+* Migrations for schema changes and UTC datetime storage, including recorded `changeTable` batches that combine operations into one `ALTER` on bulk-capable drivers (see [docs/database-migrations.md](docs/database-migrations.md) and [docs/change-table.md](docs/change-table.md))
 * Tenant-selected base-model and structure generation with one immutable, fail-closed physical database context; tenant-only model metadata initializes only after that context is active (see [docs/tenant-selected-database-generation.md](docs/tenant-selected-database-generation.md))
 * Read-only tenant migration deploy preflight with stable JSON output and fail-closed ledger reads (see [docs/tenant-migration-deploy-preflight.md](docs/tenant-migration-deploy-preflight.md))
 * External packages (engines) that contribute data models, frontend-model resources and migrations to a consuming app (see [docs/packages.md](docs/packages.md))

package/build/database/drivers/base.js

@@ -908,6 +908,25 @@ export default class VelociousDatabaseDriversBase {
     throw new Error("'type' not implemented")
   }
 
+  /**
+   * Whether this driver can combine unrelated alter-table operations into a
+   * single `ALTER TABLE` statement (Rails' `supports_bulk_alter`).
+   * @returns {boolean} - Whether bulk alter is supported.
+   */
+  supportsBulkAlter() {
+    return false
+  }
+
+  /**
+   * Whether a bulk `ALTER TABLE` statement can also carry `ADD INDEX` clauses.
+   * Only drivers that support this keep index adds inside the combined batch;
+   * the rest execute each index as its own statement.
+   * @returns {boolean} - Whether indexes can be added inside a bulk alter.
+   */
+  supportsBulkAlterIndexes() {
+    return false
+  }
+
   /**
    * Runs insert.
    * @param {InsertSqlArgsType} args - Options object.

package/build/database/drivers/mysql/index.js

@@ -345,6 +345,18 @@ export default class VelociousDatabaseDriversMysql extends Base{
    */
   getType() { return "mysql" }
 
+  /**
+   * Whether this driver supports combining operations into one bulk `ALTER`.
+   * @returns {boolean} - Whether bulk alter is supported.
+   */
+  supportsBulkAlter() { return true }
+
+  /**
+   * Whether the bulk `ALTER` can also carry `ADD INDEX` clauses.
+   * @returns {boolean} - Whether indexes can be added inside a bulk alter.
+   */
+  supportsBulkAlterIndexes() { return true }
+
   /**
    * Runs retryable database error.
    * @param {Error} error - Error instance.

package/build/database/drivers/mysql/sql/alter-table.js

@@ -26,13 +26,25 @@ export default class VelociousDatabaseConnectionDriversMysqlSqlAlterTable extend
     const indexes = this.tableData.getIndexes()
 
     if (indexes.length === 0) return sqls
-    if (sqls.length !== 1) throw new Error("Expected one MySQL ALTER TABLE statement when adding indexes")
+    if (sqls.length > 1) throw new Error("Expected one MySQL ALTER TABLE statement when adding indexes")
 
     const options = this.getOptions()
     let sql = sqls[0]
+    let needsIndexSeparator = true
+
+    if (sql === undefined) {
+      sql = `ALTER TABLE ${options.quoteTableName(this.tableData.getName())} `
+      needsIndexSeparator = false
+    }
 
     for (const index of indexes) {
-      sql += ", ADD"
+      if (needsIndexSeparator) {
+        sql += ", "
+      } else {
+        needsIndexSeparator = true
+      }
+
+      sql += "ADD"
 
       if (index.getUnique()) sql += " UNIQUE"
 

package/build/database/drivers/pgsql/index.js

@@ -203,6 +203,19 @@ export default class VelociousDatabaseDriversPgsql extends Base{
 
   getType() { return "pgsql" }
 
+  /**
+   * Whether this driver supports combining operations into one bulk `ALTER`.
+   * @returns {boolean} - Whether bulk alter is supported.
+   */
+  supportsBulkAlter() { return true }
+
+  /**
+   * Whether the bulk `ALTER` can also carry `ADD INDEX` clauses. PostgreSQL's
+   * `ALTER TABLE` cannot express index creation, so indexes stay standalone.
+   * @returns {boolean} - Whether indexes can be added inside a bulk alter.
+   */
+  supportsBulkAlterIndexes() { return false }
+
   /**
    * Runs query actual.
    * @param {string} sql - SQL string.

package/build/database/migration/change-table.js

@@ -0,0 +1,324 @@
+// @ts-check
+
+/**
+ * ChangeTableAddIndexArgsType type.
+ * @typedef {object} ChangeTableAddIndexArgsType
+ * @property {boolean} [ifNotExists] - Skip creation if the index already exists.
+ * @property {string} [name] - Explicit index name to use.
+ * @property {boolean} [unique] - Whether the index should be unique.
+ */
+
+/**
+ * ChangeTableRemoveIndexArgsType type.
+ * @typedef {object} ChangeTableRemoveIndexArgsType
+ * @property {string} [name] - Explicit index name to remove.
+ */
+
+/**
+ * ChangeTableRemoveReferenceArgsType type.
+ * @typedef {object} ChangeTableRemoveReferenceArgsType
+ * @property {string} [columnName] - Override the derived reference column name.
+ * @property {string} [indexName] - Explicit generated index name to remove.
+ */
+
+/**
+ * ChangeTableAddColumnOperationType type.
+ * @typedef {object} ChangeTableAddColumnOperationType
+ * @property {"addColumn"} type - Operation type.
+ * @property {string} columnName - Column name.
+ * @property {string} columnType - Column type.
+ * @property {import("../table-data/table-column.js").TableColumnArgsType | undefined} args - Column args.
+ */
+
+/**
+ * ChangeTableRemoveColumnOperationType type.
+ * @typedef {object} ChangeTableRemoveColumnOperationType
+ * @property {"removeColumn"} type - Operation type.
+ * @property {string} columnName - Column name.
+ */
+
+/**
+ * ChangeTableAddIndexOperationType type.
+ * @typedef {object} ChangeTableAddIndexOperationType
+ * @property {"addIndex"} type - Operation type.
+ * @property {Array<string | import("../table-data/table-column.js").default>} columns - Columns to index.
+ * @property {ChangeTableAddIndexArgsType | undefined} args - Index args.
+ */
+
+/**
+ * ChangeTableRemoveIndexOperationType type.
+ * @typedef {object} ChangeTableRemoveIndexOperationType
+ * @property {"removeIndex"} type - Operation type.
+ * @property {string | Array<string | import("../table-data/table-column.js").default>} nameOrColumns - Index name or columns.
+ * @property {ChangeTableRemoveIndexArgsType | undefined} args - Index args.
+ */
+
+/**
+ * ChangeTableAddReferenceOperationType type.
+ * @typedef {object} ChangeTableAddReferenceOperationType
+ * @property {"addReference"} type - Operation type.
+ * @property {string} referenceName - Reference name.
+ * @property {object | undefined} args - Reference args.
+ */
+
+/**
+ * ChangeTableRemoveReferenceOperationType type.
+ * @typedef {object} ChangeTableRemoveReferenceOperationType
+ * @property {"removeReference"} type - Operation type.
+ * @property {string} referenceName - Reference name.
+ * @property {ChangeTableRemoveReferenceArgsType | undefined} args - Reference args.
+ */
+
+/**
+ * ChangeTableRenameColumnOperationType type.
+ * @typedef {object} ChangeTableRenameColumnOperationType
+ * @property {"renameColumn"} type - Operation type.
+ * @property {string} oldColumnName - Previous column name.
+ * @property {string} newColumnName - New column name.
+ */
+
+/**
+ * ChangeTableChangeColumnNullOperationType type.
+ * @typedef {object} ChangeTableChangeColumnNullOperationType
+ * @property {"changeColumnNull"} type - Operation type.
+ * @property {string} columnName - Column name.
+ * @property {boolean} nullable - Whether the column becomes nullable.
+ */
+
+/**
+ * ChangeTableOperationType type.
+ * @typedef {ChangeTableAddColumnOperationType | ChangeTableRemoveColumnOperationType | ChangeTableAddIndexOperationType | ChangeTableRemoveIndexOperationType | ChangeTableAddReferenceOperationType | ChangeTableRemoveReferenceOperationType | ChangeTableRenameColumnOperationType | ChangeTableChangeColumnNullOperationType} ChangeTableOperationType
+ */
+
+/**
+ * Table-scoped recorder used by `migration.changeTable`. Each call records a
+ * single DDL operation synchronously; `changeTable` replays them after the
+ * callback completes so a failed callback executes zero recorded DDL.
+ */
+export default class VelociousDatabaseMigrationChangeTable {
+  /**
+   * Operations.
+   * @type {ChangeTableOperationType[]} */
+  _operations = []
+
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {string} args.tableName - Table name.
+   */
+  constructor({tableName}) {
+    if (!tableName) throw new Error(`Invalid table name: ${tableName}`)
+
+    this._tableName = tableName
+  }
+
+  /**
+   * Runs get table name.
+   * @returns {string} - The table name.
+   */
+  getTableName() { return this._tableName }
+
+  /**
+   * Runs get operations.
+   * @returns {ChangeTableOperationType[]} - The recorded operations.
+   */
+  getOperations() { return this._operations }
+
+  /**
+   * Records a new column.
+   * @param {string} name - Column name.
+   * @param {string} type - Column type.
+   * @param {import("../table-data/table-column.js").TableColumnArgsType} [args] - Options object.
+   * @returns {void} - No return value.
+   */
+  column(name, type, args) {
+    this._operations.push({type: "addColumn", columnName: name, columnType: type, args})
+  }
+
+  /**
+   * Records a bigint column.
+   * @param {string} name - Column name.
+   * @param {import("../table-data/table-column.js").TableColumnArgsType} [args] - Options object.
+   * @returns {void} - No return value.
+   */
+  bigint(name, args) { this.column(name, "bigint", args) }
+
+  /**
+   * Records a blob column.
+   * @param {string} name - Column name.
+   * @param {import("../table-data/table-column.js").TableColumnArgsType} [args] - Options object.
+   * @returns {void} - No return value.
+   */
+  blob(name, args) { this.column(name, "blob", args) }
+
+  /**
+   * Records a boolean column.
+   * @param {string} name - Column name.
+   * @param {import("../table-data/table-column.js").TableColumnArgsType} [args] - Options object.
+   * @returns {void} - No return value.
+   */
+  boolean(name, args) { this.column(name, "boolean", args) }
+
+  /**
+   * Records a datetime column.
+   * @param {string} name - Column name.
+   * @param {import("../table-data/table-column.js").TableColumnArgsType} [args] - Options object.
+   * @returns {void} - No return value.
+   */
+  datetime(name, args) { this.column(name, "datetime", args) }
+
+  /**
+   * Records a decimal column.
+   * @param {string} name - Column name.
+   * @param {import("../table-data/table-column.js").TableColumnArgsType} [args] - Options object.
+   * @returns {void} - No return value.
+   */
+  decimal(name, args) { this.column(name, "decimal", args) }
+
+  /**
+   * Records an integer column.
+   * @param {string} name - Column name.
+   * @param {import("../table-data/table-column.js").TableColumnArgsType} [args] - Options object.
+   * @returns {void} - No return value.
+   */
+  integer(name, args) { this.column(name, "integer", args) }
+
+  /**
+   * Records a json column.
+   * @param {string} name - Column name.
+   * @param {import("../table-data/table-column.js").TableColumnArgsType} [args] - Options object.
+   * @returns {void} - No return value.
+   */
+  json(name, args) { this.column(name, "json", args) }
+
+  /**
+   * Records a string column.
+   * @param {string} name - Column name.
+   * @param {import("../table-data/table-column.js").TableColumnArgsType} [args] - Options object.
+   * @returns {void} - No return value.
+   */
+  string(name, args) { this.column(name, "string", args) }
+
+  /**
+   * Records a text column.
+   * @param {string} name - Column name.
+   * @param {import("../table-data/table-column.js").TableColumnArgsType} [args] - Options object.
+   * @returns {void} - No return value.
+   */
+  text(name, args) { this.column(name, "text", args) }
+
+  /**
+   * Records a tinyint column.
+   * @param {string} name - Column name.
+   * @param {import("../table-data/table-column.js").TableColumnArgsType} [args] - Options object.
+   * @returns {void} - No return value.
+   */
+  tinyint(name, args) { this.column(name, "tinyint", args) }
+
+  /**
+   * Records a uuid column.
+   * @param {string} name - Column name.
+   * @param {import("../table-data/table-column.js").TableColumnArgsType} [args] - Options object.
+   * @returns {void} - No return value.
+   */
+  uuid(name, args) { this.column(name, "uuid", args) }
+
+  /**
+   * Records created_at and updated_at datetime columns.
+   * @param {import("../table-data/table-column.js").TableColumnArgsType} [args] - Options object.
+   * @returns {void} - No return value.
+   */
+  timestamps(args) {
+    this.datetime("created_at", args)
+    this.datetime("updated_at", args)
+  }
+
+  /**
+   * Records a new index.
+   * @param {string | Array<string | import("../table-data/table-column.js").default>} columns - Column name or array of column names.
+   * @param {ChangeTableAddIndexArgsType} [args] - Options object.
+   * @returns {void} - No return value.
+   */
+  index(columns, args) {
+    const normalizedColumns = typeof columns == "string" ? [columns] : columns
+
+    this._operations.push({type: "addIndex", columns: normalizedColumns, args})
+  }
+
+  /**
+   * Records a reference column, index, and optional foreign key.
+   * @param {string} name - Reference name.
+   * @param {object} [args] - Options object.
+   * @returns {void} - No return value.
+   */
+  references(name, args) {
+    this._operations.push({type: "addReference", referenceName: name, args})
+  }
+
+  /**
+   * Alias for {@link references}.
+   * @param {string} name - Reference name.
+   * @param {object} [args] - Options object.
+   * @returns {void} - No return value.
+   */
+  belongsTo(name, args) { this.references(name, args) }
+
+  /**
+   * Records removal of one or more columns.
+   * @param {string[]} columnNames - Column names to remove.
+   * @returns {void} - No return value.
+   */
+  remove(...columnNames) {
+    for (const columnName of columnNames) {
+      this._operations.push({type: "removeColumn", columnName})
+    }
+  }
+
+  /**
+   * Records removal of an index.
+   * @param {string | Array<string | import("../table-data/table-column.js").default>} nameOrColumns - Index name or columns.
+   * @param {ChangeTableRemoveIndexArgsType} [args] - Options object.
+   * @returns {void} - No return value.
+   */
+  removeIndex(nameOrColumns, args) {
+    this._operations.push({type: "removeIndex", nameOrColumns, args})
+  }
+
+  /**
+   * Records removal of a reference column and its generated index and foreign keys.
+   * @param {string} name - Reference name.
+   * @param {ChangeTableRemoveReferenceArgsType} [args] - Options object.
+   * @returns {void} - No return value.
+   */
+  removeReferences(name, args) {
+    this._operations.push({type: "removeReference", referenceName: name, args})
+  }
+
+  /**
+   * Records removal of the created_at and updated_at columns.
+   * @returns {void} - No return value.
+   */
+  removeTimestamps() {
+    this.remove("created_at", "updated_at")
+  }
+
+  /**
+   * Records a column rename.
+   * @param {string} oldColumnName - Previous column name.
+   * @param {string} newColumnName - New column name.
+   * @returns {void} - No return value.
+   */
+  rename(oldColumnName, newColumnName) {
+    this._operations.push({type: "renameColumn", oldColumnName, newColumnName})
+  }
+
+  /**
+   * Records a change to a column's nullability.
+   * @param {string} columnName - Column name.
+   * @param {boolean} nullable - Whether the column becomes nullable.
+   * @returns {void} - No return value.
+   */
+  changeNull(columnName, nullable) {
+    this._operations.push({type: "changeColumnNull", columnName, nullable})
+  }
+}

package/build/database/migration/index.js

@@ -1,17 +1,5 @@
 // @ts-check
 
-/**
- * AddColumnArgsType type.
- * @typedef {object} AddColumnArgsType
- * @property {ReturnType<typeof JSON.parse>} [default] - Default value for the column.
- * @property {object} [foreignKey] - Foreign key definition for the column.
- * @property {boolean | {unique: boolean}} [index] - Whether to add an index (optionally unique).
- * @property {number} [limit] - Alias for maxLength (varchar length limit) on string-like columns.
- * @property {number} [maxLength] - Maximum length for string-like columns (e.g. varchar length).
- * @property {boolean} [null] - Whether the column allows null values.
- * @property {boolean} [primaryKey] - Whether the column is a primary key.
- * @property {boolean} [unique] - Whether the column enforces uniqueness.
- */
 /**
  * CreateTableIdArgsType type.
  * @typedef {object} CreateTableIdArgsType
@@ -39,8 +27,11 @@
 import { convertLegacyDateValueToUtcStorage } from "../datetime-storage.js"
 import * as inflection from "inflection"
 import restArgsError from "../../utils/rest-args-error.js"
+import ChangeTable from "./change-table.js"
 import CreateIndexBase from "../query/create-index-base.js"
+import TableColumn from "../table-data/table-column.js"
 import TableData from "../table-data/index.js"
+import TableIndex from "../table-data/table-index.js"
 class NotImplementedError extends Error {}
 
 export {NotImplementedError}
@@ -118,7 +109,7 @@ export default class VelociousDatabaseMigration {
    * @param {string} tableName - Table name.
    * @param {string} columnName - Column name.
    * @param {string} columnType - Column type.
-   * @param {AddColumnArgsType} [args] - Options object.
+   * @param {import("../table-data/table-column.js").TableColumnArgsType} [args] - Options object.
    * @returns {Promise<void>} - Resolves when complete.
    */
   async addColumn(tableName, columnName, columnType, args) {
@@ -687,6 +678,199 @@ export default class VelociousDatabaseMigration {
     }
   }
 
+  /**
+   * ChangeTableArgsType type.
+   * @typedef {object} ChangeTableArgsType
+   * @property {boolean} [bulk] - Combine compatible contiguous DDL into single
+   *   ALTER TABLE statements on drivers that support bulk alters (MySQL/MariaDB
+   *   and PostgreSQL). `bulk` controls DDL grouping only, not transactional
+   *   atomicity; unchanged drivers execute the recorded commands sequentially.
+   */
+
+  /**
+   * ChangeTableCallbackType type.
+   * @typedef {(table: import("./change-table.js").default) => void | Promise<void>} ChangeTableCallbackType
+   */
+
+  /**
+   * Changes a table using a Rails-style table-scoped recorder.
+   * @overload
+   * @param {string} tableName - Table name.
+   * @param {ChangeTableCallbackType} callback - Callback function.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  /**
+   * Changes a table with explicit options.
+   * @overload
+   * @param {string} tableName - Table name.
+   * @param {ChangeTableArgsType} args - Options object.
+   * @param {ChangeTableCallbackType} callback - Callback function.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  /**
+   * Runs change table.
+   * @param {string} tableName - Table name.
+   * @param {ChangeTableArgsType | ChangeTableCallbackType} arg1 - Arg1.
+   * @param {ChangeTableCallbackType | undefined} [arg2] - Arg2.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async changeTable(tableName, arg1, arg2) {
+    let args = /** @type {ChangeTableArgsType} */ ({})
+    let callback
+
+    if (typeof arg1 == "function") {
+      callback = arg1
+    } else {
+      args = arg1 || {}
+      callback = arg2
+    }
+
+    if (typeof callback != "function") throw new Error("No callback given")
+
+    const {bulk = false, ...restArgs} = args
+
+    restArgsError(restArgs)
+
+    const table = new ChangeTable({tableName})
+
+    await callback(table)
+
+    await this._executeChangeTableOperations(tableName, table.getOperations(), {bulk})
+  }
+
+  /**
+   * Executes recorded changeTable operations. With `bulk` enabled on a
+   * supporting driver, compatible contiguous column operations accumulate into
+   * a single TableData flushed through `alterTableSQLs`; incompatible commands
+   * flush the batch first and run through the existing migration helpers.
+   * @param {string} tableName - Table name.
+   * @param {import("./change-table.js").ChangeTableOperationType[]} operations - Recorded operations.
+   * @param {object} args - Options object.
+   * @param {boolean} args.bulk - Whether to enable bulk command grouping.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async _executeChangeTableOperations(tableName, operations, {bulk}) {
+    const driver = this.getDriver()
+    const bulkSupported = bulk && driver.supportsBulkAlter()
+
+    if (!bulkSupported) {
+      for (const operation of operations) {
+        await this._executeChangeTableOperation(tableName, operation)
+      }
+
+      return
+    }
+
+    let batch = new TableData(tableName)
+
+    const flushBatch = async () => {
+      if (batch.getColumns().length == 0 && batch.getIndexes().length == 0) return
+
+      const sqls = await driver.alterTableSQLs(batch)
+
+      for (const sql of sqls) {
+        await driver.query(sql)
+      }
+
+      batch = new TableData(tableName)
+    }
+
+    for (const operation of operations) {
+      switch (operation.type) {
+        case "addColumn": {
+          if (!operation.columnType) throw new Error("No column type given")
+
+          // Flush an already-recorded index batch first so the emitted SQL keeps
+          // the recorded declaration order (index before column).
+          if (batch.getIndexes().length > 0) await flushBatch()
+
+          batch.addColumn(new TableColumn(operation.columnName, Object.assign({isNewColumn: true, type: operation.columnType}, operation.args)))
+          break
+        }
+        case "removeColumn":
+          // Flush an already-recorded index batch first so the emitted SQL keeps
+          // the recorded declaration order (index before column).
+          if (batch.getIndexes().length > 0) await flushBatch()
+
+          batch.addColumn(new TableColumn(operation.columnName, {dropColumn: true}))
+          break
+        case "addIndex":
+          // Drivers without `supportsBulkAlterIndexes` (PostgreSQL) keep indexes
+          // standalone because their ALTER TABLE does not carry CREATE INDEX
+          // clauses. An ifNotExists index is never combined because the combined
+          // bulk form cannot express that guard.
+          if (!driver.supportsBulkAlterIndexes() || operation.args?.ifNotExists) {
+            await flushBatch()
+            await this._executeChangeTableOperation(tableName, operation)
+          } else {
+            batch.addIndex(this._changeTableTableIndex(tableName, operation))
+          }
+          break
+        default:
+          await flushBatch()
+          await this._executeChangeTableOperation(tableName, operation)
+      }
+    }
+
+    await flushBatch()
+  }
+
+  /**
+   * Builds a TableIndex for a batch from a recorded addIndex operation,
+   * resolving the default addIndex name eagerly so a combined MySQL ALTER
+   * never silently names the index differently.
+   * @param {string} tableName - Table name.
+   * @param {import("./change-table.js").ChangeTableAddIndexOperationType} operation - Recorded operation.
+   * @returns {TableIndex} - The table index.
+   */
+  _changeTableTableIndex(tableName, operation) {
+    const {args, columns} = operation
+    // An ifNotExists index never reaches batching (it is flushed standalone),
+    // so the combined ALTER cannot carry that guard.
+    const {name, ...restIndexArgs} = args || {}
+    const indexName = name || new CreateIndexBase({columns, driver: this.getDriver(), tableName}).generateIndexName()
+
+    return new TableIndex(columns, Object.assign({}, restIndexArgs, {name: indexName}))
+  }
+
+  /**
+   * Executes a single recorded changeTable operation through the existing
+   * migration helper with the same semantics as a direct helper call.
+   * @param {string} tableName - Table name.
+   * @param {import("./change-table.js").ChangeTableOperationType} operation - Recorded operation.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async _executeChangeTableOperation(tableName, operation) {
+    switch (operation.type) {
+      case "addColumn":
+        await this.addColumn(tableName, operation.columnName, operation.columnType, operation.args)
+        break
+      case "removeColumn":
+        await this.removeColumn(tableName, operation.columnName)
+        break
+      case "addIndex":
+        await this.addIndex(tableName, operation.columns, operation.args)
+        break
+      case "removeIndex":
+        await this.removeIndex(tableName, operation.nameOrColumns, operation.args)
+        break
+      case "addReference":
+        await this.addReference(tableName, operation.referenceName, operation.args || {})
+        break
+      case "removeReference":
+        await this.removeReference(tableName, operation.referenceName, operation.args)
+        break
+      case "renameColumn":
+        await this.renameColumn(tableName, operation.oldColumnName, operation.newColumnName)
+        break
+      case "changeColumnNull":
+        await this.changeColumnNull(tableName, operation.columnName, operation.nullable)
+        break
+      default:
+        throw new Error("Unknown change table operation")
+    }
+  }
+
   /**
    * Runs drop table.
    * @param {string} tableName - Table name.

package/build/src/database/drivers/base.d.ts

@@ -717,6 +717,19 @@ export default class VelociousDatabaseDriversBase {
      * @returns {string} - The type.
      */
     getType(): string;
+    /**
+     * Whether this driver can combine unrelated alter-table operations into a
+     * single `ALTER TABLE` statement (Rails' `supports_bulk_alter`).
+     * @returns {boolean} - Whether bulk alter is supported.
+     */
+    supportsBulkAlter(): boolean;
+    /**
+     * Whether a bulk `ALTER TABLE` statement can also carry `ADD INDEX` clauses.
+     * Only drivers that support this keep index adds inside the combined batch;
+     * the rest execute each index as its own statement.
+     * @returns {boolean} - Whether indexes can be added inside a bulk alter.
+     */
+    supportsBulkAlterIndexes(): boolean;
     /**
      * Runs insert.
      * @param {InsertSqlArgsType} args - Options object.