uql-orm 0.87.0 → 0.88.0

package/dist/dialect/abstractSqlDialect.d.ts

@@ -106,7 +106,7 @@ export declare abstract class AbstractSqlDialect extends VectorSqlDialect implem
     createSchemaSql(schema: string): string;
     readonly isolationLevelStrategy: 'inline' | 'set-before' | 'none';
     readonly alterColumnStrategy: 'separate-clauses' | 'single-statement';
-    readonly alterColumnSyntax: 'ALTER COLUMN' | 'MODIFY COLUMN' | 'none';
+    readonly alterColumnSyntax: 'ALTER COLUMN' | 'MODIFY COLUMN';
     readonly dropForeignKeySyntax: 'DROP CONSTRAINT' | 'DROP FOREIGN KEY';
     /**
      * `DROP CONSTRAINT <name>` where a primary key is a named constraint like any other; MySQL spells

package/dist/dialect/mysqlLikeSqlDialect.js

@@ -19,9 +19,7 @@ export const MYSQL_FEATURES = {
     indexIfNotExists: false,
     schemas: true,
     dropTableCascade: false,
-    foreignKeyAlter: true,
-    primaryKeyAlter: true,
-    generatedColumnAdd: true,
+    rebuildsTables: false,
     commentSyntax: 'inline',
     vectorIndexRequiresNotNull: false,
     vectorSupportsLength: false,

package/dist/dialect/pgLikeSqlDialect.js

@@ -21,9 +21,7 @@ export const PG_FEATURES = {
     indexIfNotExists: true,
     schemas: true,
     dropTableCascade: true,
-    foreignKeyAlter: true,
-    primaryKeyAlter: true,
-    generatedColumnAdd: true,
+    rebuildsTables: false,
     commentSyntax: 'statement',
     vectorIndexRequiresNotNull: false,
     vectorSupportsLength: true,

package/dist/migrate/ddl/tableDdl.d.ts

@@ -15,6 +15,11 @@ export declare class TableDdl {
     /** A `CREATE TABLE` up to its column list, a no-op where `ifNotExists` and the table is already there. */
     createTable(target: string, ifNotExists: boolean): string;
     addColumn(table: string, definition: string): string;
+    /**
+     * `column` added, spelled by `render`. MySQL fills a zero into the rows already there for a required
+     * column with no default, so there it is added nullable and required after, failing on them as elsewhere.
+     */
+    addColumnStatements(table: string, column: ColumnSchema, render: (column: ColumnSchema) => string): string[];
     dropColumn(table: string, column: string): string[];
     /**
      * What changes `column` to what it now declares. `definition` is the whole column, which MySQL's

package/dist/migrate/ddl/tableDdl.js

@@ -1,5 +1,5 @@
-import { UqlUsageError } from '../../util/uqlError.js';
 import { formatDefaultValue, sameDefault } from '../builder/expressions.js';
+import { lacksValue } from '../schemaChange.js';
 /**
  * A column's type with the size it was read back with, unless its spelling already carries one:
  * introspection reports `VARCHAR` and `255` apart, where a type from an entity is already whole.
@@ -30,6 +30,19 @@ export class TableDdl {
     addColumn(table, definition) {
         return `ALTER TABLE ${this.dialect.escapeId(table)} ADD COLUMN ${definition};`;
     }
+    /**
+     * `column` added, spelled by `render`. MySQL fills a zero into the rows already there for a required
+     * column with no default, so there it is added nullable and required after, failing on them as elsewhere.
+     */
+    addColumnStatements(table, column, render) {
+        if (this.dialect.alterColumnSyntax !== 'MODIFY COLUMN' || !lacksValue(column)) {
+            return [this.addColumn(table, render(column))];
+        }
+        return [
+            this.addColumn(table, render({ ...column, nullable: true })),
+            ...this.alterColumn(table, column, render(column)),
+        ];
+    }
     dropColumn(table, column) {
         return [`ALTER TABLE ${this.dialect.escapeId(table)} DROP COLUMN ${this.dialect.escapeId(column)};`];
     }
