@mikro-orm/sql 7.2.0-dev.0 → 7.2.0-dev.10

package/schema/DatabaseTable.js

@@ -219,6 +219,8 @@ export class DatabaseTable {
                 skippedColumnNames.includes(index.columnNames[0]) || // Non-composite indexes for skipped columns are to be mapped as entity decorators.
                 index.deferMode ||
                 index.expression ||
+                index.where ||
+                this.hasAdvancedIndexOptions(index) ||
                 !(index.columnNames[0] in columnFks)) && // Trivial non-composite indexes for scalar props are to be mapped to the column.
             // ignore indexes that don't have all column names (this can happen in sqlite where there is no way to infer this for expressions)
             !(index.columnNames.some(col => !col) && !index.expression));
@@ -254,14 +256,7 @@ export class DatabaseTable {
                 }
             }
             // An index is trivial if it has no special options that require entity-level declaration
-            const hasAdvancedOptions = index.columns?.length ||
-                index.include?.length ||
-                index.fillFactor ||
-                index.type ||
-                index.invisible ||
-                index.disabled ||
-                index.clustered;
-            const isTrivial = !index.deferMode && !index.expression && !index.where && !hasAdvancedOptions;
+            const isTrivial = !index.deferMode && !index.expression && !index.where && !this.hasAdvancedIndexOptions(index);
             if (isTrivial) {
                 // Index is for FK. Map to the FK prop and move on.
                 const fkForIndex = fkIndexes.get(index);
@@ -299,6 +294,19 @@ export class DatabaseTable {
             }
             schema.addIndex(ret);
         }
