uql-orm 0.52.0 → 0.53.0

package/dist/migrate/ddl/mssqlTableDdl.js

@@ -0,0 +1,61 @@
+import { escapeSingleQuotes } from '../../util/sqlLiteral.js';
+import { sizedType, TableDdl } from './tableDdl.js';
+/** The constraints of each kind on column `c`, the `sys.columns` row {@link MsSqlTableDdl} reads. */
+const CONSTRAINTS_ON = {
+    default: /*sql*/ `SELECT d.name FROM sys.default_constraints d
+    WHERE d.parent_object_id = c.object_id AND d.parent_column_id = c.column_id`,
+    check: /*sql*/ `SELECT k.name FROM sys.check_constraints k
+    WHERE k.parent_object_id = c.object_id AND k.parent_column_id = c.column_id`,
+    unique: /*sql*/ `SELECT u.name FROM sys.key_constraints u
+    JOIN sys.index_columns ic ON ic.object_id = u.parent_object_id AND ic.index_id = u.unique_index_id
+    WHERE u.parent_object_id = c.object_id AND u.type = 'UQ' AND ic.column_id = c.column_id`,
+};
+/**
+ * SQL Server keeps a column's `DEFAULT`, `CHECK` and `UNIQUE` as constraints under names it picks, and
+ * refuses to drop or retype the column past one, so they go first - looked up by column, as no two
+ * databases name them alike. Renames are `sp_rename`, T-SQL having no `RENAME` clause.
+ */
+export class MsSqlTableDdl extends TableDdl {
+    /** T-SQL rejects the optional `COLUMN` keyword after `ADD`. */
+    addColumn(table, definition) {
+        return /*sql*/ `ALTER TABLE ${this.dialect.escapeId(table)} ADD ${definition};`;
+    }
+    /** Its constraints go with the column, as they do on every other engine. */
+    dropColumn(table, column) {
+        return [this.dropConstraints(table, column, Object.values(CONSTRAINTS_ON)), ...super.dropColumn(table, column)];
+    }
+    /**
+     * `ALTER COLUMN` takes the type and nullability alone, so the default is dropped and added back as a
+     * constraint of its own. A `CHECK` or `UNIQUE` stays, and the server refuses a retype it blocks.
+     */
+    alterColumn(table, column) {
+        const target = this.dialect.escapeId(table);
+        const name = this.dialect.escapeId(column.name);
+        const statements = [
+            this.dropConstraints(table, column.name, [CONSTRAINTS_ON.default]),
+            /*sql*/ `ALTER TABLE ${target} ALTER COLUMN ${name} ${sizedType(column)} ${column.nullable ? 'NULL' : 'NOT NULL'};`,
+        ];
+        if (column.defaultValue !== undefined) {
+            statements.push(/*sql*/ `ALTER TABLE ${target} ADD${this.defaultClause(column)} FOR ${name};`);
+        }
+        return statements;
+    }
+    renameColumn(table, oldName, newName) {
+        const qualified = `${this.dialect.escapeId(table)}.${this.dialect.escapeId(oldName)}`;
+        return /*sql*/ `EXEC sp_rename ${this.dialect.escape(qualified)}, ${this.dialect.escape(newName)}, 'COLUMN';`;
+    }
+    renameTable(oldName, newName) {
+        return /*sql*/ `EXEC sp_rename ${this.dialect.escape(this.dialect.escapeId(oldName))}, ${this.dialect.escape(newName)};`;
+    }
+    storedGeneratedColumn(_type, expression) {
+        return /*sql*/ `AS (${expression}) PERSISTED`;
+    }
+    /** One statement, so a split on `;` cannot part the lookup from the `EXEC` it feeds. */
+    dropConstraints(table, column, kinds) {
+        const target = this.dialect.escapeId(table);
+        return (`DECLARE @drop nvarchar(max) = (SELECT STRING_AGG(N'ALTER TABLE ${escapeSingleQuotes(target)} DROP CONSTRAINT ' ` +
+            `+ QUOTENAME(pinned.name), N'; ') FROM sys.columns c CROSS APPLY (${kinds.join(' UNION ALL ')}) pinned ` +
+            `WHERE c.object_id = OBJECT_ID(${this.dialect.escape(target)}) AND c.name = ${this.dialect.escape(column)}) ` +
+            'EXEC (@drop);');
+    }
+}

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

