uql-orm 0.79.0 → 0.81.0

package/dist/migrate/schemaGenerator.js

@@ -1,17 +1,19 @@
 import { getMeta } from '../entity/index.js';
-import { canonicalToSql, engineType, isVectorCategory } from '../schema/canonicalType.js';
+import { canonicalToSql, engineType, isVectorCategory, resolveColumnCanonicalType } from '../schema/canonicalType.js';
 import { indexChanges } from '../schema/indexDifferences.js';
-import { buildSchemaAST, resolveColumnCanonicalType } from '../schema/schemaASTBuilder.js';
+import { buildSchemaAST } from '../schema/schemaASTBuilder.js';
 import { diffRelationshipNodes, diffTable } from '../schema/schemaASTDiffer.js';
 import { isAutoIncrement, qualifyName } from '../util/index.js';
-import { derivedCheckName, derivedForeignKeyName, derivedPrimaryKeyName } from '../util/sql.util.js';
-import { formatDefaultValue, SqlExpression } from './builder/expressions.js';
+import { derivedCheckName, derivedForeignKeyName, derivedPrimaryKeyName, isOwnedName } from '../util/sql.util.js';
+import { sameDefault } from './builder/expressions.js';
 import { splitSqlStatements } from './builder/splitSqlStatements.js';
 import { indexDdlFor, tableDdlFor } from './ddl/index.js';
 import { sizedType } from './ddl/tableDdl.js';
 import { columnForeignKey, columnIndex, fullColumnDefinitionToNode, renderIndexDefinition, tableDefinitionToNode, } from './generator/definitionToNode.js';
 import { indexNodeToSchema } from './generator/indexNodeToSchema.js';
 import { assertIndexPredicate } from './indexPredicate.js';