+        for (const check of this.getChecks()) {
+            // skip checks that were consumed by enum conversion — the enum property recreates an
+            // equivalent check under the conventional name during discovery (only on platforms that
+            // emulate enums via check constraints; mysql/mariadb enums are native and recreate nothing)
+            const enumItems = check.columnName ? this.getColumn(check.columnName)?.enumItems : undefined;
+            if (this.#platform.usesEnumCheckConstraints() &&
+                enumItems?.length &&
+                (check.expression === this.#platform.getEnumCheckConstraintExpression(check.columnName, enumItems) ||
+                    check.name === this.#platform.getIndexName(this.name, [check.columnName], 'check'))) {
+                continue;
+            }
+            schema.meta.checks.push({ name: check.name, expression: check.expression });
+        }
         const addedStandaloneFkPropsBasedOnColumn = new Set();
         const nonSkippedColumns = this.getColumns().filter(column => !skippedColumnNames.includes(column.name));
         for (const column of nonSkippedColumns) {
@@ -507,7 +515,9 @@ export class DatabaseTable {
     findFkIndex(currentFk) {
         const fkColumnsLength = currentFk.columnNames.length;
         const possibleIndexes = this.#indexes.filter(index => {
-            return (index.columnNames.length === fkColumnsLength &&
+            return (!index.where &&
+                !this.hasAdvancedIndexOptions(index) &&
+                index.columnNames.length === fkColumnsLength &&
                 !currentFk.columnNames.some((columnName, i) => index.columnNames[i] !== columnName));
         });
         possibleIndexes.sort((a, b) => {
@@ -521,13 +531,31 @@ export class DatabaseTable {
         });
         return possibleIndexes.at(0);
     }
+    /** Advanced options require an entity-level declaration, as the property-level `index`/`unique` cannot carry them. */
+    hasAdvancedIndexOptions(index) {
+        return !!(index.columns?.length ||
+            index.include?.length ||
+            index.fillFactor ||
+            index.type ||
+            index.invisible ||
+            index.disabled ||
+            index.clustered);
+    }
     getIndexProperties(index, columnFks, fksOnColumnProps, fksOnStandaloneProps, namingStrategy) {
-        const propBaseNames = new Set();
+        const propBaseNames = new Map();
         const columnNames = index.columnNames;
         const l = columnNames.length;
         if (columnNames.some(col => !col)) {
             return;
         }
+        const addPropBaseName = (baseName, position) => {
+            const positions = propBaseNames.get(baseName);
+            if (positions) {
+                positions.last = position;
+                return;
+            }
+            propBaseNames.set(baseName, { first: position, last: position });
+        };
         for (let i = 0; i < l; ++i) {
             const columnName = columnNames[i];
             // The column is not involved with FKs.
@@ -538,14 +566,14 @@ export class DatabaseTable {
                 }
                 // It has a prop named after it.
                 // Add it and move on.
-                propBaseNames.add(columnName);
+                addPropBaseName(columnName, i);
                 continue;
             }
             // If the prop named after the column has a FK and the FK's columns are a subset of this index,
             // include this prop and move on.
             const columnPropFk = fksOnColumnProps.get(columnName);
             if (columnPropFk && !columnPropFk.columnNames.some(fkColumnName => !columnNames.includes(fkColumnName))) {
-                propBaseNames.add(columnName);
+                addPropBaseName(columnName, i);
                 continue;
             }
             // If there is at least one standalone FK featuring this column,
@@ -557,7 +585,7 @@ export class DatabaseTable {
                     continue;
                 }
                 if (!fk.columnNames.some(fkColumnName => !columnNames.includes(fkColumnName))) {
-                    propBaseNames.add(propName);
+                    addPropBaseName(propName, i);
                     propAdded = true;
                 }
             }
@@ -568,7 +596,10 @@ export class DatabaseTable {
             // Break the whole prop creation.
             return;
         }
-        return Array.from(propBaseNames).map(baseName => this.getPropertyName(namingStrategy, baseName, fksOnColumnProps.get(baseName)));
+        // Props sharing their first column would otherwise follow FK discovery order, so break ties on the last one.
+        return Array.from(propBaseNames)
+            .sort(([, a], [, b]) => a.first - b.first || a.last - b.last)
+            .map(([baseName]) => this.getPropertyName(namingStrategy, baseName, fksOnColumnProps.get(baseName)));
     }
     getSafeBaseNameForFkProp(namingStrategy, currentFk, fks, columnName) {
         if (columnName &&
@@ -694,9 +725,19 @@ export class DatabaseTable {
         const prop = this.getPropertyName(namingStrategy, column.name, fk);
         const persist = !(column.name in columnFks && typeof fk === 'undefined');
         const index = compositeFkIndexes[prop] ||
-            this.#indexes.find(idx => idx.columnNames[0] === column.name && !idx.composite && !idx.unique && !idx.primary);
+            this.#indexes.find(idx => idx.columnNames[0] === column.name &&
+                !idx.composite &&
+                !idx.unique &&
+                !idx.primary &&
+                !idx.where &&
+                !this.hasAdvancedIndexOptions(idx));
         const unique = compositeFkUniques[prop] ||
-            this.#indexes.find(idx => idx.columnNames[0] === column.name && !idx.composite && idx.unique && !idx.primary);
+            this.#indexes.find(idx => idx.columnNames[0] === column.name &&
+                !idx.composite &&
+                idx.unique &&
+                !idx.primary &&
+                !idx.where &&
+                !this.hasAdvancedIndexOptions(idx));
         const kind = this.getReferenceKind(fk, unique);
         const runtimeType = this.getPropertyTypeForColumn(namingStrategy, column, fk);
         const type = fk
@@ -989,8 +1030,12 @@ export class DatabaseTable {
             // mysql stores decimal defaults padded to scale (`0` → `0.00`); collapse to canonical numeric form
             // so the metadata-side (`0`) and introspection-side (`0.00`) snapshots agree
             let defaultValue = c.default ?? null;
-            if (defaultValue != null && c.mappedType instanceof DecimalType && Number.isFinite(+defaultValue)) {
-                defaultValue = this.#platform.formatDecimal(defaultValue, c.scale).toString();
+            if (defaultValue != null && c.mappedType instanceof DecimalType) {
+                // string defaults like `default: '0.00'` are quoted in metadata, so strip the quotes first
+                const unquoted = defaultValue.replace(/^'(.*)'$/, '$1');
+                if (Number.isFinite(+unquoted)) {
+                    defaultValue = this.#platform.formatDecimal(unquoted, c.scale).toString();
+                }
             }
             const normalized = {
                 name: c.name,

package/schema/SchemaComparator.d.ts

@@ -89,6 +89,7 @@ export declare class SchemaComparator {
     private diffViewExpression;
     private diffTrigger;
     parseJsonDefault(defaultValue?: string | null): Dictionary | string | null;
+    private parseDecimalDefault;
     hasSameDefaultValue(from: Column, to: Column): boolean;
     private mapColumnToProperty;
     private log;

package/schema/SchemaComparator.js

@@ -820,6 +820,10 @@ export class SchemaComparator {
         if (!!index1.clustered !== !!index2.clustered) {
             return false;
         }
+        // Compare the index access method (e.g. `using gin` on PostgreSQL); unset means the platform default
+        if (this.#helper.getIndexAccessMethod(index1) !== this.#helper.getIndexAccessMethod(index2)) {
+            return false;
+        }
         // Compare WHERE predicate of partial indexes structurally (whitespace/quoting/casing
         // are normalized via the same helper used for check constraints).
         if (this.diffExpression(index1.where ?? '', index2.where ?? '')) {
@@ -897,9 +901,13 @@ export class SchemaComparator {
                 // lookbehind: only strip a real charset introducer, never an underscore inside a literal like 'a_b'
                 ?.replace(/(?<![\w'])_\w+'(.*?)'/g, '$1')
                 .replace(/!=/g, '<>')
-                .replace(/in\s*\((.*?)\)/gi, '= any (array[$1])')
+                // `\b` keeps this from firing inside identifiers like `min(...)`
+                .replace(/\bin\s*\((.*?)\)/gi, '= any (array[$1])')
                 // MySQL normalizes count(*) to count(0)
                 .replace(/\bcount\s*\(\s*0\s*\)/gi, 'count(*)')
+                // multi word type names in casts, the generic `::\w+` below only covers single word ones
+                // the precision is kept, so `timestamptz(3)` and `timestamp(3) with time zone` leave the same residue
+                .replace(/::\s*(?:character\s+varying|bit\s+varying|double\s+precision|(?:timestamp|time)\b(\s*\(\d+\))?(?:\s+with(?:out)?\s+time\s+zone)?)/gi, '$1')
                 // Remove quotes first so we can process identifiers
                 .replace(/['"`]/g, '')
                 // MySQL adds table/alias prefixes to columns (e.g., a.name or table_name.column vs just column)
@@ -907,12 +915,18 @@ export class SchemaComparator {
                 .replace(/\b\w+\.(\w+)/g, '$1')
                 // Normalize JOIN syntax: inner join -> join (equivalent in SQL)
                 .replace(/\binner\s+join\b/gi, 'join')
+                // PostgreSQL names an unaliased bare function call after the function itself,
+                // so `max(created_at)` comes back as `max(created_at) AS max`
+                // the lookahead skips table function column alias lists like `unnest(a) AS unnest(c)`, which are meaningful
+                .replace(/\b(\w+)\s*\(((?:[^()]|\([^()]*\))*)\)\s+as\s+\1\b(?!\s*\()/gi, '$1($2)')
                 // Remove redundant column aliases like `title AS title` -> `title`
                 .replace(/\b(\w+)\s+as\s+\1\b/gi, '$1')
                 // Remove AS keyword (optional in SQL, MySQL may add/remove it)
                 .replace(/\bas\b/gi, '')
                 // Remove remaining special chars, parentheses, type casts, asterisks, and normalize whitespace
-                .replace(/[()\n[\]*]|::\w+| +/g, '')
+                // tabs and CRs included — the schema generator trims every line before executing the DDL,
+                // so indentation and CRLF endings can never come back from introspection
+                .replace(/[()\n\r\t[\]*]|::\w+| +/g, '')
                 .replace(/anyarray\[(.*)]/gi, '$1')
                 .toLowerCase()
                 // PostgreSQL adds default aliases to aggregate functions (e.g., count(*) AS count)
@@ -979,6 +993,10 @@ export class SchemaComparator {
         const val = defaultValue.replace(/^(_\w+\\)?'(.*?)\\?'$/, '$2').replace(/^\(?'(.*?)'\)?$/, '$1');
         return parseJsonSafe(val);
     }
+    parseDecimalDefault(defaultValue) {
+        const value = +('' + defaultValue).replace(/^'(.+)'$/, '$1');
+        return Number.isFinite(value) ? value : null;
+    }
     hasSameDefaultValue(from, to) {
         if (from.default == null ||
             from.default.toString().toLowerCase() === 'null' ||
@@ -1004,10 +1022,15 @@ export class SchemaComparator {
             const defaultValueTo = to.default.toLowerCase().replace('current_timestamp', 'now').replace(/\(\)$/, '');
             return defaultValueFrom === defaultValueTo;
         }
-        // mysql stores decimal defaults padded to scale (`0` → `0.00`); compare numerically so the
-        // entity-side raw literal and the introspected padded form don't churn the no-op migration
-        if (to.mappedType instanceof DecimalType && Number.isFinite(+from.default) && Number.isFinite(+to.default)) {
-            return (this.#platform.formatDecimal(from.default, to.scale) === this.#platform.formatDecimal(to.default, to.scale));
+        // mysql pads decimal defaults to scale (`0` → `0.00`) and postgres reports them unquoted
+        // while metadata keeps them quoted; compare numerically so neither churns a no-op migration
+        if (to.mappedType instanceof DecimalType) {
+            const defaultValueFrom = this.parseDecimalDefault(from.default);
+            const defaultValueTo = this.parseDecimalDefault(to.default);
+            if (defaultValueFrom != null && defaultValueTo != null) {
+                return (this.#platform.formatDecimal(defaultValueFrom, to.scale) ===
+                    this.#platform.formatDecimal(defaultValueTo, to.scale));
+            }
         }
         if (from.default && to.default) {
             return from.default.toString().toLowerCase() === to.default.toString().toLowerCase();

package/schema/SchemaHelper.d.ts

@@ -4,7 +4,13 @@ import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference, SqlTriggerDef, SqlRoutineDef } from '../typings.js';
 import type { DatabaseSchema } from './DatabaseSchema.js';
 import type { DatabaseTable } from './DatabaseTable.js';
-/** Flattens `;\n` boundaries so the schema-generator's statement splitter doesn't break the routine DDL apart. Other whitespace is preserved. */
+/**
+ * Flattens `;\n` boundaries and drops blank lines so the schema-generator's statement splitter
+ * doesn't break the routine or trigger DDL apart — it treats both as statement/group separators.
+ * Blank lines go first, otherwise a `;` followed by one would keep its newline. Like
+ * `normalizeViewDefinition`, this is not string-literal aware, so a blank line inside a multi-line
+ * literal is dropped too. Other whitespace is preserved.
+ */
 export declare function stripStatementNewlines(body: string): string;
 /**
  * Strips SQL line comments and blank lines from a view definition. Comments are dropped by the
@@ -64,6 +70,13 @@ export declare abstract class SchemaHelper {
      * Hook for adding driver-specific index options (e.g., fill factor for PostgreSQL).
      */
     protected getCreateIndexSuffix(_index: IndexDef): string;
+    /**
+     * Normalized index access method (e.g. `gin` on PostgreSQL), empty string when the
+     * platform default applies. Used for both DDL emission and index diffing.
+     */
+    getIndexAccessMethod(_index: IndexDef): string;
+    /** Emits the access method between the table name and the column list (e.g. ` using gin`). */
+    protected getIndexAccessMethodClause(index: IndexDef): string;
     /**
      * Default emits ` where <predicate>` for partial indexes. Only Oracle overrides this to
      * return `''` (it emulates partials via CASE-WHEN columns). MySQL sidesteps the whole path
@@ -118,6 +131,8 @@ export declare abstract class SchemaHelper {
     getAddColumnsSQL(table: DatabaseTable, columns: Column[]): string[];
     getDropColumnsSQL(tableName: string, columns: Column[], schemaName?: string): string;
     hasNonDefaultPrimaryKeyName(table: DatabaseTable): boolean;
+    /** Returns the `constraint <name> ` prefix for a primary key definition, empty when the server assigns the default name on its own. */
+    protected getPrimaryKeyConstraintPrefix(table: DatabaseTable, index: IndexDef): string;
     castColumn(name: string, type: string): string;
     alterTableColumn(column: Column, table: DatabaseTable, changedProperties: Set<string>): string[];
     /** Returns the bare `collate <name>` clause for column DDL. Overridden by PostgreSQL to quote the identifier. */
@@ -137,6 +152,8 @@ export declare abstract class SchemaHelper {
         }[];
     }[], safe: boolean): string[];
     getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
+    /** Whether the column comment is part of the column declaration, as opposed to a separate statement. */
+    protected hasInlineColumnComment(): boolean;
     getNamespaces(connection: AbstractSqlConnection, ctx?: Transaction): Promise<string[]>;
     protected mapIndexes(indexes: IndexDef[]): Promise<IndexDef[]>;
     mapForeignKeys(fks: any[], tableName: string, schemaName?: string): Dictionary;
@@ -176,6 +193,8 @@ export declare abstract class SchemaHelper {
     createRoutine(_routine: SqlRoutineDef): string;
     dropRoutine(_routine: SqlRoutineDef): string;
     getAllRoutines(_connection: AbstractSqlConnection, _schemas?: string[]): Promise<SqlRoutineDef[]>;
+    /** Flattens internal `;\n` so the statement splitter doesn't tear the DDL, and ensures exactly one trailing `;` for the enclosing `begin ... end` block. */
+    protected normalizeTriggerBody(body: string): string;
     /** Wraps the body in `BEGIN ... END` if not already, and flattens internal `;\n` so the schema-generator's statement splitter doesn't tear the DDL. */
     protected wrapRoutineBody(body: string): string;
     protected stripRoutineBody(body: string): string;

package/schema/SchemaHelper.js

@@ -1,7 +1,17 @@
 import { isRaw, Utils, } from '@mikro-orm/core';
-/** Flattens `;\n` boundaries so the schema-generator's statement splitter doesn't break the routine DDL apart. Other whitespace is preserved. */
+/**
+ * Flattens `;\n` boundaries and drops blank lines so the schema-generator's statement splitter
+ * doesn't break the routine or trigger DDL apart — it treats both as statement/group separators.
+ * Blank lines go first, otherwise a `;` followed by one would keep its newline. Like
+ * `normalizeViewDefinition`, this is not string-literal aware, so a blank line inside a multi-line
+ * literal is dropped too. Other whitespace is preserved.
+ */
 export function stripStatementNewlines(body) {
-    return body.replace(/;[\t ]*\r?\n/g, '; ');
+    return body
+        .split('\n')
+        .filter(line => line.trim() !== '')
+        .join('\n')
+        .replace(/;[\t ]*\r?\n/g, '; ');
 }
 /**
  * Strips SQL line comments and blank lines from a view definition. Comments are dropped by the
@@ -157,13 +167,14 @@ export class SchemaHelper {
         tableName = this.quote(tableName);
         const keyName = this.quote(index.keyName);
         const defer = index.deferMode ? ` deferrable initially ${index.deferMode}` : '';
-        let sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName}`;
+        const using = this.getIndexAccessMethodClause(index);
+        let sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName}${using}`;
         if (index.unique && index.constraint) {
             sql = `alter table ${tableName} add constraint ${keyName} unique`;
         }
         if (index.columnNames.some(column => column.includes('.'))) {
             // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
-            sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName}`;
+            sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName}${using}`;
             const columns = this.platform.getJsonIndexDefinition(index);
             return `${sql} (${columns.join(', ')})${this.getCreateIndexSuffix(index)}${this.getIndexWhereClause(index)}${defer}`;
         }
@@ -182,6 +193,18 @@ export class SchemaHelper {
     getCreateIndexSuffix(_index) {
         return '';
     }
+    /**
+     * Normalized index access method (e.g. `gin` on PostgreSQL), empty string when the
+     * platform default applies. Used for both DDL emission and index diffing.
+     */
+    getIndexAccessMethod(_index) {
+        return '';
+    }
+    /** Emits the access method between the table name and the column list (e.g. ` using gin`). */
+    getIndexAccessMethodClause(index) {
+        const method = this.getIndexAccessMethod(index);
+        return method ? ` using ${method}` : '';
+    }
     /**
      * Default emits ` where <predicate>` for partial indexes. Only Oracle overrides this to
      * return `''` (it emulates partials via CASE-WHEN columns). MySQL sidesteps the whole path
@@ -436,7 +459,8 @@ export class SchemaHelper {
             this.append(ret, this.alterTableColumn(column, diff.fromTable, changedProperties));
         }
         for (const { column, changedProperties } of Object.values(diff.changedColumns).filter(diff => diff.changedProperties.has('comment'))) {
-            if (['type', 'nullable', 'autoincrement', 'unsigned', 'default', 'enumItems', 'collation'].some(t => changedProperties.has(t))) {
+            if (this.hasInlineColumnComment() &&
+                ['type', 'nullable', 'autoincrement', 'unsigned', 'default', 'enumItems', 'collation'].some(t => changedProperties.has(t))) {
                 continue; // will be handled via column update
             }
             ret.push(this.getChangeColumnCommentSQL(tableName, column, schemaName));
@@ -489,7 +513,13 @@ export class SchemaHelper {
             return `add ${this.createTableColumn(column, table)}`;
         })
             .join(', ');
-        return [`alter table ${table.getQuotedName()} ${adds}`];
+        const ret = [`alter table ${table.getQuotedName()} ${adds}`];
+        if (!this.hasInlineColumnComment()) {
+            for (const column of columns.filter(column => column.comment)) {
+                ret.push(this.getChangeColumnCommentSQL(table.name, column, table.schema));
+            }
+        }
+        return ret;
     }
     getDropColumnsSQL(tableName, columns, schemaName) {
         const name = this.quote(this.getTableName(tableName, schemaName));
@@ -504,6 +534,10 @@ export class SchemaHelper {
         const defaultName = this.platform.getDefaultPrimaryName(table.name, pkIndex.columnNames);
         return pkIndex?.keyName !== defaultName;
     }
+    /** Returns the `constraint <name> ` prefix for a primary key definition, empty when the server assigns the default name on its own. */
+    getPrimaryKeyConstraintPrefix(table, index) {
+        return this.hasNonDefaultPrimaryKeyName(table) ? `constraint ${this.quote(index.keyName)} ` : '';
+    }
     /* v8 ignore next */
     castColumn(name, type) {
         return '';
@@ -608,6 +642,10 @@ export class SchemaHelper {
     getChangeColumnCommentSQL(tableName, to, schemaName) {
         return '';
     }
+    /** Whether the column comment is part of the column declaration, as opposed to a separate statement. */
+    hasInlineColumnComment() {
+        return false;
+    }
     async getNamespaces(connection, ctx) {
         return [];
     }
@@ -745,7 +783,7 @@ export class SchemaHelper {
         const primaryKey = table.getPrimaryKey();
         const createPrimary = !table.getColumns().some(c => c.autoincrement && c.primary) || this.hasNonDefaultPrimaryKeyName(table);
         if (createPrimary && primaryKey) {
-            const name = this.hasNonDefaultPrimaryKeyName(table) ? `constraint ${this.quote(primaryKey.keyName)} ` : '';
+            const name = this.getPrimaryKeyConstraintPrefix(table, primaryKey);
             sql += `, ${name}primary key (${primaryKey.columnNames.map(c => this.quote(c)).join(', ')})`;
         }
         sql += ')';
@@ -828,7 +866,7 @@ export class SchemaHelper {
         const columns = index.columnNames.map(c => this.quote(c)).join(', ');
         const defer = index.deferMode ? ` deferrable initially ${index.deferMode}` : '';
         if (index.primary) {
-            const keyName = this.hasNonDefaultPrimaryKeyName(table) ? `constraint ${index.keyName} ` : '';
+            const keyName = this.getPrimaryKeyConstraintPrefix(table, index);
             return `alter table ${table.getQuotedName()} add ${keyName}primary key (${columns})${defer}`;
         }
         if (index.type === 'fulltext') {
@@ -861,7 +899,7 @@ export class SchemaHelper {
         const events = trigger.events.map(e => e.toUpperCase()).join(' OR ');
         const forEach = trigger.forEach === 'statement' ? 'STATEMENT' : 'ROW';
         const when = trigger.when ? ` when (${trigger.when})` : '';
-        return `create trigger ${this.quote(trigger.name)} ${timing} ${events} on ${table.getQuotedName()} for each ${forEach}${when} begin ${trigger.body}; end`;
+        return `create trigger ${this.quote(trigger.name)} ${timing} ${events} on ${table.getQuotedName()} for each ${forEach}${when} begin ${this.normalizeTriggerBody(trigger.body)} end`;
     }
     /**
      * Generates SQL to drop a database trigger from a table.
@@ -885,6 +923,11 @@ export class SchemaHelper {
     async getAllRoutines(_connection, _schemas = []) {
         return [];
     }
+    /** Flattens internal `;\n` so the statement splitter doesn't tear the DDL, and ensures exactly one trailing `;` for the enclosing `begin ... end` block. */
+    normalizeTriggerBody(body) {
+        const trimmed = stripStatementNewlines(body).trim();
+        return /;\s*$/.test(trimmed) ? trimmed : `${trimmed};`;
+    }
     /** Wraps the body in `BEGIN ... END` if not already, and flattens internal `;\n` so the schema-generator's statement splitter doesn't tear the DDL. */
     wrapRoutineBody(body) {
         const trimmed = stripStatementNewlines(body).trim();

package/schema/SqlSchemaGenerator.d.ts

@@ -54,6 +54,10 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
         wrap?: boolean;
         ctx?: Transaction;
     }): Promise<void>;
+    /** Splits the SQL on the separator, keeping the separators that fall inside a string literal. */
+    private splitOutsideLiterals;
+    /** Whether the statement has to be the first one in a query batch, e.g. `create trigger` on MSSQL. */
+    protected startsBatch(_statement: string): boolean;
     dropTableIfExists(name: string, schema?: string): Promise<void>;
     private wrapSchema;
     private append;

package/schema/SqlSchemaGenerator.js

@@ -308,22 +308,6 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         for (const newTable of Object.values(schemaDiff.newTables)) {
             this.append(ret, this.helper.createTable(newTable, true), true);
         }
-        if (this.helper.supportsSchemaConstraints()) {
-            for (const newTable of Object.values(schemaDiff.newTables)) {
-                const sql = [];
-                if (this.options.createForeignKeyConstraints) {
-                    const fks = Object.values(newTable.getForeignKeys()).map(fk => this.helper.createForeignKey(newTable, fk));
-                    this.append(sql, fks);
-                }
-                for (const check of newTable.getChecks()) {
-                    this.append(sql, this.helper.createCheck(newTable, check));
-                }
-                for (const trigger of newTable.getTriggers()) {
-                    this.append(sql, this.helper.createTrigger(newTable, trigger));
-                }
-                this.append(ret, sql, true);
-            }
-        }
         if (options.dropTables && !options.safe) {
             for (const table of Object.values(schemaDiff.removedTables)) {
                 // Drop triggers before the table so driver-specific cleanup runs (e.g. PostgreSQL function removal)
@@ -353,6 +337,23 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         for (const changedTable of alteredTables) {
             this.append(ret, this.helper.getPostAlterTable(changedTable, options.safe), true);
         }
+        // after the alters, so a new table's FK can reference a unique constraint an existing table gains in the same diff
+        if (this.helper.supportsSchemaConstraints()) {
+            for (const newTable of Object.values(schemaDiff.newTables)) {
+                const sql = [];
+                if (this.options.createForeignKeyConstraints) {
+                    const fks = Object.values(newTable.getForeignKeys()).map(fk => this.helper.createForeignKey(newTable, fk));
+                    this.append(sql, fks);
+                }
+                for (const check of newTable.getChecks()) {
+                    this.append(sql, this.helper.createCheck(newTable, check));
+                }
+                for (const trigger of newTable.getTriggers()) {
+                    this.append(sql, this.helper.createTrigger(newTable, trigger));
+                }
+                this.append(ret, sql, true);
+            }
+        }
         if (!options.safe && this.platform.supportsNativeEnums()) {
             for (const removedNativeEnum of schemaDiff.removedNativeEnums) {
                 this.append(ret, this.helper.getDropNativeEnumSQL(removedNativeEnum.name, removedNativeEnum.schema));
@@ -439,18 +440,23 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
     }
     async execute(sql, options = {}) {
         options.wrap ??= false;
-        const lines = this.wrapSchema(sql, options).split('\n');
+        const lines = this.splitOutsideLiterals(this.wrapSchema(sql, options), '\n');
         const groups = [];
         let i = 0;
         for (const line of lines) {
-            if (line.trim() === '') {
+            const stmt = line.trim();
+            if (stmt === '') {
                 if (groups[i]?.length > 0) {
                     i++;
                 }
                 continue;
             }
+            // same boundary an empty line creates, for statements that have to start their own batch
+            if (groups[i]?.length > 0 && this.startsBatch(stmt)) {
+                i++;
+            }
             groups[i] ??= [];
-            groups[i].push(line.trim());
+            groups[i].push(stmt);
         }
         if (groups.length === 0) {
             return;
@@ -463,14 +469,37 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
             return;
         }
         const statements = groups.flatMap(group => {
-            return group
-                .join('\n')
-                .split(';\n')
+            return this.splitOutsideLiterals(group.join('\n'), ';\n')
                 .map(s => s.trim())
                 .filter(s => s);
         });
         await Utils.runSerial(statements, stmt => this.driver.execute(stmt));
     }
+    /** Splits the SQL on the separator, keeping the separators that fall inside a string literal. */
+    splitOutsideLiterals(sql, separator) {
+        const [idOpen, idClose] = this.platform.quoteIdentifier('');
+        // mysql escapes quotes as `\'`, the other dialects double them, which pairs up on its own
+        const esc = this.platform.quoteValue(`'`).includes(`\\'`) ? '\\\\.|' : '';
+        // complete literals, quoted identifiers and `--` comments, so that an apostrophe inside an
+        // identifier or a comment is not mistaken for one opening a literal
+        const tokens = new RegExp(`'(?:${esc}[^'])*'|\\${idOpen}[^\\${idClose}]*\\${idClose}|--[^\n]*`, 'g');
+        const parts = [];
+        for (const chunk of sql.split(separator)) {
+            const prev = parts.at(-1);
+            // whatever quote is left once the complete tokens are gone opened a literal we are still inside of
+            if (prev?.replace(tokens, '').includes(`'`)) {
+                parts[parts.length - 1] = prev + separator + chunk;
+            }
+            else {
+                parts.push(chunk);
+            }
+        }
+        return parts;
+    }
+    /** Whether the statement has to be the first one in a query batch, e.g. `create trigger` on MSSQL. */
+    startsBatch(_statement) {
+        return false;
+    }
     async dropTableIfExists(name, schema) {
         const sql = this.helper.dropTableIfExists(name, schema);
         return this.execute(sql);

package/typings.d.ts

@@ -368,9 +368,9 @@ type MaybeGenerated<TValue, TOptions, TProcessOnCreate extends boolean> = TOptio
 } ? TValue | null : TOptions extends {
     autoincrement: true;
 } ? Generated<TValue> : TOptions extends {
-    default: true;
+    default: unknown;
 } ? Generated<TValue> : TOptions extends {
-    defaultRaw: true;
+    defaultRaw: unknown;
 } ? Generated<TValue> : TProcessOnCreate extends false ? TValue : TOptions extends {
     onCreate: Function;
 } ? Generated<TValue> : TValue;