@@ -0,0 +1,34 @@
+import type { AbstractSqlDialect } from '../../dialect/abstractSqlDialect.js';
+import type { ColumnSchema } from '../../type/index.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.
+ */
+export declare function sizedType(column: Pick<ColumnSchema, 'type' | 'length' | 'precision' | 'scale'>): string;
+/**
+ * The `ALTER TABLE` statements an engine spells its own way: the migrator's, for the reason
+ * {@link IndexDdl} is. The form here is the portable one; SQL Server's is {@link MsSqlTableDdl}.
+ */
+export declare class TableDdl {
+    protected readonly dialect: AbstractSqlDialect;
+    constructor(dialect: AbstractSqlDialect);
+    addColumn(table: string, definition: string): string;
+    dropColumn(table: string, column: string): string[];
+    /**
+     * What changes `column` to what it now declares. `definition` is the whole column, which MySQL's
+     * `MODIFY COLUMN` restates; Postgres takes each change as a clause of its own.
+     */
+    alterColumn(table: string, column: ColumnSchema, definition: string): string[];
+    renameColumn(table: string, oldName: string, newName: string): string;
+    renameTable(oldName: string, newName: string): string;
+    /** A stored generated column's type, with the clause computing it. */
+    storedGeneratedColumn(type: string, expression: string): string;
+    /**
+     * ` DEFAULT <sql>`, or nothing where the column declares none. Empty rather than `DEFAULT NULL`, so
+     * an absent default stays absent - `defaultValue: null` is the way to ask for one.
+     */
+    defaultClause(column: {
+        readonly defaultValue?: unknown;
+        readonly type: string;
+    }): string;
+}

package/dist/migrate/ddl/tableDdl.js

@@ -0,0 +1,71 @@
+import { formatDefaultValue } from '../builder/expressions.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.
+ */
+export function sizedType(column) {
+    if (column.type.includes('(')) {
+        return column.type;
+    }
+    if (column.precision !== undefined) {
+        const size = column.scale === undefined ? column.precision : `${column.precision}, ${column.scale}`;
+        return `${column.type}(${size})`;
+    }
+    return column.length === undefined ? column.type : `${column.type}(${column.length})`;
+}
+/**
+ * The `ALTER TABLE` statements an engine spells its own way: the migrator's, for the reason
+ * {@link IndexDdl} is. The form here is the portable one; SQL Server's is {@link MsSqlTableDdl}.
+ */
+export class TableDdl {
+    dialect;
+    constructor(dialect) {
+        this.dialect = dialect;
+    }
+    addColumn(table, definition) {
+        return `ALTER TABLE ${this.dialect.escapeId(table)} ADD COLUMN ${definition};`;
+    }
+    dropColumn(table, column) {
+        return [`ALTER TABLE ${this.dialect.escapeId(table)} DROP COLUMN ${this.dialect.escapeId(column)};`];
+    }
+    /**
+     * What changes `column` to what it now declares. `definition` is the whole column, which MySQL's
+     * `MODIFY COLUMN` restates; Postgres takes each change as a clause of its own.
+     */
+    alterColumn(table, column, definition) {
+        if (this.dialect.alterColumnSyntax === 'none') {
+            throw new TypeError(`${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};`];
+        }
+        const alter = `ALTER TABLE ${target} ALTER COLUMN ${this.dialect.escapeId(column.name)}`;
+        return [
+            `${alter} TYPE ${column.type};`,
+            `${alter} ${column.nullable ? 'DROP NOT NULL' : 'SET NOT NULL'};`,
+            column.defaultValue === undefined ? `${alter} DROP DEFAULT;` : `${alter} SET${this.defaultClause(column)};`,
+        ];
+    }
+    renameColumn(table, oldName, newName) {
+        const [target, from, to] = [table, oldName, newName].map((name) => this.dialect.escapeId(name));
+        return `ALTER TABLE ${target} RENAME COLUMN ${from} TO ${to};`;
+    }
+    renameTable(oldName, newName) {
+        return `ALTER TABLE ${this.dialect.escapeId(oldName)} RENAME TO ${this.dialect.escapeId(newName)};`;
+    }
+    /** A stored generated column's type, with the clause computing it. */
+    storedGeneratedColumn(type, expression) {
+        return `${type} GENERATED ALWAYS AS (${expression}) STORED`;
+    }
+    /**
+     * ` DEFAULT <sql>`, or nothing where the column declares none. Empty rather than `DEFAULT NULL`, so
+     * an absent default stays absent - `defaultValue: null` is the way to ask for one.
+     */
+    defaultClause(column) {
+        return column.defaultValue === undefined
+            ? ''
+            : ` DEFAULT ${formatDefaultValue(column.defaultValue, this.dialect, column.type)}`;
+    }
+}

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