+import { added, alterations, dropped, nonEmpty, sides } from './schemaChange.js';
+import { dropTrigger, renderTrigger, stampTriggers } from './triggerSql.js';
 /**
  * Unified SQL schema generator.
  * Parameterized by dialect to handle Postgres, MySQL, MariaDB, and SQLite.
@@ -77,6 +79,7 @@ export class SqlSchemaGenerator {
         return buildEntityAST(this, entities, {
             defaultForeignKeyAction: this.defaultForeignKeyAction,
             textScoreIndexes: this.dialect.features.textScoreIndexes,
+            vectorIndexRequiresNotNull: this.features.vectorIndexRequiresNotNull,
         });
     }
     /**
@@ -98,8 +101,49 @@ export class SqlSchemaGenerator {
                 statements.push(...this.addForeignKeyStatements(qualifyName(table.name, table.schema), table.outgoingRelations.map(foreignKeyOf)));
             }
         }
+        // Triggers last: each needs its own table, and a body may read any other the same schema just made.
+        const made = new Set(tables.map((table) => qualifyName(table.name, table.schema)));
+        statements.push(...entities
+            .filter((entity) => made.has(this.resolveTableName(getMeta(entity))))
+            .flatMap((entity) => this.generateTriggers(entity)));
         return statements;
     }
+    /**
+     * The installed triggers on `entity`'s table it does not declare, and the declared ones not installed,
+     * compared by name alone: a name carries a hash of the trigger's SQL, so an edited one is a new name.
+     * Every trigger counts - the ones it authored, and one per event each stamp names.
+     */
+    triggerChanges(entity, installed) {
+        const meta = getMeta(entity);
+        const triggers = [...(meta.triggers ?? []), ...stampTriggers(this.dialect, meta)];
+        const rendered = triggers.map((trigger, i) => renderTrigger(this.dialect, meta, trigger, i));
+        const declared = new Set(rendered.map((trigger) => trigger.name));
+        return {
+            stale: [...installed]
+                .filter(([name]) => isOwnedName(name) && !declared.has(name))
+                .map(([name, statements]) => ({ name, statements })),
+            missing: rendered.filter((trigger) => !installed.has(trigger.name)),
+        };
+    }
+    generateTriggers(entity, installed = new Map()) {
+        const { stale, missing } = this.triggerChanges(entity, installed);
+        return this.swapTriggers(entity, stale, missing);
+    }
+    generateTriggersDown(entity, installed = new Map()) {
+        const { stale, missing } = this.triggerChanges(entity, installed);
+        return this.swapTriggers(entity, missing, stale);
+    }
+    /** `dropped` taken off `entity`'s table and `created` put on, which is a reconcile read either way. */
+    swapTriggers(entity, dropped, created) {
+        return [
+            ...this.generateTriggerDrops(entity, dropped.map((trigger) => trigger.name)),
+            ...created.flatMap((trigger) => trigger.statements.map((sql) => `${sql};`)),
+        ];
+    }
+    generateTriggerDrops(entity, names) {
+        const meta = getMeta(entity);
+        return names.filter(isOwnedName).flatMap((name) => dropTrigger(this.dialect, meta, name).map((sql) => `${sql};`));
+    }
     /**
      * One statement per distinct schema the tables being created live in, in first-seen order. Only
      * the tables actually being created, so a narrowed `only` does not declare namespaces it is not
@@ -131,97 +175,45 @@ export class SqlSchemaGenerator {
         const cascade = options.cascade && this.features.dropTableCascade ? ' CASCADE' : '';
         return `DROP TABLE ${ifExists}${this.escapeId(tableName)}${cascade};`;
     }
+    /**
+     * The statements taking a table through `diff`, in the one order both directions need: whatever holds
+     * something down goes before it and comes back after it. A foreign key holds its columns and the key it
+     * points at, so it goes first and comes back last; the key holds its columns; and some engines drop an
+     * index along with its column, which would leave nothing to name. An alter is its drop, then its add.
+     */
     generateAlterTable(diff) {
-        const statements = [];
-        // Before the columns, because a key column being added cannot be part of the old key, and after
-        // it is dropped the table is free to take the new one below.
-        if (diff.primaryKey?.from.length) {
-            statements.push(this.generateDropPrimaryKeySql(diff.tableName, diff.primaryKey.fromName));
-        }
-        // Before the columns: a constraint holds its columns down, so one the entity dropped cannot go
-        // while a foreign key still names it. An alter is a drop and an add, and this is its drop half.
-        statements.push(...this.dropForeignKeyStatements(diff.tableName, [
-            ...(diff.foreignKeysToDrop ?? []),
-            ...(diff.foreignKeysToAlter ?? []).map((it) => constraintNameOf(diff.tableName, it.from)),
-        ]));
-        // Before the adds, which may reuse a dropped index's name, and before the columns: some engines
-        // drop an index along with its column, which would leave nothing here to name.
-        statements.push(...this.dropIndexStatements(diff.tableName, diff.indexesToDrop, diff.schema));
-        for (const column of diff.columnsToAdd ?? []) {
-            this.assertColumnAddable(diff.tableName, column);
-            statements.push(this.tableDdl.addColumn(diff.tableName, this.generateColumnDefinitionFromSchema(column)));
-            statements.push(...this.generateColumnCommentStatement(diff.tableName, column, diff.schema));
-        }
-        statements.push(...this.alterColumnStatements(diff.tableName, (diff.columnsToAlter ?? []).map((it) => it.to)));
-        for (const columnName of diff.columnsToDrop ?? []) {
-            statements.push(...this.tableDdl.dropColumn(diff.tableName, columnName));
-        }
-        statements.push(...this.addIndexStatements(diff.tableName, diff.indexesToAdd));
-        // Last, so every column it names exists by now.
-        if (diff.primaryKey?.to.length) {
-            statements.push(this.generateAddPrimaryKeySql(diff.tableName, diff.primaryKey.to));
-        }
-        // After the columns, for the same reason the key is: a constraint cannot name one that is not
-        // there yet. The add half of an alter rides along, its drop having gone out above.
-        statements.push(...this.addForeignKeyStatements(diff.tableName, [
-            ...(diff.foreignKeysToAdd ?? []),
-            ...(diff.foreignKeysToAlter ?? []).map((it) => it.to),
-        ]));
-        return statements;
+        const { tableName, schema, primaryKey } = diff;
+        const { columns } = diff;
+        return [
+            ...sides(diff.foreignKeys, 'from').map((foreignKey) => this.generateDropForeignKeySql(tableName, constraintNameOf(tableName, foreignKey))),
+            ...(primaryKey?.from ? [this.generateDropPrimaryKeySql(tableName, primaryKey.from.name)] : []),
+            ...sides(diff.indexes, 'from').map((index) => this.generateDropIndex(tableName, index.name, schema)),
+            ...added(columns).flatMap((column) => this.addColumnStatements(tableName, column, schema)),
+            ...alterations(columns).flatMap(({ from, to }) => this.tableDdl.alterColumn(tableName, to, this.generateColumnDefinitionFromSchema(to), from)),
+            ...dropped(columns).flatMap((column) => this.tableDdl.dropColumn(tableName, column.name)),
+            ...this.addIndexStatements(tableName, sides(diff.indexes, 'to')),
+            ...(primaryKey?.to ? [this.generateAddPrimaryKeySql(tableName, primaryKey.to.columns, primaryKey.to.name)] : []),
+            ...this.addForeignKeyStatements(tableName, sides(diff.foreignKeys, 'to')),
+        ];
     }
     /** `ADD CONSTRAINT` for each of `foreignKeys`. */
     addForeignKeyStatements(tableName, foreignKeys) {
         return foreignKeys.map((foreignKey) => this.generateAddForeignKeySql(tableName, foreignKey));
     }