@@ -39,10 +52,6 @@ export class TableDdl {
      * column was (`from`), only the clauses that changed.
      */
     alterColumn(table, column, definition, from) {
-        if (this.dialect.alterColumnSyntax === 'none') {
-            throw new UqlUsageError(`${this.dialect}: Cannot alter column "${column.name}" - you must recreate the table. ` +
-                `This database does not support ALTER COLUMN.`);
-        }
         const target = this.dialect.escapeId(table);
         if (this.dialect.alterColumnStrategy !== 'separate-clauses') {
             return [`ALTER TABLE ${target} ${this.dialect.alterColumnSyntax} ${definition};`];

package/dist/migrate/ddl/tableRebuild.d.ts

@@ -0,0 +1,17 @@
+import type { AbstractSqlDialect } from '../../dialect/index.js';
+import type { RebuiltTable, Rename } from '../../type/index.js';
+/** What the copy reads besides the columns both sides share: renamed ones, and a default filling a column's nulls. */
+export type RebuildCopy = {
+    readonly renames: readonly Rename[];
+    readonly fills: ReadonlyMap<string, string>;
+};
+/**
+ * SQLite's documented rebuild of `table`: a new table in the shape `to` gives, the rows copied into it,
+ * the old one dropped and the new one renamed into its place, then its indexes and triggers. A foreign
+ * key pointing at the table would delete or null its rows with the drop, so the guard fails the whole
+ * rebuild first unless foreign keys are off, as the migrator turns them off on a SQLite connection.
+ */
+export declare function rebuildTable(dialect: AbstractSqlDialect, table: string, { from, to }: {
+    readonly from: RebuiltTable;
+    readonly to: RebuiltTable;
+}, copy: RebuildCopy): string[];

package/dist/migrate/ddl/tableRebuild.js

@@ -0,0 +1,56 @@
+import { OWNED_PREFIX } from '../../dialect/aliases.js';
+/** The table a rebuild copies into, under a name no entity's table takes. */
+const NEW_TABLE_PREFIX = `${OWNED_PREFIX}_new_`;
+/** The table the guard inserts into, refused while foreign keys would take rows down with the rebuilt one. */
+const GUARD_TABLE = `${OWNED_PREFIX}_rebuild_guard`;
+/**
+ * SQLite's documented rebuild of `table`: a new table in the shape `to` gives, the rows copied into it,
+ * the old one dropped and the new one renamed into its place, then its indexes and triggers. A foreign
+ * key pointing at the table would delete or null its rows with the drop, so the guard fails the whole
+ * rebuild first unless foreign keys are off, as the migrator turns them off on a SQLite connection.
+ */
+export function rebuildTable(dialect, table, { from, to }, copy) {
+    const id = (name) => dialect.escapeId(name);
+    const target = id(`${NEW_TABLE_PREFIX}${table}`);
+    const [create, ...rest] = to.statements;
+    const copied = to.columns.flatMap((column) => {
+        const source = copy.renames.find((rename) => rename.to === column)?.from ?? column;
+        if (!from.columns.includes(source)) {
+            return [];
+        }
+        const fill = copy.fills.get(column);
+        return [{ column: id(column), value: fill === undefined ? id(source) : `coalesce(${id(source)}, ${fill})` }];
+    });
+    return [
+        ...guard(dialect, table),
+        renameCreatedTable(create, target),
+        ...(copied.length
+            ? [
+                `INSERT INTO ${target} (${copied.map((it) => it.column).join(', ')}) ` +
+                    `SELECT ${copied.map((it) => it.value).join(', ')} FROM ${id(table)};`,
+            ]
+            : []),
+        `DROP TABLE ${id(table)};`,
+        `ALTER TABLE ${target} RENAME TO ${id(table)};`,
+        ...rest,
+    ];
+}
+/** Fails, naming the way out, where foreign keys are on and any table references `table`. */
+function guard(dialect, table) {
+    const id = (name) => dialect.escapeId(name);
+    const guardTable = id(GUARD_TABLE);
+    const referencing = id('referencing');
+    const refusal = id(`turn foreign keys off to rebuild ${table}: the rows referencing it would be lost`);
+    return [
+        `CREATE TABLE IF NOT EXISTS ${guardTable} (${referencing} INTEGER CONSTRAINT ${refusal} CHECK (${referencing} = 0));`,
+        `INSERT INTO ${guardTable} SELECT count(*) FROM pragma_foreign_keys AS k, sqlite_master AS m, ` +
+            `pragma_foreign_key_list(m.name) AS f WHERE k.foreign_keys AND m.type = 'table' ` +
+            `AND f.${id('table')} = ${dialect.escape(table)} COLLATE NOCASE;`,
+        `DROP TABLE ${guardTable};`,
+    ];
+}
+const CREATE_TABLE_NAME = /^(\s*CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?)(?:"(?:[^"]|"")*"|`(?:[^`]|``)*`|\[[^\]]*\]|[^\s(]+)/i;
+/** A `CREATE TABLE` as the engine or the generator spelled it, creating `name` instead. */
+function renameCreatedTable(sql, name) {
+    return sql.replace(CREATE_TABLE_NAME, `$1${name}`);
+}

package/dist/migrate/introspection/abstractSqlSchemaIntrospector.d.ts

@@ -1,5 +1,5 @@
 import { type ForeignKeyAction } from '../../schema/types.js';
-import type { ColumnSchema, InstalledTriggers, ForeignKeySchema, IndexSchema, PrimaryKeySchema, QuerierPool, RawRow, SchemaIntrospector, SqlQuerier, TableSchema } from '../../type/index.js';
+import type { ColumnSchema, InstalledTriggers, ForeignKeySchema, IndexSchema, PrimaryKeySchema, QuerierPool, RawRow, SchemaIntrospector, SqlQuerier, StoredDefinition, TableSchema } from '../../type/index.js';
 import { BaseSqlIntrospector } from './baseSqlIntrospector.js';
 /**
  * Reads the rows of one statement while introspecting a table.
@@ -37,6 +37,8 @@ export declare abstract class AbstractSqlSchemaIntrospector extends BaseSqlIntro
      */
     protected readonly defaultSchemaExpr: string;
     getTableSchema(tableName: string): Promise<TableSchema | undefined>;
+    /** See {@link TableSchema.definition}: none, but where the engine keeps the statements themselves. */
+    protected getDefinition(_read: TableRowReader, _tableName: string): Promise<StoredDefinition[] | undefined>;
     getTableNames(): Promise<string[]>;
     /**
      * Every trigger uql installed in this schema, by table and then by name, with the statements recreating

package/dist/migrate/introspection/abstractSqlSchemaIntrospector.js

@@ -30,11 +30,12 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
             if (!exists) {
                 return undefined;
             }
-            const [columns, indexes, foreignKeys, primaryKey] = await Promise.all([
+            const [columns, indexes, foreignKeys, primaryKey, definition] = await Promise.all([
                 this.getColumns(read, tableName),
                 this.getIndexes(read, tableName),
                 this.getForeignKeys(read, tableName),
                 this.getPrimaryKey(read, tableName),
+                this.getDefinition(read, tableName),
             ]);
             return {
                 name: tableName,
@@ -42,9 +43,14 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
                 primaryKey,
                 indexes,
                 foreignKeys,
+                definition,
             };
         });
     }
+    /** See {@link TableSchema.definition}: none, but where the engine keeps the statements themselves. */
+    async getDefinition(_read, _tableName) {
+        return undefined;
+    }
     async getTableNames() {
         return this.withSqlQuerier(async (querier) => {
             const results = await querier.all(this.getTableNamesQuery());

package/dist/migrate/introspection/baseSqlIntrospector.js

@@ -97,13 +97,16 @@ export class BaseSqlIntrospector {
         // key from `(b, a)`, and a flag says only that a column is *in* the key. Falls back to the flags
         // for an introspector that reports no key of its own.
         table.primaryKey = schema.primaryKey ?? keyOfColumns(schema.columns);
+        table.definition = schema.definition;
         return table;
     }
     buildRelationships(ast, tableNodes, schema, fromTable) {
         for (const fk of schema.foreignKeys ?? []) {
             const toTable = tableNodes.get(fk.references.table);
-            if (!toTable)
+            if (!toTable) {
+                fromTable.externalForeignKeys.push(fk);
                 continue;
+            }
             const fromColumns = fk.columns.flatMap((name) => fromTable.columns.get(name) ?? []);
             const toColumns = fk.references.columns.flatMap((name) => toTable.columns.get(name) ?? []);
             if (fromColumns.length > 0 && toColumns.length > 0) {

package/dist/migrate/introspection/sqliteIntrospector.d.ts

@@ -1,5 +1,5 @@
 import type { IndexFacet } from '../../schema/indexDifferences.js';
-import type { ColumnSchema, ForeignKeySchema, IndexSchema } from '../../type/index.js';
+import type { ColumnSchema, ForeignKeySchema, IndexSchema, StoredDefinition } from '../../type/index.js';
 import { AbstractSqlSchemaIntrospector, type TableRowReader } from './abstractSqlSchemaIntrospector.js';
 /**
  * SQLite schema introspector
@@ -32,12 +32,12 @@ export declare class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospec
     protected mapColumnsResult(read: TableRowReader, tableName: string, results: SqliteColumnRow[]): Promise<ColumnSchema[]>;
     protected mapIndexesResult(read: TableRowReader, _tableName: string, results: SqliteIndexRow[]): Promise<IndexSchema[]>;
     protected mapForeignKeysResult(_read: TableRowReader, tableName: string, results: SqliteForeignKeyRow[]): Promise<ForeignKeySchema[]>;
+    /** Every statement `sqlite_master` keeps for the table, its `CREATE TABLE` first. An automatic index has none. */
+    protected getDefinition(read: TableRowReader, tableName: string): Promise<StoredDefinition[]>;
     protected mapPrimaryKeyResult(results: SqliteColumnRow[]): string[] | undefined;
     private getUniqueColumns;
     /** libSQL's `libsql_vector_idx(col, 'metric=...')`, read back from the statement that created it. */
     private getVectorIndex;
-    /** The statement that created the table, which is where SQLite keeps every expression it was given. */
-    private getTableDdl;
     private getIndexColumns;
     protected normalizeType(type: string): string;
     protected extractLength(type: string): number | undefined;

package/dist/migrate/introspection/sqliteIntrospector.js

@@ -69,7 +69,10 @@ export class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         const uniqueColumns = await this.getUniqueColumns(read, tableName);
         // Only a sole `INTEGER PRIMARY KEY` is the rowid, which is what numbers itself.
         const soleKey = results.filter((row) => row.pk > 0).length === 1;
-        const ddl = results.some((row) => row.hidden === STORED_GENERATED) ? await this.getTableDdl(read, tableName) : '';
+        const [table] = results.some((row) => row.hidden === STORED_GENERATED)
+            ? await this.getDefinition(read, tableName)
+            : [];
+        const ddl = table?.sql ?? '';
         return results.map((row) => ({
             name: row.name,
             type: this.normalizeType(row.type),
@@ -136,6 +139,11 @@ export class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospector {
             };
         });
     }
+    /** Every statement `sqlite_master` keeps for the table, its `CREATE TABLE` first. An automatic index has none. */
+    getDefinition(read, tableName) {
+        return read(
+        /*sql*/ `SELECT type AS kind, name, sql FROM sqlite_master WHERE tbl_name = ? AND sql IS NOT NULL ORDER BY type <> 'table'`, [tableName]);
+    }
     mapPrimaryKeyResult(results) {
         const pkColumns = results.filter((r) => r.pk > 0).sort((a, b) => a.pk - b.pk);
         if (pkColumns.length === 0) {
@@ -176,12 +184,6 @@ export class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospector {
             distance: this.dialect.indexedDistance(metric),
         };
     }
-    /** The statement that created the table, which is where SQLite keeps every expression it was given. */
-    async getTableDdl(read, tableName) {
-        const [row] = await read(
-        /*sql*/ `SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?`, [tableName]);
-        return row.sql;
-    }
     getIndexColumns(read, indexName) {
         return read(/*sql*/ `PRAGMA index_info(${this.escapeId(indexName)})`);
     }

package/dist/migrate/migrationTarget.js

@@ -10,8 +10,34 @@ import { MongoMigrationStorage } from './storage/mongoStorage.js';
 const sqlSession = (querier) => ({
     querier,
     run: (statement) => querier.run(statement),
-    transaction: (work) => querier.transaction(work),
+    transaction: (work) => querier.dialect.features.rebuildsTables ? withForeignKeysOff(querier, work) : querier.transaction(work),
 });
+/**
+ * SQLite's own procedure for a schema change: foreign keys off before the transaction, where the switch
+ * takes effect, and every reference checked before it commits. Otherwise dropping a table to rebuild it
+ * deletes the rows pointing at it. A connection whose transaction runs elsewhere keeps them on, which the
+ * rebuild's guard refuses.
+ */
+async function withForeignKeysOff(querier, work) {
+    const [{ foreign_keys: enforced }] = await querier.all('PRAGMA foreign_keys');
+    if (!enforced) {
+        return querier.transaction(work);
+    }
+    await querier.run('PRAGMA foreign_keys = OFF');
+    try {
+        await querier.transaction(async () => {
+            await work();
+            const violations = await querier.all('PRAGMA foreign_key_check');
+            if (violations.length) {
+                const [{ table, parent }] = violations;
+                throw new UqlUsageError(`The migration leaves ${violations.length} row(s) referencing a missing one, the first in "${table}" pointing at "${parent}".`);
+            }
+        });
+    }
+    finally {
+        await querier.run('PRAGMA foreign_keys = ON');
+    }
+}
 const mongoSession = (querier) => ({
     querier,
     run: (statement) => runMongoCommand(querier.db, statement),

package/dist/migrate/migrator.d.ts

@@ -92,6 +92,11 @@ export declare class Migrator {
      * same columns, which may be the table renamed. That one is never renamed here: it may be another's.
      */
     private noteChanges;
+    /**
+     * Refuses, before anything runs, each column the changes require with no default while rows would hold
+     * none: every engine fails on one but MySQL, which fills in a zero. Counted, since an empty table is fine.
+     */
+    private assertFillable;
     /** The tables the database holds that no entity names, each paired with a new one it is identical to. */
     private renamedTables;
     /** The entities whose tables are among `created`. */
@@ -142,7 +147,8 @@ export declare class Migrator {
     /**
      * Safe mode only adds: a change with a `from` drops or rebuilds what the table holds, so it is held,
      * and so is a key whole, which rebuilds an index over every row and fails where a column holds a null.
-     * Without `drop`, a column's drop is held too.
+     * Without `drop`, a column's drop is held too. A rebuilt table applies its diff whole, so holding any
+     * part of it holds the rebuild, and only what an `ALTER` adds goes ahead: a plain column, an index.
      */
     protected filterDiff(diff: SchemaDiff, options: {
         safe?: boolean;

package/dist/migrate/migrator.js

@@ -7,10 +7,11 @@ import { columnRenames, tableRenameCandidates } from '../schema/schemaASTDiffer.
 import { hasTriggers } from '../util/field.util.js';
 import { LoggerWrapper } from '../util/index.js';
 import { UqlUsageError } from '../util/uqlError.js';
+import { withSqlQuerierForMigrations } from './acquireQuerierForMigrations.js';
 import { buildMigrationModule } from './codegen/migrationFile.js';
 import { introspectorFor } from './introspection/registry.js';
 import { migrationBuilderFor, migrationTargetFor } from './migrationTarget.js';
-import { dropped, nonEmpty, reverseDiff, sides } from './schemaChange.js';
+import { dropped, lacksValue, newlyRequired, nonEmpty, reverseDiff, sides, withoutRebuild } from './schemaChange.js';
 /**
  * Main class for managing database migrations
  */
@@ -185,6 +186,7 @@ export class Migrator {
     async generateFromEntities(name) {
         const generator = await this.getSchemaGenerator();
         const { created, altered } = await this.pendingChanges({ renames: true });
+        await this.assertFillable(altered);
         const plan = this.alterPlan(generator, altered, await this.installedTriggers(created));
         await this.noteChanges(generator, created, altered);
         const up = [...this.createSchema(generator, created), ...plan.up];
@@ -237,7 +239,7 @@ export class Migrator {
      */
     alterPlan(generator, altered, state) {
         const changing = new Set(altered
-            .filter((diff) => sides(diff.columns, 'from').length || diff.renamedColumns?.length)
+            .filter((diff) => sides(diff.columns, 'from').length || diff.renamedColumns?.length || diff.rebuild)
             .map((diff) => diff.tableName));
         const cleared = state.filter(({ entity }) => changing.has(this.tableOf(entity)));
         const after = state.map((it) => (cleared.includes(it) ? { entity: it.entity, installed: new Map() } : it));
@@ -290,6 +292,35 @@ export class Migrator {
                 `renamed, replace its creation in this migration with \`renameTable('${from}', '${to}')\`.`);
         }
     }
+    /**
+     * Refuses, before anything runs, each column the changes require with no default while rows would hold
+     * none: every engine fails on one but MySQL, which fills in a zero. Counted, since an empty table is fine.
+     */
+    async assertFillable(altered) {
+        // A renamed column is identical but for its name, so the one counted is never renamed too.
+        const counts = altered.flatMap(({ tableName, columns }) => newlyRequired(columns)
+            .filter(({ to }) => lacksValue(to))
+            .map(({ from, to }) => ({ tableName, column: to.name, nullable: from })));
+        if (!counts.length) {
+            return;
+        }
+        const unfilled = await withSqlQuerierForMigrations(this.pool, 'Migrator', async (querier) => {
+            const escapeId = (name) => querier.dialect.escapeId(name);
+            const found = [];
+            for (const { tableName, column, nullable } of counts) {
+                const empty = nullable ? ` WHERE ${escapeId(column)} IS NULL` : '';
+                const [{ rows }] = await querier.all(`SELECT COUNT(*) AS ${escapeId('rows')} FROM ${escapeId(tableName)}${empty}`);
+                const count = Number(rows);
+                if (count) {
+                    found.push(`"${tableName}"."${column}" is required with no default, and ${count} ${count === 1 ? 'row holds' : 'rows hold'} none`);
+                }
+            }
+            return found;
+        });
+        if (unfilled.length) {
+            throw new UqlUsageError(`${unfilled.join('; ')}. Declare a default, or add the column nullable, fill it, then require it.`);
+        }
+    }
     /** The tables the database holds that no entity names, each paired with a new one it is identical to. */
     async renamedTables(generator, created) {
         const createdEntities = this.createdEntities(created);
@@ -386,6 +417,7 @@ export class Migrator {
         const ast = await this.introspectEntities([entity, ...referencedEntities(meta)]);
         // The table is already there, so its triggers are reconciled rather than carried by a `CREATE`.
         const altered = this.alterFromEntity(generator, entity, ast.getTable(tableName), options);
+        await this.assertFillable(altered);
         return this.alterPlan(generator, altered, await this.installedTriggers([], [entity])).up;
     }
     /** The diff for one entity against the table it already has, and none where the two agree. */
@@ -418,6 +450,7 @@ export class Migrator {
         }
         const { created, altered } = await this.pendingChanges();
         const filtered = altered.map((diff) => this.filterDiff(diff, options));
+        await this.assertFillable(filtered);
         return [
             ...this.createSchema(generator, created),
             ...this.alterPlan(generator, filtered, await this.installedTriggers(created)).up,
@@ -442,12 +475,15 @@ export class Migrator {
     /**
      * Safe mode only adds: a change with a `from` drops or rebuilds what the table holds, so it is held,
      * and so is a key whole, which rebuilds an index over every row and fails where a column holds a null.
-     * Without `drop`, a column's drop is held too.
+     * Without `drop`, a column's drop is held too. A rebuilt table applies its diff whole, so holding any
+     * part of it holds the rebuild, and only what an `ALTER` adds goes ahead: a plain column, an index.
      */
     filterDiff(diff, options) {
         const safe = options.safe !== false;
+        let held = false;
         const skip = (what, names, fix) => {
             if (names.length) {
+                held = true;
                 this.logger.logSkippedMigration(`[AutoSync] Skipped ${names.length} ${what} in table '${diff.tableName}': ${names.join(', ')} (${fix}).`);
             }
         };
@@ -466,13 +502,18 @@ export class Migrator {
         if (!options.drop) {
             skip('column drops', dropped(columns).map((column) => column.name), 'drop: false. Use { drop: true } to apply');
         }
-        return {
+        const filtered = {
             ...diff,
             primaryKey: safe ? undefined : diff.primaryKey,
             columns: options.drop ? columns : nonEmpty((columns ?? []).filter((change) => change.to !== undefined)),
             indexes: additive('index', diff.indexes, (index) => index.name),
             foreignKeys: additive('foreign key', diff.foreignKeys, (foreignKey) => foreignKey.name ?? foreignKey.columns.join(', ')),
         };
+        if (!diff.rebuild || !held) {
+            return filtered;
+        }
+        skip('rebuild', [diff.tableName], 'it applies the whole diff, and part of it is held');
+        return withoutRebuild(filtered);
     }
     /** Runs the statements a generator wrote, in one transaction where the engine takes DDL in one. */
     async executeSyncStatements(statements, options) {
@@ -599,6 +640,8 @@ function referencedEntities(meta) {
     return [...fields, ...relations];
 }
 /** A diff's column renames, through the builder operation every SQL generator already renders. */
-function renameStatements(generator, { tableName, renamedColumns = [] }) {
-    return renamedColumns.flatMap(({ from, to }) => generator.generateOperation({ type: 'renameColumn', tableName, oldName: from, newName: to }));
+function renameStatements(generator, { tableName, renamedColumns = [], rebuild }) {
+    return rebuild
+        ? []
+        : renamedColumns.flatMap(({ from, to }) => generator.generateOperation({ type: 'renameColumn', tableName, oldName: from, newName: to }));
 }

package/dist/migrate/schemaChange.d.ts

@@ -1,4 +1,4 @@
-import type { Change, SchemaDiff } from '../type/index.js';
+import type { Change, ColumnSchema, SchemaDiff } from '../type/index.js';
 /** Each change's end on `side`, where it has one: what a drop half removes (`from`), or an add half creates (`to`). */
 export declare function sides<T>(changes: readonly Change<T>[] | undefined, side: 'from' | 'to'): T[];
 /** What the changes add: each `to` with no `from`. */
@@ -10,6 +10,17 @@ export declare function alterations<T>(changes?: readonly Change<T>[]): {
     readonly from: T;
     readonly to: T;
 }[];
+/** Each column `changes` make required on the rows already there: added so, or no longer nullable. */
+export declare function newlyRequired(changes?: readonly Change<ColumnSchema>[]): {
+    readonly from?: ColumnSchema;
+    readonly to: ColumnSchema;
+}[];
+/** Whether a row already in the table would hold nothing in `column`: required, with no default, and not one the engine fills. */
+export declare function lacksValue(column: ColumnSchema): boolean;
+/** Whether `diff` holds anything an engine that rebuilds tables makes no other way, a key or a foreign key included. */
+export declare function needsRebuild(diff: SchemaDiff): boolean;
+/** `diff` less its rebuild and everything only a rebuild makes: what an `ALTER` can still apply alone. */
+export declare function withoutRebuild(diff: SchemaDiff): SchemaDiff;
 /** `items`, or nothing where it has none, so an empty change list is left off a diff. */
 export declare function nonEmpty<T>(items: readonly T[]): readonly T[] | undefined;
 /** `change` undone: an add becomes a drop, a drop an add, and an alter runs the other way. */

package/dist/migrate/schemaChange.js

@@ -17,6 +17,32 @@ export function dropped(changes = []) {
 export function alterations(changes = []) {
     return changes.flatMap(({ from, to }) => (from === undefined || to === undefined ? [] : [{ from, to }]));
 }
+/** Each column `changes` make required on the rows already there: added so, or no longer nullable. */
+export function newlyRequired(changes = []) {
+    return changes.flatMap(({ from, to }) => (to && !to.nullable && (!from || from.nullable) ? [{ from, to }] : []));
+}
+/** Whether a row already in the table would hold nothing in `column`: required, with no default, and not one the engine fills. */
+export function lacksValue(column) {
+    return !column.nullable && column.defaultValue === undefined && !column.generatedAs && !column.isAutoIncrement;
+}
+/** Whether an engine that rebuilds tables makes `change` no other way: a column changed in place, or a stored generated one added. */
+function onlyRebuilt({ from, to }) {
+    return from === undefined ? Boolean(to?.generatedAs) : to !== undefined;
+}
+/** Whether `diff` holds anything an engine that rebuilds tables makes no other way, a key or a foreign key included. */
+export function needsRebuild(diff) {
+    return Boolean(diff.primaryKey || diff.foreignKeys || diff.columns?.some(onlyRebuilt));
+}
+/** `diff` less its rebuild and everything only a rebuild makes: what an `ALTER` can still apply alone. */
+export function withoutRebuild(diff) {
+    return {
+        ...diff,
+        primaryKey: undefined,
+        foreignKeys: undefined,
+        columns: nonEmpty((diff.columns ?? []).filter((change) => !onlyRebuilt(change))),
+        rebuild: undefined,
+    };
+}
 /** `items`, or nothing where it has none, so an empty change list is left off a diff. */
 export function nonEmpty(items) {
     return items.length ? items : undefined;
@@ -34,5 +60,6 @@ export function reverseDiff(diff) {
         indexes: diff.indexes?.map(swap),
         foreignKeys: diff.foreignKeys?.map(swap),
         renamedColumns: diff.renamedColumns?.map(({ from, to }) => ({ from: to, to: from })),
+        rebuild: diff.rebuild && { from: diff.rebuild.to, to: diff.rebuild.from },
     };
 }

package/dist/migrate/schemaGenerator.d.ts

@@ -75,6 +75,11 @@ export declare class SqlSchemaGenerator implements SchemaGenerator {
      * index along with its column, which would leave nothing to name. An alter is its drop, then its add.
      */
     generateAlterTable(diff: SchemaDiff): string[];
+    /**
+     * Each column the changes make required while declaring a default, and that default as SQL: the rows
+     * already there hold a null it has to replace, and it is the only value the entity says it may take.
+     */
+    private defaultFills;
     /** `ADD CONSTRAINT` for each of `foreignKeys`. */
     private addForeignKeyStatements;
     /** An index added to a table that may already have rows: its `CREATE`, then what the engine needs after. */
@@ -120,6 +125,12 @@ export declare class SqlSchemaGenerator implements SchemaGenerator {
      * drift detection runs, with types normalized as the engine stores them.
      */
     diffSchema(entity: Type<object>, currentTable: TableNode | undefined, desiredAst?: SchemaAST, renamedColumns?: readonly Rename[]): SchemaDiff | undefined;
+    /**
+     * Both ends of rebuilding `actual` as `desired`. The new table is the entity's, keeping what it cannot
+     * know of: the indexes and triggers uql did not make, and foreign keys to tables no entity names. The
+     * old one is the engine's own statements, so a rollback restores it exactly, checks included.
+     */
+    private rebuildOf;
     diffOptions(): DiffOptions;
     /** Spread, not copied field by field, so a field the node gains cannot go missing here. */
     private columnNodeToSchema;
@@ -172,12 +183,13 @@ export declare class SqlSchemaGenerator implements SchemaGenerator {
      * generator added it. MySQL takes no name.
      */
     generateDropPrimaryKeySql(tableName: string, constraintName?: string): string;
+    /** A stored generated column, which an engine that rebuilds tables takes only in a `CREATE TABLE`. */
+    private assertColumnAddable;
     /**
-     * A column an `ALTER` can carry. Only a generated one is ever refused, and only where the engine
-     * takes it in a `CREATE TABLE` but not afterwards.
+     * Refuses `what` where the engine makes it only by rebuilding the table, which a migration generated
+     * from the entities does and a lone statement of the builder cannot.
      */
-    private assertColumnAddable;
-    private assertPrimaryKeyAlterable;
+    private assertAlterable;
 }
 /**
  * The entities as an AST, named by `generator`'s resolvers rather than a naming strategy, which would

package/dist/migrate/schemaGenerator.js

@@ -6,14 +6,15 @@ import { diffRelationshipNodes, diffTable } from '../schema/schemaASTDiffer.js';
 import { isAutoIncrement, qualifyName } from '../util/index.js';
 import { derivedCheckName, derivedForeignKeyName, derivedPrimaryKeyName, isOwnedName } from '../util/sql.util.js';
 import { UqlUsageError } from '../util/uqlError.js';
-import { sameDefault } from './builder/expressions.js';
+import { formatDefaultValue, 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 { rebuildTable } from './ddl/tableRebuild.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 { added, alterations, dropped, needsRebuild, newlyRequired, nonEmpty, sides } from './schemaChange.js';
 import { dropTrigger, renderTrigger, stampTriggers } from './triggerSql.js';
 /**
  * Unified SQL schema generator.
@@ -92,7 +93,7 @@ export class SqlSchemaGenerator {
         const withForeignKeys = options.foreignKeys ?? true;
         // Inline only where a constraint cannot be added afterwards, which is what makes the cyclic case
         // work everywhere else.
-        const inline = withForeignKeys && !this.features.foreignKeyAlter;
+        const inline = withForeignKeys && this.features.rebuildsTables;
         // Namespaces first: a qualified `CREATE TABLE` fails against a schema nobody created, and the
         // schema is the one part of the layout a migration cannot infer from the table it is making.
         const statements = this.generateCreateSchemas(tables);
@@ -183,13 +184,21 @@ export class SqlSchemaGenerator {
      * index along with its column, which would leave nothing to name. An alter is its drop, then its add.
      */
     generateAlterTable(diff) {
-        const { tableName, schema, primaryKey } = diff;
-        const { columns } = diff;
+        const { tableName, schema, primaryKey, columns, rebuild } = diff;
+        const fills = this.defaultFills(columns);
+        if (rebuild) {
+            return rebuildTable(this.dialect, tableName, rebuild, { renames: diff.renamedColumns ?? [], fills });
+        }
+        const target = this.escapeId(tableName);
         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)),
+            ...[...fills].map(([column, value]) => {
+                const name = this.escapeId(column);
+                return `UPDATE ${target} SET ${name} = ${value} WHERE ${name} IS NULL;`;
+            }),
             ...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')),
@@ -197,6 +206,15 @@ export class SqlSchemaGenerator {
             ...this.addForeignKeyStatements(tableName, sides(diff.foreignKeys, 'to')),
         ];
     }
+    /**
+     * Each column the changes make required while declaring a default, and that default as SQL: the rows
+     * already there hold a null it has to replace, and it is the only value the entity says it may take.
+     */
+    defaultFills(columns) {
+        return new Map(newlyRequired(columns)
+            .filter(({ from, to }) => from && to.defaultValue !== undefined)
+            .map(({ to }) => [to.name, formatDefaultValue(to.defaultValue, this.dialect, to.type)]));
+    }
     /** `ADD CONSTRAINT` for each of `foreignKeys`. */
     addForeignKeyStatements(tableName, foreignKeys) {
         return foreignKeys.map((foreignKey) => this.generateAddForeignKeySql(tableName, foreignKey));
@@ -212,7 +230,7 @@ export class SqlSchemaGenerator {
     addColumnStatements(tableName, column, schema) {
         this.assertColumnAddable(tableName, column);
         return [
-            this.tableDdl.addColumn(tableName, this.generateColumnDefinitionFromSchema(column)),
+            ...this.tableDdl.addColumnStatements(tableName, column, (it) => this.generateColumnDefinitionFromSchema(it)),
             ...this.generateColumnCommentStatement(tableName, column, schema),
         ];
     }
@@ -339,11 +357,7 @@ export class SqlSchemaGenerator {
                 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 relationDiffs = diffRelationshipNodes(desired.outgoingRelations, currentTable.outgoingRelations, this.diffOptions());
         const foreignKeys = relationDiffs.map(({ actual, expected }) => ({
             from: actual && foreignKeyOf(actual),
             to: expected && foreignKeyOf(expected),
@@ -362,9 +376,38 @@ export class SqlSchemaGenerator {
             foreignKeys: nonEmpty(foreignKeys),
             renamedColumns: nonEmpty(renamedColumns ?? []),
         };
-        return alter.primaryKey || alter.columns || alter.indexes || alter.foreignKeys || alter.renamedColumns
-            ? alter
-            : undefined;
+        if (!(alter.primaryKey || alter.columns || alter.indexes || alter.foreignKeys || alter.renamedColumns)) {
+            return undefined;
+        }
+        return this.features.rebuildsTables && needsRebuild(alter)
+            ? { ...alter, rebuild: this.rebuildOf(desired, currentTable, indexes.kept, renamedColumns ?? []) }
+            : alter;
+    }
+    /**
+     * Both ends of rebuilding `actual` as `desired`. The new table is the entity's, keeping what it cannot
+     * know of: the indexes and triggers uql did not make, and foreign keys to tables no entity names. The
+     * old one is the engine's own statements, so a rollback restores it exactly, checks included.
+     */
+    rebuildOf(desired, actual, kept, renames) {
+        const definition = actual.definition ?? [];
+        const read = new Set(actual.indexes.map((index) => index.name));
+        const own = (entry) => entry.kind === 'trigger' && isOwnedName(entry.name);
+        const verbatim = (entries) => entries.map((entry) => `${entry.sql};`);
+        const stored = (table) => [...table.columns.values()].filter((column) => !column.generatedAs).map((column) => column.name);
+        return {
+            from: {
+                statements: verbatim(definition.filter((entry) => !own(entry))),
+                columns: stored(actual).map((name) => renames.find((rename) => rename.to === name)?.from ?? name),
+            },
+            to: {
+                statements: [
+                    ...this.generateCreateTableFromNode({ ...desired, externalForeignKeys: actual.externalForeignKeys }),
+                    ...kept.map((index) => this.generateCreateIndexFromNode(index)),
+                    ...verbatim(definition.filter((entry) => (entry.kind === 'index' && !read.has(entry.name)) || (entry.kind === 'trigger' && !own(entry)))),
+                ],
+                columns: stored(desired),
+            },
+        };
     }
     diffOptions() {
         return {
@@ -406,6 +449,9 @@ 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));
         }
+        for (const foreignKey of table.externalForeignKeys) {
+            constraints.push(this.foreignKeyConstraint(table.name, foreignKey, this.escapeId(foreignKey.references.table)));
+        }
         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');
@@ -497,9 +543,7 @@ export class SqlSchemaGenerator {
     }
     /** `ADD COLUMN`, plus the foreign key and index the column declares, as `CREATE TABLE` lifts them. */
     generateAddColumnSql(tableName, column) {
-        this.assertColumnAddable(tableName, column);
-        const colSql = this.generateColumnFromNode(fullColumnDefinitionToNode(column, tableName));
-        const statements = [this.tableDdl.addColumn(tableName, colSql)];
+        const statements = this.addColumnStatements(tableName, this.columnNodeToSchema(fullColumnDefinitionToNode(column, tableName)));
         const foreignKey = columnForeignKey(column);
         if (foreignKey) {
             statements.push(...this.addForeignKeyStatements(tableName, [foreignKey]));
@@ -508,10 +552,10 @@ export class SqlSchemaGenerator {
         if (index) {
             statements.push(this.generateCreateIndex(tableName, index));
         }
-        statements.push(...this.generateColumnCommentStatement(tableName, column));
         return statements;
     }
     generateAlterColumnSql(tableName, columnName, column) {
+        this.assertAlterable(`Altering the column "${columnName}" of "${tableName}"`);
         const node = fullColumnDefinitionToNode(column, tableName);
         return this.tableDdl.alterColumn(tableName, { ...this.columnNodeToSchema(node), name: columnName }, this.generateColumnFromNode(node));
     }
@@ -536,9 +580,7 @@ export class SqlSchemaGenerator {
             `ON UPDATE ${foreignKey.onUpdate ?? this.defaultForeignKeyAction}`);
     }
     generateAddForeignKeySql(tableName, foreignKey) {
-        if (!this.features.foreignKeyAlter) {
-            throw new UqlUsageError(`Dialect ${this.dialect} does not support adding foreign keys to existing tables`);
-        }
+        this.assertAlterable(`Adding a foreign key to "${tableName}"`);
         const constraint = this.foreignKeyConstraint(tableName, foreignKey, this.escapeId(foreignKey.references.table));
         return `ALTER TABLE ${this.escapeId(tableName)} ADD ${constraint};`;
     }
@@ -551,7 +593,7 @@ export class SqlSchemaGenerator {
      * rather than emitting DDL it will reject.
      */
     generateAddPrimaryKeySql(tableName, columns, name) {
-        this.assertPrimaryKeyAlterable(tableName);
+        this.assertAlterable(`Changing the primary key of "${tableName}"`);
         const constraintName = this.escapeId(name ?? derivedPrimaryKeyName(tableName, columns));
         const pkCols = columns.map((c) => this.escapeId(c)).join(', ');
         return `ALTER TABLE ${this.escapeId(tableName)} ADD CONSTRAINT ${constraintName} PRIMARY KEY (${pkCols});`;
@@ -561,7 +603,7 @@ export class SqlSchemaGenerator {
      * generator added it. MySQL takes no name.
      */
     generateDropPrimaryKeySql(tableName, constraintName) {
-        this.assertPrimaryKeyAlterable(tableName);
+        this.assertAlterable(`Changing the primary key of "${tableName}"`);
         const table = this.escapeId(tableName);
         if (this.dialect.dropPrimaryKeySyntax === 'DROP PRIMARY KEY') {
             return `ALTER TABLE ${table} DROP PRIMARY KEY;`;
@@ -572,24 +614,21 @@ export class SqlSchemaGenerator {
         }
         return `ALTER TABLE ${table} DROP CONSTRAINT ${this.escapeId(constraintName)};`;
     }
-    /**
-     * A column an `ALTER` can carry. Only a generated one is ever refused, and only where the engine
-     * takes it in a `CREATE TABLE` but not afterwards.
-     */
+    /** A stored generated column, which an engine that rebuilds tables takes only in a `CREATE TABLE`. */
     assertColumnAddable(tableName, column) {
-        if (!column.generatedAs || this.features.generatedColumnAdd) {
-            return;
+        if (column.generatedAs) {
+            this.assertAlterable(`Adding the stored column "${column.name}" to "${tableName}"`);
         }
-        throw new UqlUsageError(`${this.dialect}: Cannot add the computed column "${column.name}" to the existing table ` +
-            `"${tableName}" - this database only accepts one in a CREATE TABLE. Drop \`stored\` to have the ` +
-            'expression spliced into each statement instead, or recreate the table in a written migration.');
     }
-    assertPrimaryKeyAlterable(tableName) {
-        if (this.features.primaryKeyAlter) {
-            return;
+    /**
+     * Refuses `what` where the engine makes it only by rebuilding the table, which a migration generated
+     * from the entities does and a lone statement of the builder cannot.
+     */
+    assertAlterable(what) {
+        if (this.features.rebuildsTables) {
+            throw new UqlUsageError(`${this.dialect}: ${what} rebuilds the table, which a migration generated from the entities does ` +
+                '(`uql-migrate generate:entities`) and a hand-written one cannot.');
         }
-        throw new UqlUsageError(`${this.dialect}: Cannot change the primary key of "${tableName}" - this database has no ALTER ` +
-            'for it. Recreate the table in a written migration.');
     }
 }
 /**

package/dist/migrate/triggerSql.js

@@ -53,8 +53,9 @@ function triggerStatements(dialect, meta, trigger, name) {
     const table = dialect.escapedTableName(meta);
     const names = rowNames(dialect);
     const rows = [rowRefs(meta.entity, names.$new), rowRefs(meta.entity, names.$old)];
-    const sql = dialect.compileDdl(body(...rows), meta.entity, { rows: rowsFrom(dialect, meta, operation) });
-    const guard = triggerGuard(dialect, meta, trigger, rows, names);
+    const source = rowsFrom(dialect, meta, operation, trigger.of ?? []);
+    const sql = dialect.compileDdl(body(...rows), meta.entity, { rows: source });
+    const guard = triggerGuard(dialect, meta, trigger, rows, names, source);
     const inBody = features.guards !== 'clause';
     const guarded = !guard || !inBody
         ? sql
@@ -115,12 +116,16 @@ function triggerBody(dialect, meta, trigger, before) {
     }
     return body;
 }
-/** The one condition both guards reduce to: any watched column that moved, and whatever `where` asks. */
-function triggerGuard(dialect, meta, trigger, rows, names) {
+/**
+ * The one condition both guards reduce to: any watched column that moved, and whatever `where` asks. On a
+ * set-based engine a watched column narrows `source` already, so the guard asks whether it holds a row.
+ */
+function triggerGuard(dialect, meta, trigger, rows, names, source) {
     const moved = movedColumns(dialect, meta, trigger.of ?? [], names);
+    const watched = moved && (source ? `EXISTS (SELECT 1 ${source})` : moved);
     return [
-        ...(moved ? [moved] : []),
-        ...(trigger.where ? condition(dialect, meta, trigger.where, rows, names, Boolean(moved)) : []),
+        ...(watched ? [watched] : []),
+        ...(trigger.where ? condition(dialect, meta, trigger.where, rows, names, Boolean(watched)) : []),
     ].join(' AND ');
 }
 /** The PL/pgSQL function holding a body. `OR REPLACE`, since a dropped table leaves its function behind. */
@@ -210,7 +215,7 @@ function dollarQuote(body) {
 }
 /**
  * Whether any watched column moved, null-safely, or `undefined` where none is watched: the two records
- * compared on a row-based engine, and on a set-based one the same question over a join of its two tables.
+ * compared on a row-based engine, the two tables' rows on a set-based one.
  */
 function movedColumns(dialect, meta, of, { $new: newName, $old: oldName }) {
     if (!of.length) {
@@ -220,16 +225,15 @@ function movedColumns(dialect, meta, of, { $new: newName, $old: oldName }) {
         const column = dialect.escapedColumnName(meta, key);
         return dialect.neExpr(`${oldName}.${column}`, `${newName}.${column}`);
     });
-    const moved = differs.length > 1 ? `(${differs.join(' OR ')})` : differs.join('');
-    const source = rowsFrom(dialect, meta, 'UPDATE');
-    return source ? `EXISTS (SELECT 1 ${source} WHERE ${moved})` : moved;
+    return differs.length > 1 ? `(${differs.join(' OR ')})` : differs.join('');
 }
 /**
  * Where a set-based engine's body reads the rows it fires for, as the `FROM` a statement names them in:
- * `inserted` on an insert, `deleted` on a delete, and on an update both, joined on the whole key. None on a
- * row-based engine, whose body reads `NEW` and `OLD` bare.
+ * `inserted` on an insert, `deleted` on a delete, and on an update both, joined on the whole key and on a
+ * watched column having moved, so the body writes for those rows alone, as a per-row engine fires for them.
+ * None on a row-based engine, whose body reads `NEW` and `OLD` bare.
  */
-function rowsFrom(dialect, meta, operation) {
+function rowsFrom(dialect, meta, operation, of) {
     if (dialect.features.triggers.rows !== 'set') {
         return undefined;
     }
@@ -241,5 +245,6 @@ function rowsFrom(dialect, meta, operation) {
         const column = dialect.escapedColumnName(meta, id);
         return `${$new}.${column} = ${$old}.${column}`;
     });
-    return `FROM ${$new} JOIN ${$old} ON ${keyed.join(' AND ')}`;
+    const moved = movedColumns(dialect, meta, of, { $new, $old });
+    return `FROM ${$new} JOIN ${$old} ON ${[...keyed, ...(moved ? [moved] : [])].join(' AND ')}`;
 }

package/dist/mongo/mongoDialect.js

@@ -19,9 +19,7 @@ export const mongoDialectFeatures = {
     indexIfNotExists: false,
     schemas: false, // the connection picks the database, and a collection name takes no dot
     dropTableCascade: false,
-    foreignKeyAlter: false,
-    primaryKeyAlter: false,
-    generatedColumnAdd: false,
+    rebuildsTables: false,
     commentSyntax: 'none',
     vectorIndexRequiresNotNull: false,
     vectorSupportsLength: false,

package/dist/mssql/mssqlDialect.js

@@ -17,9 +17,7 @@ const MSSQL_FEATURES = {
     indexIfNotExists: true,
     schemas: true,
     dropTableCascade: false,
-    foreignKeyAlter: true,
-    primaryKeyAlter: true,
-    generatedColumnAdd: true,
+    rebuildsTables: false,
     // Extended properties are out-of-band metadata with their own procedures, not comments.
     commentSyntax: 'none',
     vectorIndexRequiresNotNull: false,

package/dist/schema/indexDifferences.d.ts

@@ -30,7 +30,7 @@ export declare function pairIndexes<S extends ComparableIndex, T extends Compara
 /**
  * The indexes a table lacks, the ones it no longer needs, and the ones to rebuild, differing in what
  * `facets` let the engine report. Only an unpaired index uql named, or whose name the entity claims, is
- * dropped: any other may have been made outside the ORM.
+ * dropped: any other may have been made outside the ORM, so it is `kept`.
  */
 export declare function indexChanges<I extends IndexSchema>(table: string, declared: readonly I[], current: readonly IndexNode[], facets: ReadonlySet<IndexFacet>): {
     toAdd: I[];
@@ -39,6 +39,7 @@ export declare function indexChanges<I extends IndexSchema>(table: string, decla
         from: IndexNode;
         to: I;
     }[];
+    kept: IndexNode[];
 };
 /**
  * What two indexes differ by, comparing only what both sides state structurally: an expression, a JSON

package/dist/schema/indexDifferences.js

@@ -38,7 +38,7 @@ export function pairIndexes(source, target, normalizeName = (name) => name) {
 /**
  * The indexes a table lacks, the ones it no longer needs, and the ones to rebuild, differing in what
  * `facets` let the engine report. Only an unpaired index uql named, or whose name the entity claims, is
- * dropped: any other may have been made outside the ORM.
+ * dropped: any other may have been made outside the ORM, so it is `kept`.
  */
 export function indexChanges(table, declared, current, facets) {
     const { created, dropped, matched } = pairIndexes(declared, current);
@@ -47,6 +47,7 @@ export function indexChanges(table, declared, current, facets) {
     return {
         toAdd: created,
         toDrop: dropped.filter(owned),
+        kept: dropped.filter((index) => !owned(index)),
         toAlter: matched.flatMap(([to, from]) => (describeIndexDifferences(to, from, facets).length ? [{ from, to }] : [])),
     };
 }

package/dist/schema/schemaAST.js

@@ -9,6 +9,7 @@ export function createTableNode(name, schema, indexFacets = new Set()) {
         columns: new Map(),
         indexes: [],
         checks: [],
+        externalForeignKeys: [],
         incomingRelations: [],
         outgoingRelations: [],
     };

package/dist/schema/types.d.ts

@@ -1,4 +1,4 @@
-import type { IndexSchema, PrimaryKeySchema } from '../type/migration.js';
+import type { ForeignKeySchema, IndexSchema, PrimaryKeySchema, StoredDefinition } from '../type/migration.js';
 import type { IndexFacet } from './indexDifferences.js';
 /**
  * Type categories universal across SQL dialects.
@@ -123,6 +123,10 @@ export interface TableNode {
     readonly checks: CheckSchema[];
     /** Optional table comment */
     readonly comment?: string;
+    /** The statements the engine keeps for the table, where it keeps them; none on a table built from entities. */
+    definition?: readonly StoredDefinition[];
+    /** The foreign keys to tables this AST does not hold, which a rebuild keeps as they are. */
+    readonly externalForeignKeys: ForeignKeySchema[];
     /** Relationships pointing TO this table (other tables referencing this one) */
     incomingRelations: RelationshipNode[];
     /** Relationships pointing FROM this table (this table referencing others) */

package/dist/sqlite/sqliteDialect.d.ts

@@ -13,7 +13,6 @@ export declare class SqliteDialect extends AbstractSqlDialect {
     readonly commitTransactionCommand = "COMMIT";
     readonly rollbackTransactionCommand = "ROLLBACK";
     readonly isolationLevelStrategy = "none";
-    readonly alterColumnSyntax = "none";
     readonly booleanLiteral = "integer";
     /** SQLite's own cap on a function call before 3.48, which libSQL and `bun:sqlite`'s build still have. */
     readonly maxFunctionArgs: number;

package/dist/sqlite/sqliteDialect.js

@@ -21,9 +21,7 @@ export const SQLITE_FEATURES = {
     indexIfNotExists: true,
     schemas: false, // SQLite's namespaces are attached database files, not declared objects
     dropTableCascade: false,
-    foreignKeyAlter: false, // SQLite does not support adding FKs to existing tables
-    primaryKeyAlter: false, // nor changing a key: the only route is rebuilding the table
-    generatedColumnAdd: false, // accepted in a CREATE TABLE, rejected in an ALTER
+    rebuildsTables: true,
     commentSyntax: 'none',
     vectorIndexRequiresNotNull: false,
     vectorSupportsLength: true,
@@ -62,7 +60,6 @@ export class SqliteDialect extends AbstractSqlDialect {
     commitTransactionCommand = 'COMMIT';
     rollbackTransactionCommand = 'ROLLBACK';
     isolationLevelStrategy = 'none';
-    alterColumnSyntax = 'none';
     booleanLiteral = 'integer';
     /** SQLite's own cap on a function call before 3.48, which libSQL and `bun:sqlite`'s build still have. */
     maxFunctionArgs = 127;

package/dist/type/dialect.d.ts

@@ -87,18 +87,12 @@ export interface DialectFeatures {
      */
     readonly schemas: boolean;
     readonly dropTableCascade: boolean;
-    readonly foreignKeyAlter: boolean;
     /**
-     * Whether a table's primary key can be changed on an existing table. False on SQLite, whose only
-     * route is rebuilding the table - so a migration that would change one is refused by name rather
-     * than emitting DDL the engine rejects.
+     * Whether the engine changes a column, a key or a foreign key, or adds a stored generated column, only
+     * by rebuilding the table, as SQLite does: a generated migration copies the table into a new one, and
+     * the migration builder refuses the change by name.
      */
-    readonly primaryKeyAlter: boolean;
-    /**
-     * Whether a stored generated column can be added to an existing table. SQLite takes one only in a
-     * `CREATE TABLE`, so a sync that would add one is refused by name.
-     */
-    readonly generatedColumnAdd: boolean;
+    readonly rebuildsTables: boolean;
     /** Where a comment goes: in the declaration (MySQL family), a `COMMENT ON` of its own (Postgres family), or nowhere. */
     readonly commentSyntax: 'inline' | 'statement' | 'none';
     /**

package/dist/type/migration.d.ts

@@ -122,7 +122,20 @@ export interface TableSchema {
     readonly primaryKey?: PrimaryKeySchema;
     readonly indexes?: IndexSchema[];
     readonly foreignKeys?: ForeignKeySchema[];
+    /** The statements the engine keeps for the table, where it keeps them: SQLite's `sqlite_master`. */
+    readonly definition?: readonly StoredDefinition[];
 }
+/** A statement exactly as the engine keeps it, which only it can say all of: a `CHECK`, an index over an expression. */
+export type StoredDefinition = {
+    readonly kind: 'table' | 'index' | 'trigger';
+    readonly name: string;
+    readonly sql: string;
+};
+/** One side of a rebuilt table: its `CREATE TABLE` and what goes back on it, and the columns holding stored values, under this side's names. */
+export type RebuiltTable = {
+    readonly statements: readonly string[];
+    readonly columns: readonly string[];
+};
 /**
  * Represents an index in a database table
  */
@@ -216,6 +229,14 @@ export interface SchemaDiff {
     readonly foreignKeys?: readonly Change<ForeignKeySchema>[];
     /** Columns renamed in place, `from` the database's name `to` the entity's, which the other changes already use. */
     readonly renamedColumns?: readonly Rename[];
+    /**
+     * The table copied into a new one, which is how an engine that {@link DialectFeatures.rebuildsTables}
+     * applies the changes above. Its column renames are carried by the copy.
+     */
+    readonly rebuild?: {
+        readonly from: RebuiltTable;
+        readonly to: RebuiltTable;
+    };
 }
 /**
  * What every sync entry point takes: `safe` keeps it additive, `drop` lets it remove a column, and

package/package.json

@@ -3,7 +3,7 @@
   "homepage": "https://uql-orm.dev",
   "description": "JSON-native TypeScript ORM for Bun, Browsers, Edge, Deno, Node, Workers. Supports PostgreSQL, PGlite, MySQL, MariaDB, SQLite, CockroachDB, SQL Server, Turso, Neon, Cloudflare D1 and MongoDB. Queries are plain JSON, typed to the leaf.",
   "license": "MIT",
-  "version": "0.87.0",
+  "version": "0.88.0",
   "type": "module",
   "engines": {
     "node": ">=24"

package/skills/uql-orm/SKILL.md

@@ -154,7 +154,7 @@ transaction. A querier from `pool.getQuerier()` is yours to release: bind it wit
 ## Migrations
 
 `npx uql-migrate` reads `uql.config.ts`. `sync` creates what the entities imply (development only);
-`generate:entities` writes the diff as a migration file to review, renaming a column its field was renamed from and printing `renameTable` for a table that may have been; `up` applies migrations; `generate:from-db`
+`generate:entities` writes the diff as a migration file to review, renaming a column its field was renamed from, printing `renameTable` for a table that may have been, rebuilding a SQLite table for what it cannot alter, and refusing a required column with no default on a table holding rows; `up` applies migrations; `generate:from-db`
 writes entity classes from an existing database; `drift:check` fails when the database no longer matches.
 Triggers are part of the diff: uql installs its own under `_uql_`-prefixed names and never touches another.