@@ -16,21 +16,16 @@ export declare class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospect
         count?: number;
     }[]): boolean;
     /**
-     * `is_identity` and the default come from `sys`, not `INFORMATION_SCHEMA`: the latter has no
-     * identity flag, and reports a default already wrapped in the parentheses the engine reprints it
-     * with, which is the same text either way but only nameable as a constraint through `sys`.
+     * From `sys` rather than `INFORMATION_SCHEMA`, which has no identity flag and no per-column view of
+     * the key or of a unique index. A key column is not also `isUnique`, as on MySQL: only a unique index
+     * of its own, other than the key's, makes it so.
      */
     protected getColumnsQuery(_tableName: string): string;
     /** `is_primary_key` is excluded: the key is read separately, the way every other engine reads it. */
     protected getIndexesQuery(_tableName: string): string;
     protected getForeignKeysQuery(_tableName: string): string;
     protected getPrimaryKeyQuery(_tableName: string): string;
-    /**
-     * `max_length` is in bytes, so an `NVARCHAR` column reports twice its declared length and `MAX`
-     * reports `-1`. Read as characters, every Unicode column would drift to double its width the first
-     * time it was diffed against the entity that declared it.
-     */
-    protected mapColumnsResult(read: TableRowReader, tableName: string, results: MsSqlColumnRow[]): Promise<ColumnSchema[]>;
+    protected mapColumnsResult(_read: TableRowReader, _tableName: string, results: MsSqlColumnRow[]): Promise<ColumnSchema[]>;
     protected mapIndexesResult(_read: TableRowReader, _tableName: string, results: {
         index_name: string;
         columns: string;
@@ -59,5 +54,7 @@ type MsSqlColumnRow = {
     is_nullable: boolean;
     is_identity: boolean;
     column_default: string | null;
+    is_primary_key: number | null;
+    is_unique: number | null;
 };
 export {};

package/dist/migrate/introspection/mssqlIntrospector.js

@@ -30,9 +30,9 @@ export class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         return (this.toNumber(results[0]?.count) ?? 0) > 0;
     }
     /**
-     * `is_identity` and the default come from `sys`, not `INFORMATION_SCHEMA`: the latter has no
-     * identity flag, and reports a default already wrapped in the parentheses the engine reprints it
-     * with, which is the same text either way but only nameable as a constraint through `sys`.
+     * From `sys` rather than `INFORMATION_SCHEMA`, which has no identity flag and no per-column view of
+     * the key or of a unique index. A key column is not also `isUnique`, as on MySQL: only a unique index
+     * of its own, other than the key's, makes it so.
      */
     getColumnsQuery(_tableName) {
         return /*sql*/ `
@@ -44,12 +44,27 @@ export class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         c.scale as numeric_scale,
         c.is_nullable as is_nullable,
         c.is_identity as is_identity,
-        d.definition as column_default
+        d.definition as column_default,
+        f.is_primary_key,
+        f.is_unique
       FROM sys.columns c
       JOIN sys.objects o ON o.object_id = c.object_id
       JOIN sys.schemas s ON s.schema_id = o.schema_id
       JOIN sys.types t ON t.user_type_id = c.user_type_id
       LEFT JOIN sys.default_constraints d ON d.object_id = c.default_object_id
+      OUTER APPLY (
+        SELECT
+          MAX(CAST(i.is_primary_key AS INT)) as is_primary_key,
+          MAX(CASE WHEN i.is_primary_key = 0 AND n.key_columns = 1 THEN 1 ELSE 0 END) as is_unique
+        FROM sys.index_columns ic
+        JOIN sys.indexes i ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+        CROSS APPLY (
+          SELECT COUNT(*) as key_columns FROM sys.index_columns k
+          WHERE k.object_id = i.object_id AND k.index_id = i.index_id AND k.is_included_column = 0
+        ) n
+        WHERE ic.object_id = c.object_id AND ic.column_id = c.column_id
+          AND ic.is_included_column = 0 AND i.is_unique = 1
+      ) f
       WHERE s.name = ${this.schemaExpr} AND o.name = @p1
       ORDER BY c.column_id
     `;
@@ -105,44 +120,19 @@ export class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
       ORDER BY ic.key_ordinal
     `;
     }
-    /**
-     * `max_length` is in bytes, so an `NVARCHAR` column reports twice its declared length and `MAX`
-     * reports `-1`. Read as characters, every Unicode column would drift to double its width the first
-     * time it was diffed against the entity that declared it.
-     */
-    async mapColumnsResult(read, tableName, results) {
-        // One extra statement for both flags, and the reader sends it once: a column is in the key or
-        // uniquely indexed on its own, and `sys` is the only place either is readable per column.
-        const flags = await read(
-        /*sql*/ `
-      SELECT c.name as column_name, MAX(CAST(i.is_primary_key AS INT)) as is_primary_key
-      FROM sys.indexes i
-      JOIN sys.objects o ON o.object_id = i.object_id
-      JOIN sys.schemas s ON s.schema_id = o.schema_id
-      JOIN sys.index_columns ic ON ic.object_id = i.object_id AND ic.index_id = i.index_id
-      JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
-      WHERE s.name = ${this.schemaExpr} AND o.name = @p1
-        AND i.is_unique = 1 AND ic.is_included_column = 0
-        AND (SELECT COUNT(*) FROM sys.index_columns k
-             WHERE k.object_id = i.object_id AND k.index_id = i.index_id AND k.is_included_column = 0) = 1
-      GROUP BY c.name
-    `, [tableName]);
-        const unique = new Set(flags.map((row) => row.column_name));
-        const keys = new Set(flags.filter((row) => Boolean(row.is_primary_key)).map((row) => row.column_name));
+    async mapColumnsResult(_read, _tableName, results) {
         return results.map((row) => {
             const type = row.data_type.toUpperCase();
-            const wide = type.startsWith('N');
             const bytes = this.toNumber(row.max_length);
-            const length = bytes === undefined || bytes < 0 || !CHARACTER_TYPES.has(type) ? undefined : wide ? bytes / 2 : bytes;
             return {
                 name: row.column_name,
                 type: bytes === -1 && CHARACTER_TYPES.has(type) ? `${type}(MAX)` : type,
                 nullable: Boolean(row.is_nullable),
                 defaultValue: this.parseDefaultValue(row.column_default),
                 isAutoIncrement: Boolean(row.is_identity),
-                isPrimaryKey: keys.has(row.column_name),
-                isUnique: unique.has(row.column_name),
-                length,
+                isPrimaryKey: Boolean(row.is_primary_key),
+                isUnique: Boolean(row.is_unique),
+                length: widthOf(type, bytes),
                 precision: NUMERIC_TYPES.has(type) ? this.toNumber(row.numeric_precision) : undefined,
                 scale: NUMERIC_TYPES.has(type) ? this.toNumber(row.numeric_scale) : undefined,
             };
@@ -196,3 +186,20 @@ export class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
 /** The types whose `max_length` is a width rather than a fixed storage size. */
 const CHARACTER_TYPES = new Set(['CHAR', 'NCHAR', 'VARCHAR', 'NVARCHAR', 'BINARY', 'VARBINARY']);
 const NUMERIC_TYPES = new Set(['DECIMAL', 'NUMERIC']);
+/**
+ * A column's declared width from `max_length`, which is bytes: an `N` type holds two a character, a
+ * `VECTOR` is an 8-byte header and four a dimension, and `MAX` is `-1`. Read as bytes, every Unicode
+ * column would drift to double its width against the entity that declared it.
+ */
+function widthOf(type, bytes) {
+    if (bytes === undefined || bytes < 0) {
+        return undefined;
+    }
+    if (type === 'VECTOR') {
+        return (bytes - 8) / 4;
+    }
+    if (!CHARACTER_TYPES.has(type)) {
+        return undefined;
+    }
+    return type.startsWith('N') ? bytes / 2 : bytes;
+}

package/dist/migrate/schemaGenerator.d.ts

@@ -4,7 +4,7 @@ import { type DiffOptions } from '../schema/schemaASTDiffer.js';
 import type { CanonicalType, ColumnNode, ForeignKeyAction, IndexNode, TableNode } from '../schema/types.js';
 import type { ColumnSchema, CreateSchemaOptions, DialectFeatures, DropSchemaOptions, EntityMeta, FieldMeta, FieldOptions, ForeignKeySchema, IndexSchema, NamingStrategy, SchemaDiff, SchemaGenerator, SqlDdlGenerator, Type } from '../type/index.js';
 import type { FullColumnDefinition, TableDefinition } from './builder/types.js';
-import { type IndexDdl } from './ddl/index.js';
+import { type IndexDdl, type TableDdl } from './ddl/index.js';
 /**
  * Unified SQL schema generator.
  * Parameterized by dialect to handle Postgres, MySQL, MariaDB, and SQLite.
@@ -14,6 +14,8 @@ export declare class SqlSchemaGenerator implements SqlDdlGenerator {
     protected readonly defaultForeignKeyAction: ForeignKeyAction;
     /** `CREATE INDEX` for this dialect: the migrator's, so a runtime import carries none of it. */
     protected readonly indexDdl: IndexDdl;
+    /** The `ALTER TABLE` statements this dialect spells its own way, the migrator's for the same reason. */
+    protected readonly tableDdl: TableDdl;
     constructor(dialect: AbstractSqlDialect, defaultForeignKeyAction?: ForeignKeyAction);
     get namingStrategy(): NamingStrategy | undefined;
     get features(): DialectFeatures;
@@ -97,18 +99,14 @@ export declare class SqlSchemaGenerator implements SqlDdlGenerator {
      */
     generateColumnDefinitionFromSchema(column: ColumnSchema): string;
     /**
-     * The one place a column definition is spelled. Both callers reach it - the `ColumnSchema` path above
-     * and the `ColumnNode` path below - because the clause order and the "no NOT NULL on a primary key"
-     * rules are the same everywhere, and having them written twice is how the two paths drifted.
+     * 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.
      */
     private renderColumn;
-    /** ` DEFAULT <sql>`, or nothing where the column declares none. Empty rather than `DEFAULT NULL`
-     * so an absent default stays absent - `defaultValue: null` is the way to ask for one. */
-    private defaultClause;
     getSqlType(field: FieldMeta): string;
-    /**
-     * Generate ALTER COLUMN statements (database-specific)
-     */
+    /** The statements that alter `column` in place, as this dialect spells them. */
     generateAlterColumnStatements(tableName: string, column: ColumnSchema, newDefinition: string): string[];
     /** The inline ` COMMENT '...'` a column declaration carries, where the engine takes one there. */
     generateColumnComment(comment: string): string;

package/dist/migrate/schemaGenerator.js

@@ -4,10 +4,11 @@ import { areTypesEqual, canonicalToSql, engineType, fieldOptionsToCanonical, isV
 import { indexSignature } from '../schema/indexDifferences.js';
 import { buildSchemaAST } from '../schema/schemaASTBuilder.js';
 import { diffRelationshipNodes, diffTable } from '../schema/schemaASTDiffer.js';
-import { getKeys, isAutoIncrement, isSoleIdField, qualifyName } from '../util/index.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 { indexDdlFor } from './ddl/index.js';
+import { indexDdlFor, tableDdlFor } from './ddl/index.js';
+import { sizedType } from './ddl/tableDdl.js';
 import { columnForeignKey, columnIndex, fullColumnDefinitionToNode, tableDefinitionToNode, } from './generator/definitionToNode.js';
 import { indexNodeToSchema } from './generator/indexNodeToSchema.js';
 /**
@@ -19,10 +20,13 @@ export class SqlSchemaGenerator {
     defaultForeignKeyAction;
     /** `CREATE INDEX` for this dialect: the migrator's, so a runtime import carries none of it. */
     indexDdl;
+    /** The `ALTER TABLE` statements this dialect spells its own way, the migrator's for the same reason. */
+    tableDdl;
     constructor(dialect, defaultForeignKeyAction = 'NO ACTION') {
         this.dialect = dialect;
         this.defaultForeignKeyAction = defaultForeignKeyAction;
         this.indexDdl = indexDdlFor(dialect);
+        this.tableDdl = tableDdlFor(dialect);
     }
     get namingStrategy() {
         return this.dialect.namingStrategy;
@@ -138,7 +142,6 @@ export class SqlSchemaGenerator {
     }
     generateAlterTable(diff) {
         const statements = [];
-        const tableName = this.escapeId(diff.tableName);
         // 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) {
@@ -154,7 +157,7 @@ export class SqlSchemaGenerator {
         if (diff.columnsToAdd?.length) {
             for (const column of diff.columnsToAdd) {
                 this.assertColumnAddable(diff.tableName, column);
-                statements.push(`ALTER TABLE ${tableName} ADD COLUMN ${this.generateColumnDefinitionFromSchema(column)};`);
+                statements.push(this.tableDdl.addColumn(diff.tableName, this.generateColumnDefinitionFromSchema(column)));
                 statements.push(...this.generateColumnCommentStatement(diff.tableName, column, diff.schema));
             }
         }
@@ -169,7 +172,7 @@ export class SqlSchemaGenerator {
         // Drop columns
         if (diff.columnsToDrop?.length) {
             for (const columnName of diff.columnsToDrop) {
-                statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${this.escapeId(columnName)};`);
+                statements.push(...this.tableDdl.dropColumn(diff.tableName, columnName));
             }
         }
         // Add indexes