-    /** `DROP CONSTRAINT` for each of `constraintNames`, the mirror of {@link addForeignKeyStatements}. */
-    dropForeignKeyStatements(tableName, constraintNames) {
-        return constraintNames.map((name) => this.generateDropForeignKeySql(tableName, name));
-    }
-    /** The `ALTER COLUMN` restating each of `columns`. */
-    alterColumnStatements(tableName, columns) {
-        return columns.flatMap((column) => this.generateAlterColumnStatements(tableName, column, this.generateColumnDefinitionFromSchema(column)));
-    }
     /** An index added to a table that may already have rows: its `CREATE`, then what the engine needs after. */
-    addIndexStatements(tableName, indexes = []) {
+    addIndexStatements(tableName, indexes) {
         return indexes.flatMap((index) => [
             this.generateCreateIndex(tableName, index),
             ...this.indexDdl.settleStatements(tableName, index),
         ]);
     }
-    /** `DROP INDEX` for each of `indexes`, the mirror of {@link addIndexStatements}. */
-    dropIndexStatements(tableName, indexes = [], schema) {
-        return indexes.map((index) => this.generateDropIndex(tableName, index.name, schema));
-    }
-    generateAlterTableDown(diff) {
-        const statements = [];
-        // Constraints first, mirroring the up direction: the up added them last, so the down drops them
-        // first, and a column it is about to drop is then free of anything naming it.
-        statements.push(...this.dropForeignKeyStatements(diff.tableName, [
-            ...(diff.foreignKeysToAdd ?? []).map((it) => constraintNameOf(diff.tableName, it)),
-            ...(diff.foreignKeysToAlter ?? []).map((it) => constraintNameOf(diff.tableName, it.to)),
-        ]));
-        // The key next, for the same reason: a column the up added cannot be dropped below while the new
-        // key still names it. Restored under the name the database gave it, which is what the table had
-        // before, rather than a derived one that was never on it.
-        if (diff.primaryKey?.to.length) {
-            statements.push(this.generateDropPrimaryKeySql(diff.tableName, derivedPrimaryKeyName(diff.tableName, diff.primaryKey.to)));
-        }
-        for (const column of diff.columnsToAdd ?? []) {
-            statements.push(...this.tableDdl.dropColumn(diff.tableName, column.name));
-        }
-        statements.push(...this.alterColumnStatements(diff.tableName, (diff.columnsToAlter ?? []).map((it) => it.from)));
-        statements.push(...this.dropIndexStatements(diff.tableName, diff.indexesToAdd, diff.schema));
-        statements.push(...this.addIndexStatements(diff.tableName, diff.indexesToDrop));
-        if (diff.primaryKey?.from.length) {
-            statements.push(this.generateAddPrimaryKeySql(diff.tableName, diff.primaryKey.from, diff.primaryKey.fromName));
-        }
-        // The constraint the up replaced, back under the name the database had for it. A foreign key the
-        // up *dropped* is not restored: only its name survived the diff, never what it pointed at.
-        statements.push(...this.addForeignKeyStatements(diff.tableName, (diff.foreignKeysToAlter ?? []).map((it) => it.from)));
-        if (diff.columnsToDrop?.length || diff.foreignKeysToDrop?.length) {
-            statements.push(`-- TODO: Manual reversal needed for dropped columns/foreign keys`);
-        }
-        return statements;
+    /** A column added to a table that exists, and its comment where the engine keeps one apart. */
+    addColumnStatements(tableName, column, schema) {
+        this.assertColumnAddable(tableName, column);
+        return [
+            this.tableDdl.addColumn(tableName, this.generateColumnDefinitionFromSchema(column)),
+            ...this.generateColumnCommentStatement(tableName, column, schema),
+        ];
     }
     generateCreateIndex(tableName, index, options = {}) {
         return this.indexDdl.getCreateIndexStatement(tableName, index, options);
@@ -246,8 +238,8 @@ export class SqlSchemaGenerator {
     /**
      * The one place a column definition is spelled, so the `ColumnSchema` and `ColumnNode` paths cannot
      * drift. A key column states `NOT NULL` rather than leave it to the key: SQLite lets a key column hold
-     * NULL otherwise, and SQL Server adds no key over a nullable column. `UNIQUE` is left to the key. An
-     * enum's `CHECK` comes last, the only place MariaDB takes it.
+     * NULL otherwise, and SQL Server adds no key over a nullable column. Never `UNIQUE`: a unique column is
+     * a unique index, which the table creates beside it. An enum's `CHECK` comes last, the only place MariaDB takes it.
      */
     renderColumn(column) {
         const type = column.generatedAs
@@ -257,9 +249,6 @@ export class SqlSchemaGenerator {
         if (!column.nullable) {
             def += ' NOT NULL';
         }
-        if (column.isUnique && !column.isPrimaryKey) {
-            def += ' UNIQUE';
-        }
         def += this.tableDdl.defaultClause(column);
         if (column.comment) {
             def += this.generateColumnComment(column.comment);
@@ -325,72 +314,61 @@ export class SqlSchemaGenerator {
         if (!desired) {
             return undefined;
         }
-        // Indexes are matched here rather than by the differ, which pairs them by name so that a changed
-        // one reads as one index that altered. A migration needs the opposite: an index already in the
-        // table, under whatever name, must not be created again, and one whose shape differs is dropped
-        // and created anew - no engine alters an index's columns or uniqueness.
         const tableDiff = diffTable(desired, currentTable, { ...this.diffOptions(), compareIndexes: false });
-        const indexes = indexChanges(currentTable.name, desired.indexes, currentTable.indexes);
-        const indexesToAdd = indexes.toAdd.map(indexNodeToSchema);
-        const indexesToDrop = indexes.toDrop.map(indexNodeToSchema);
-        const columnDiffs = tableDiff?.columnDiffs ?? [];
-        const columnsToAdd = columnDiffs.flatMap((it) => (it.type === 'add' ? [this.columnNodeToSchema(it.expected)] : []));
-        const columnsToDrop = columnDiffs.flatMap((it) => (it.type === 'drop' ? [it.column] : []));
-        // Without its values: an alter restates the whole column, and MySQL answers a restated `CHECK` by
-        // adding a *second* constraint rather than replacing the first, so the column would accumulate one
-        // per alter. An enum's values reach the database with the column and are never restated - which is
-        // also why changing them is a hand-written migration. See architecture/roadmap.md.
-        const columnsToAlter = columnDiffs.flatMap((it) => it.type === 'alter'
-            ? [
-                {
-                    from: this.columnNodeToSchema(it.actual),
-                    to: { ...this.columnNodeToSchema(it.expected), enum: undefined },
-                },
-            ]
-            : []);
-        const primaryKey = tableDiff?.primaryKeyDiff && {
-            from: tableDiff.primaryKeyDiff.actual,
-            to: tableDiff.primaryKeyDiff.expected,
-            fromName: tableDiff.primaryKeyDiff.actualName,
+        const indexes = indexChanges(currentTable.name, desired.indexes, currentTable.indexes, currentTable.indexFacets);
+        // An alter's `to` without its values: an alter restates the whole column, and MySQL answers a
+        // restated `CHECK` by adding a *second* constraint rather than replacing the first, so the column
+        // would accumulate one per alter. An enum's values reach the database with the column and are never
+        // restated - which is also why changing them is a hand-written migration. See architecture/roadmap.md.
+        const columns = (tableDiff?.columnDiffs ?? []).map((it) => {
+            if (it.type === 'add') {
+                return { to: this.columnNodeToSchema(it.expected) };
+            }
+            if (it.type === 'drop') {
+                return { from: this.columnNodeToSchema(it.actual) };
+            }
+            return {
+                from: this.columnNodeToSchema(it.actual),
+                to: { ...this.columnNodeToSchema(it.expected), enum: undefined },
+            };
+        });
+        const keyDiff = tableDiff?.primaryKeyDiff;
+        // The key added named as this generator names it, so the rollback can drop it by that name.
+        const primaryKey = keyDiff && {
+            from: keyDiff.actual,
+            to: keyDiff.expected && {
+                columns: keyDiff.expected.columns,
+                name: derivedPrimaryKeyName(tableName, keyDiff.expected.columns),
+            },
         };
         // This table's own foreign keys. None where the engine cannot alter one (SQLite, short of rebuilding
         // the table), since a difference nothing can apply would throw on every sync; `drift:check` names it.
         const relationDiffs = this.features.foreignKeyAlter
             ? diffRelationshipNodes(desired.outgoingRelations, currentTable.outgoingRelations, this.diffOptions())
             : [];
-        const foreignKeysToAdd = relationDiffs.flatMap((it) => (it.type === 'create' ? [foreignKeyOf(it.expected)] : []));
-        const foreignKeysToDrop = relationDiffs.flatMap((it) => (it.type === 'drop' ? [it.name] : []));
-        const foreignKeysToAlter = relationDiffs.flatMap((it) => it.type === 'alter' ? [{ from: foreignKeyOf(it.actual), to: foreignKeyOf(it.expected) }] : []);
-        if (!columnsToAdd.length &&
-            !columnsToAlter.length &&
-            !columnsToDrop.length &&
-            !indexesToAdd.length &&
-            !indexesToDrop.length &&
-            !foreignKeysToAdd.length &&
-            !foreignKeysToDrop.length &&
-            !foreignKeysToAlter.length &&
-            !primaryKey) {
-            return undefined;
-        }
-        return {
+        const foreignKeys = relationDiffs.map(({ actual, expected }) => ({
+            from: actual && foreignKeyOf(actual),
+            to: expected && foreignKeyOf(expected),
+        }));
+        const alter = {
             tableName,
             schema,
             type: 'alter',
             primaryKey,
-            columnsToAdd: columnsToAdd.length ? columnsToAdd : undefined,
-            columnsToAlter: columnsToAlter.length ? columnsToAlter : undefined,
-            columnsToDrop: columnsToDrop.length ? columnsToDrop : undefined,
-            indexesToAdd: indexesToAdd.length ? indexesToAdd : undefined,
-            indexesToDrop: indexesToDrop.length ? indexesToDrop : undefined,
-            foreignKeysToAdd: foreignKeysToAdd.length ? foreignKeysToAdd : undefined,
-            foreignKeysToDrop: foreignKeysToDrop.length ? foreignKeysToDrop : undefined,
-            foreignKeysToAlter: foreignKeysToAlter.length ? foreignKeysToAlter : undefined,
+            columns: nonEmpty(columns),
+            indexes: nonEmpty([
+                ...indexes.toAdd.map((to) => ({ to: indexNodeToSchema(to) })),
+                ...indexes.toDrop.map((from) => ({ from: indexNodeToSchema(from) })),
+                ...indexes.toAlter.map(({ from, to }) => ({ from: indexNodeToSchema(from), to: indexNodeToSchema(to) })),
+            ]),
+            foreignKeys: nonEmpty(foreignKeys),
         };
+        return alter.primaryKey || alter.columns || alter.indexes || alter.foreignKeys ? alter : undefined;
     }
     diffOptions() {
         return {
             normalizeType: engineType(this.dialect),
-            defaultsEqual: (expected, actual) => this.isDefaultValueEqual(actual, expected),
+            defaultsEqual: this.defaultsEqual,
         };
     }
     /** Spread, not copied field by field, so a field the node gains cannot go missing here. */
@@ -398,58 +376,28 @@ export class SqlSchemaGenerator {
         const { table: _table, referencedBy: _referencedBy, references: _references, ...column } = col;
         return { ...column, type: this.columnSqlType(col) };
     }
-    /**
-     * Compare two default values for equality
-     */
-    isDefaultValueEqual(current, desired) {
-        if (current === desired)
-            return true;
-        // Both spellings of "no default" are the same fact, and engines disagree on which they report:
-        // MariaDB says `null` where MySQL says nothing at all. Reading them as different values asked to
-        // `MODIFY` every nullable column, on every sync, forever.
-        if (current == null || desired == null)
-            return current == null && desired == null;
-        const normalize = (value) => {
-            // Render first: the desired side may be a symbolic expression, the current side is always the
-            // engine's own text, and `{"kind":"now"}` matches no spelling of `CURRENT_TIMESTAMP`.
-            const val = SqlExpression.isExpression(value) ? formatDefaultValue(value, this.dialect) : value;
-            if (typeof val === 'string') {
-                let s = val.replace(/::[a-z_]+(\s+[a-z_]+)*(\[\])?$/i, '');
-                s = s.replace(/^'(.*)'$/, '$1');
-                if (s.toLowerCase() === 'null')
-                    return 'null';
-                return s;
-            }
-            return typeof val === 'object' ? JSON.stringify(val) : String(val);
-        };
-        return normalize(current) === normalize(desired);
-    }
+    /** Whether a column's stored default is the one the entity declares, as this engine reprints it. */
+    defaultsEqual = (desired, current) => sameDefault(desired, current, this.dialect);
     generateCreateTableFromNode(table, options = {}) {
         const columns = [];
         const constraints = [];
-        // MariaDB rejects a `VECTOR INDEX` whose column is nullable ("All parts of a VECTOR index must
-        // be NOT NULL"), so being indexed decides it rather than the entity's own nullability.
-        const indexedVectorColumns = new Set(this.features.vectorIndexRequiresNotNull
-            ? table.indexes.filter((index) => index.type === 'vector').flatMap((idx) => idx.entries.map((e) => e.column))
-            : []);
         for (const col of table.columns.values()) {
-            const colDef = this.generateColumnFromNode(indexedVectorColumns.has(col.name) ? { ...col, nullable: false } : col);
-            columns.push(colDef);
+            columns.push(this.generateColumnFromNode(col));
         }
         // Every key, of any width, as one named constraint beside the checks and foreign keys - so a
         // later `DROP` has something to name. The exception is a dialect whose serial type states the key
         // itself (SQLite's `INTEGER PRIMARY KEY AUTOINCREMENT`, which cannot be split): there the column
         // has already declared it, and saying it again is a second primary key.
+        const key = table.primaryKey;
         const declaredByColumn = this.dialect.features.serialDeclaresPrimaryKey &&
-            table.primaryKey.length === 1 &&
-            table.primaryKey[0].isAutoIncrement;
-        if (table.primaryKey.length && !declaredByColumn) {
-            const pkColumns = table.primaryKey.map((c) => c.name);
-            const pkName = table.primaryKeyName ?? derivedPrimaryKeyName(table.name, pkColumns);
-            const pkCols = pkColumns.map((c) => this.escapeId(c)).join(', ');
-            constraints.push(`CONSTRAINT ${this.escapeId(pkName)} PRIMARY KEY (${pkCols})`);
-        }
-        (table.checks ?? []).forEach((check, i) => {
+            key?.columns.length === 1 &&
+            table.columns.get(key.columns[0])?.isAutoIncrement;
+        if (key && !declaredByColumn) {
+            const name = key.name ?? derivedPrimaryKeyName(table.name, key.columns);
+            const columns = key.columns.map((column) => this.escapeId(column)).join(', ');
+            constraints.push(`CONSTRAINT ${this.escapeId(name)} PRIMARY KEY (${columns})`);
+        }
+        table.checks.forEach((check, i) => {
             const name = check.name ?? derivedCheckName(table.name, i + 1);
             constraints.push(`CONSTRAINT ${this.escapeId(name)} CHECK (${check.expression})`);
         });
@@ -457,8 +405,8 @@ export class SqlSchemaGenerator {
             const refTable = this.dialect.escapeQualifiedId(rel.to.table.name, rel.to.table.schema);
             constraints.push(this.foreignKeyConstraint(table.name, foreignKeyOf(rel), refTable));
         }
-        const ifNotExists = options.ifNotExists && this.features.ifNotExists ? 'IF NOT EXISTS ' : '';
-        let createSql = `CREATE TABLE ${ifNotExists}${this.dialect.escapeQualifiedId(table.name, table.schema)} (\n`;
+        const target = this.dialect.escapeQualifiedId(table.name, table.schema);
+        let createSql = `${this.tableDdl.createTable(target, !!options.ifNotExists)} (\n`;
         createSql += columns.map((col) => `  ${col}`).join(',\n');
         if (constraints.length > 0) {
             createSql += ',\n';

package/dist/migrate/storage/databaseStorage.d.ts

@@ -13,6 +13,10 @@ export declare class DatabaseMigrationStorage implements MigrationStorage {
         tableName?: string;
     });
     ensureStorage(): Promise<void>;
+    /**
+     * Rendered by the schema generator rather than written out, so each engine gets its own spelling: SQL
+     * Server has no `CREATE TABLE IF NOT EXISTS`, and its `TIMESTAMP` is a row version that takes no default.
+     */
     private createTableIfNotExists;
     executed(): Promise<string[]>;
     /**

package/dist/migrate/storage/databaseStorage.js

@@ -1,4 +1,7 @@
 import { withSqlQuerierForMigrations } from '../acquireQuerierForMigrations.js';
+import { expr } from '../builder/expressions.js';
+import { TableBuilder } from '../builder/tableBuilder.js';
+import { SqlSchemaGenerator } from '../schemaGenerator.js';
 /** Where executed migrations are recorded when the config does not name a table. */
 export const DEFAULT_MIGRATIONS_TABLE = 'uql_migrations';
 /**
@@ -22,15 +25,18 @@ export class DatabaseMigrationStorage {
             this.storageInitialized = true;
         });
     }
+    /**
+     * Rendered by the schema generator rather than written out, so each engine gets its own spelling: SQL
+     * Server has no `CREATE TABLE IF NOT EXISTS`, and its `TIMESTAMP` is a row version that takes no default.
+     */
     async createTableIfNotExists(querier) {
-        const { dialect } = querier;
-        const sql = /*sql*/ `
-      CREATE TABLE IF NOT EXISTS ${dialect.escapeId(this.tableName)} (
-        ${dialect.escapeId('name')} VARCHAR(255) PRIMARY KEY,
-        ${dialect.escapeId('executed_at')} TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-      )
-    `;
-        await querier.run(sql);
+        const table = new TableBuilder(this.tableName);
+        table.string('name', { length: 255, primaryKey: true });
+        table.timestamp('executed_at', { defaultValue: expr.now() });
+        const generator = new SqlSchemaGenerator(querier.dialect);
+        for (const sql of generator.generateCreateTableFromDefinition(table.build(), { ifNotExists: true })) {
+            await querier.run(sql);
+        }
     }
     async executed() {
         await this.ensureStorage();

package/dist/migrate/triggerSql.d.ts

@@ -0,0 +1,24 @@
+import type { AbstractSqlDialect } from '../dialect/index.js';
+import type { EntityMeta, EntityTriggerMeta } from '../type/index.js';
+/** A trigger as uql installs it: the identifier, and the statements creating it under that identifier. */
+export type RenderedTrigger = {
+    readonly name: string;
+    readonly statements: readonly string[];
+};
+/**
+ * One trigger for `dialect`, named for its table and label and ending in a hash of its own SQL. That hash
+ * is the whole of change detection: a trigger is in place exactly when its name is installed, and an
+ * edited one is a new name, created while the old one drops as no longer declared.
+ */
+export declare function renderTrigger<E>(dialect: AbstractSqlDialect, meta: EntityMeta<E>, trigger: EntityTriggerMeta<E>, position: number): RenderedTrigger;
+/**
+ * What removes one trigger: the trigger, named with its table only where the engine scopes the name to
+ * one, and on the Postgres family the function holding its body, which dropping a trigger leaves behind.
+ */
+export declare function dropTrigger<E>(dialect: AbstractSqlDialect, meta: EntityMeta<E>, name: string): string[];
+/**
+ * The triggers a stamp needs: one per event it names, each assigning the field's expression to its
+ * column. Generated rather than authored, so unlike an authored body it renders on every engine from
+ * one declaration - and not at all on the MySQL family, whose columns stamp themselves.
+ */
+export declare function stampTriggers<E>(dialect: AbstractSqlDialect, meta: EntityMeta<E>): EntityTriggerMeta<E>[];