@@ -206,7 +209,6 @@ export class SqlSchemaGenerator {
     }
     generateAlterTableDown(diff) {
         const statements = [];
-        const tableName = this.escapeId(diff.tableName);
         // 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, [
@@ -222,7 +224,7 @@ export class SqlSchemaGenerator {
         // Reverse column additions by dropping them
         if (diff.columnsToAdd?.length) {
             for (const column of diff.columnsToAdd) {
-                statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${this.escapeId(column.name)};`);
+                statements.push(...this.tableDdl.dropColumn(diff.tableName, column.name));
             }
         }
         // Reverse column alterations by restoring original schema
@@ -273,53 +275,35 @@ export class SqlSchemaGenerator {
      * {@link renderColumn}, which is the part that must not be written twice.
      */
     generateColumnDefinitionFromSchema(column) {
-        let type = column.type;
-        if (!type.includes('(')) {
-            if (column.precision !== undefined) {
-                type += column.scale === undefined ? `(${column.precision})` : `(${column.precision}, ${column.scale})`;
-            }
-            else if (column.length !== undefined) {
-                type += `(${column.length})`;
-            }
-        }
-        return this.renderColumn({ ...column, type });
+        return this.renderColumn({ ...column, type: sizedType(column) });
     }
     /**
-     * The one place a column definition is spelled. Both callers reach it - the `ColumnSchema` path above
-     * and the `ColumnNode` path below - because the clause order and the "no NOT NULL on a primary key"
-     * rules are the same everywhere, and having them written twice is how the two paths drifted.
+     * 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.
      */
     renderColumn(column) {
-        let def = `${this.escapeId(column.name)} ${column.type}`;
-        // Before the constraints, which every engine here accepts and is where each documents it. The
-        // clause takes the place of a `DEFAULT`, which is mutually exclusive with it; everything else -
-        // `NOT NULL`, `UNIQUE`, an enum `CHECK`, a comment - a generated column carries like any other.
-        if (column.generatedAs) {
-            def += ` GENERATED ALWAYS AS (${column.generatedAs}) STORED`;
-        }
-        if (!column.nullable && !column.isPrimaryKey) {
+        const type = column.generatedAs
+            ? this.tableDdl.storedGeneratedColumn(column.type, column.generatedAs)
+            : column.type;
+        let def = `${this.escapeId(column.name)} ${type}`;
+        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);
+        }
         if (column.enum?.length) {
             const values = column.enum.map((value) => this.dialect.escape(value)).join(', ');
             def += ` CHECK (${this.escapeId(column.name)} IN (${values}))`;
         }
-        def += this.defaultClause(column);
-        if (column.comment) {
-            def += this.generateColumnComment(column.comment);
-        }
         return def;
     }
-    /** ` DEFAULT <sql>`, or nothing where the column declares none. Empty rather than `DEFAULT NULL`
-     * so an absent default stays absent - `defaultValue: null` is the way to ask for one. */
-    defaultClause(column) {
-        return column.defaultValue === undefined
-            ? ''
-            : ` DEFAULT ${formatDefaultValue(column.defaultValue, this.dialect, column.type)}`;
-    }
     getSqlType(field) {
         // A foreign key takes the type of the key it points at. A `referencedKey` the target does not
         // have falls through to this column's own options, as the AST builder does with the same case.
@@ -338,35 +322,9 @@ export class SqlSchemaGenerator {
         }
         return this.canonicalTypeToSql(canonical);
     }
-    /**
-     * Generate ALTER COLUMN statements (database-specific)
-     */
+    /** The statements that alter `column` in place, as this dialect spells them. */
     generateAlterColumnStatements(tableName, column, newDefinition) {
-        const table = this.escapeId(tableName);
-        const colName = this.escapeId(column.name);
-        if (this.dialect.alterColumnSyntax === 'none') {
-            throw new TypeError(`${this.dialect}: Cannot alter column "${column.name}" - you must recreate the table. ` +
-                `This database does not support ALTER COLUMN.`);
-        }
-        if (this.dialect.alterColumnStrategy === 'separate-clauses') {
-            const statements = [];
-            // Separate ALTER COLUMN clauses for different changes (Postgres)
-            statements.push(`ALTER TABLE ${table} ALTER COLUMN ${colName} TYPE ${column.type};`);
-            if (column.nullable) {
-                statements.push(`ALTER TABLE ${table} ALTER COLUMN ${colName} DROP NOT NULL;`);
-            }
-            else {
-                statements.push(`ALTER TABLE ${table} ALTER COLUMN ${colName} SET NOT NULL;`);
-            }
-            if (column.defaultValue !== undefined) {
-                statements.push(`ALTER TABLE ${table} ALTER COLUMN ${colName} SET${this.defaultClause(column)};`);
-            }
-            else {
-                statements.push(`ALTER TABLE ${table} ALTER COLUMN ${colName} DROP DEFAULT;`);
-            }
-            return statements;
-        }
-        return [`ALTER TABLE ${table} ${this.dialect.alterColumnSyntax} ${newDefinition};`];
+        return this.tableDdl.alterColumn(tableName, column, newDefinition);
     }
     /** The inline ` COMMENT '...'` a column declaration carries, where the engine takes one there. */
     generateColumnComment(comment) {
@@ -627,10 +585,7 @@ export class SqlSchemaGenerator {
         return this.generateCreateTableFromNode(tableNode, options);
     }
     generateRenameTableSql(oldName, newName) {
-        if (this.dialect.renameTableSyntax === 'rename-table') {
-            return `RENAME TABLE ${this.escapeId(oldName)} TO ${this.escapeId(newName)};`;
-        }
-        return `ALTER TABLE ${this.escapeId(oldName)} RENAME TO ${this.escapeId(newName)};`;
+        return this.tableDdl.renameTable(oldName, newName);
     }
     /**
      * `ADD COLUMN`, plus the constraint and index the column declares.
@@ -643,7 +598,7 @@ export class SqlSchemaGenerator {
     generateAddColumnSql(tableName, column) {
         this.assertColumnAddable(tableName, column);
         const colSql = this.generateColumnFromNode(fullColumnDefinitionToNode(column, tableName));
-        const statements = [`ALTER TABLE ${this.escapeId(tableName)} ADD COLUMN ${colSql};`];
+        const statements = [this.tableDdl.addColumn(tableName, colSql)];
         const foreignKey = columnForeignKey(column);
         if (foreignKey) {
             statements.push(...this.addForeignKeyStatements(tableName, [foreignKey]));
@@ -660,10 +615,10 @@ export class SqlSchemaGenerator {
         return this.generateAlterColumnStatements(tableName, { ...this.columnNodeToSchema(node), name: columnName }, this.generateColumnFromNode(node)).join('\n');
     }
     generateDropColumnSql(tableName, columnName) {
-        return `ALTER TABLE ${this.escapeId(tableName)} DROP COLUMN ${this.escapeId(columnName)};`;
+        return this.tableDdl.dropColumn(tableName, columnName).join('\n');
     }
     generateRenameColumnSql(tableName, oldName, newName) {
-        return `ALTER TABLE ${this.escapeId(tableName)} RENAME COLUMN ${this.escapeId(oldName)} TO ${this.escapeId(newName)};`;
+        return this.tableDdl.renameColumn(tableName, oldName, newName);
     }
     /**
      * `CONSTRAINT <name> FOREIGN KEY (...) REFERENCES ... ON DELETE ... ON UPDATE ...`.