@mikro-orm/sql 7.1.0-dev.5 → 7.1.0-dev.50

package/schema/SchemaComparator.js

@@ -1,5 +1,6 @@
 import { ArrayType, BooleanType, DateTimeType, inspect, JsonType, parseJsonSafe, Utils, } from '@mikro-orm/core';
 import { DatabaseTable } from './DatabaseTable.js';
+import { diffPartitioning } from './partitioning.js';
 /**
  * Compares two Schemas and return an instance of SchemaDifference.
  */
@@ -27,6 +28,9 @@ export class SchemaComparator {
             newViews: {},
             changedViews: {},
             removedViews: {},
+            newRoutines: {},
+            changedRoutines: {},
+            removedRoutines: {},
             orphanedForeignKeys: [],
             newNativeEnums: [],
             removedNativeEnums: [],
@@ -162,8 +166,151 @@ export class SchemaComparator {
                 diff.changedTables[viewName] = tableDiff;
             }
         }
+        this.compareRoutines(fromSchema, toSchema, diff);
         return diff;
     }
+    compareRoutines(fromSchema, toSchema, diff) {
+        // Case-fold so user-written `'sql_hash'` matches Oracle's introspected `'SQL_HASH'`.
+        const routineKey = (r) => ((r.schema ? `${r.schema}.` : '') + r.name).toLowerCase();
+        const fromByKey = new Map(fromSchema.getRoutines().map(r => [routineKey(r), r]));
+        const toByKey = new Map(toSchema.getRoutines().map(r => [routineKey(r), r]));
+        for (const [key, toRoutine] of toByKey) {
+            const fromRoutine = fromByKey.get(key);
+            if (!fromRoutine) {
+                diff.newRoutines[key] = toRoutine;
+                this.log(`routine ${key} added`);
+                continue;
+            }
+            if (this.diffRoutine(fromRoutine, toRoutine)) {
+                diff.changedRoutines[key] = { from: fromRoutine, to: toRoutine };
+                this.log(`routine ${key} changed`, { fromRoutine, toRoutine });
+            }
+        }
+        for (const [key, fromRoutine] of fromByKey) {
+            if (!toByKey.has(key)) {
+                diff.removedRoutines[key] = fromRoutine;
+                this.log(`routine ${key} removed`);
+            }
+        }
+    }
+    diffRoutine(from, to) {
+        const ignore = new Set(to.ignoreSchemaChanges ?? []);
+        if (from.type !== to.type) {
+            this.log(`routine ${from.name}: type ${from.type} -> ${to.type}`);
+            return true;
+        }
+        if (!ignore.has('body') && from.expression == null && to.expression == null) {
+            const a = this.normaliseBody(from.body);
+            const b = this.normaliseBody(to.body);
+            if (a !== b) {
+                this.log(`routine ${from.name}: body differs`, { from: a, to: b });
+                return true;
+            }
+        }
+        if (!ignore.has('comment') && (from.comment ?? '') !== (to.comment ?? '')) {
+            return true;
+        }
+        // For security/deterministic/definer, unset on the metadata side means "don't care": the
+        // DB always has some server default, comparing it would force a drop+create on every run.
+        if (!ignore.has('security') && to.security != null && from.security !== to.security) {
+            return true;
+        }
+        if (!ignore.has('deterministic') &&
+            to.deterministic != null &&
+            (from.deterministic ?? false) !== to.deterministic) {
+            return true;
+        }
+        if (!ignore.has('definer') && to.definer != null && from.definer !== to.definer) {
+            return true;
+        }
+        // `language` (PG) / `dataAccess` (MySQL) follow the same to-side-wins policy: only diff when
+        // the metadata explicitly declares them, otherwise the create DDL's defaults will line up with
+        // whatever the engine introspected.
+        if (to.language != null && (from.language ?? '').toLowerCase() !== to.language.toLowerCase()) {
+            this.log(`routine ${from.name}: language ${from.language} -> ${to.language}`);
+            return true;
+        }
+        if (to.dataAccess != null && from.dataAccess !== to.dataAccess) {
+            this.log(`routine ${from.name}: dataAccess ${from.dataAccess} -> ${to.dataAccess}`);
+            return true;
+        }
+        if (this.diffRoutineParams(from.params, to.params)) {
+            this.log(`routine ${from.name}: params differ`, { from: from.params, to: to.params });
+            return true;
+        }
+        if (this.diffRoutineReturns(from.returns, to.returns)) {
+            this.log(`routine ${from.name}: returns differ`, { from: from.returns, to: to.returns });
+            return true;
+        }
+        return false;
+    }
+    /** Strips outer `BEGIN ... END` and trailing semicolons so the comparator doesn't churn on cosmetic round-trip differences. */
+    normaliseBody(body) {
+        let result = (body ?? '').replace(/\s+/g, ' ').trim();
+        const beginEnd = /^begin\s+([\s\S]*?)\s*end\s*;?\s*$/i.exec(result);
+        if (beginEnd) {
+            result = beginEnd[1].trim();
+        }
+        return result.replace(/;+\s*$/, '').trim();
+    }
+    diffRoutineParams(from, to) {
+        if (from.length !== to.length) {
+            return true;
+        }
+        for (let i = 0; i < from.length; i++) {
+            const a = from[i];
+            const b = to[i];
+            if (a.name.toLowerCase() !== b.name.toLowerCase() ||
+                this.normaliseParamType(a.type) !== this.normaliseParamType(b.type) ||
+                a.direction !== b.direction) {
+                return true;
+            }
+            // Asymmetric: drivers don't currently introspect param nullability, so the from side is
+            // always undefined; comparing eagerly would churn metadata-declared `nullable: true`.
+            if (a.nullable != null && !!a.nullable !== !!b.nullable) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** Engines drop length/precision modifiers and use different aliases for the same logical type — canonicalise both sides. */
+    normaliseParamType(type) {
+        const lengthMatch = /^([^()]+)\(([^)]*)\)\s*$/.exec(type);
+        const base = (lengthMatch ? lengthMatch[1] : type).trim().toLowerCase();
+        const aliased = SchemaComparator.PARAM_TYPE_ALIASES[base] ?? base;
+        const length = lengthMatch ? Number.parseInt(lengthMatch[2].split(',')[0].trim(), 10) : NaN;
+        const options = Number.isFinite(length) ? { length } : {};
+        return this.#platform.normalizeColumnType(aliased, options).toLowerCase();
+    }
+    static PARAM_TYPE_ALIASES = {
+        int: 'integer',
+        int4: 'integer',
+        int8: 'bigint',
+        int2: 'smallint',
+        bool: 'boolean',
+        'character varying': 'varchar',
+        bpchar: 'char',
+        float8: 'double precision',
+        float4: 'real',
+        // Oracle's USER_ARGUMENTS reports `REF CURSOR`; users declare `sys_refcursor`.
+        'ref cursor': 'sys_refcursor',
+    };
+    diffRoutineReturns(from, to) {
+        if (from == null && to == null) {
+            return false;
+        }
+        if (from == null || to == null) {
+            return true;
+        }
+        if (this.normaliseParamType(from.type) !== this.normaliseParamType(to.type)) {
+            return true;
+        }
+        // Engines report function returns as nullable; only diff when metadata explicitly declares it.
+        if (to.nullable != null && (from.nullable ?? false) !== to.nullable) {
+            return true;
+        }
+        return false;
+    }
     /**
      * Returns the difference between the tables fromTable and toTable.
      * If there are no differences this method returns the boolean false.
@@ -176,14 +323,17 @@ export class SchemaComparator {
             addedForeignKeys: {},
             addedIndexes: {},
             addedChecks: {},
+            addedTriggers: {},
             changedColumns: {},
             changedForeignKeys: {},
             changedIndexes: {},
             changedChecks: {},
+            changedTriggers: {},
             removedColumns: {},
             removedForeignKeys: {},
             removedIndexes: {},
             removedChecks: {},
+            removedTriggers: {},
             renamedColumns: {},
             renamedIndexes: {},
             fromTable,
@@ -197,6 +347,17 @@ export class SchemaComparator {
             });
             changes++;
         }
+        if (diffPartitioning(fromTable.getPartitioning(), toTable.getPartitioning(), this.#platform.getDefaultSchemaName())) {
+            tableDifferences.changedPartitioning = {
+                from: fromTable.getPartitioning(),
+                to: toTable.getPartitioning(),
+            };
+            this.log(`table partitioning changed for ${tableDifferences.name}`, {
+                fromPartitioning: fromTable.getPartitioning(),
+                toPartitioning: toTable.getPartitioning(),
+            });
+            changes++;
+        }
         const fromTableColumns = fromTable.getColumns();
         const toTableColumns = toTable.getColumns();
         // See if all the columns in "from" table exist in "to" table
@@ -263,6 +424,19 @@ export class SchemaComparator {
             if (!this.diffIndex(index, toTableIndex)) {
                 continue;
             }
+            // Constraint-vs-index form mismatch needs drop+create with the OLD form's drop SQL,
+            // which `changedIndexes` (uses new form only) can't do. Primary keys stay on the
+            // changed path which emits `add primary key`.
+            if (!index.primary && !!index.constraint !== !!toTableIndex.constraint) {
+                tableDifferences.removedIndexes[index.keyName] = index;
+                tableDifferences.addedIndexes[index.keyName] = toTableIndex;
+                this.log(`index ${index.keyName} changed form in table ${tableDifferences.name}`, {
+                    fromTableIndex: index,
+                    toTableIndex,
+                });
+                changes += 2;
+                continue;
+            }
             tableDifferences.changedIndexes[index.keyName] = toTableIndex;
             this.log(`index ${index.keyName} changed in table ${tableDifferences.name}`, {
                 fromTableIndex: index,
@@ -309,6 +483,33 @@ export class SchemaComparator {
             tableDifferences.changedChecks[check.name] = toTableCheck;
             changes++;
         }
+        const fromTableTriggers = fromTable.getTriggers();
+        const toTableTriggers = toTable.getTriggers();
+        for (const trigger of toTableTriggers) {
+            if (fromTable.hasTrigger(trigger.name)) {
+                continue;
+            }
+            tableDifferences.addedTriggers[trigger.name] = trigger;
+            this.log(`trigger ${trigger.name} added to table ${tableDifferences.name}`, { trigger });
+            changes++;
+        }
+        for (const trigger of fromTableTriggers) {
+            if (!toTable.hasTrigger(trigger.name)) {
+                tableDifferences.removedTriggers[trigger.name] = trigger;
+                this.log(`trigger ${trigger.name} removed from table ${tableDifferences.name}`);
+                changes++;
+                continue;
+            }
+            const toTableTrigger = toTable.getTrigger(trigger.name);
+            if (this.diffTrigger(trigger, toTableTrigger)) {
+                this.log(`trigger ${trigger.name} changed in table ${tableDifferences.name}`, {
+                    fromTableTrigger: trigger,
+                    toTableTrigger,
+                });
+                tableDifferences.changedTriggers[trigger.name] = toTableTrigger;
+                changes++;
+            }
+        }
         const fromForeignKeys = { ...fromTable.getForeignKeys() };
         const toForeignKeys = { ...toTable.getForeignKeys() };
         for (const fromConstraint of Object.values(fromForeignKeys)) {
@@ -516,6 +717,11 @@ export class SchemaComparator {
             log(`'comment' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('comment');
         }
+        if (!(fromColumn.ignoreSchemaChanges?.includes('collation') || toColumn.ignoreSchemaChanges?.includes('collation')) &&
+            this.diffCollation(fromColumn.collation, toColumn.collation, fromTable.collation)) {
+            log(`'collation' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
+            changedProperties.add('collation');
+        }
         const isNonNativeEnumArray = !(fromColumn.nativeEnumName || toColumn.nativeEnumName) &&
             (fromColumn.mappedType instanceof ArrayType || toColumn.mappedType instanceof ArrayType);
         if (!isNonNativeEnumArray && this.diffEnumItems(fromColumn.enumItems, toColumn.enumItems)) {
@@ -537,12 +743,26 @@ export class SchemaComparator {
         // eslint-disable-next-line eqeqeq
         return comment1 != comment2 && !(comment1 == null && comment2 === '') && !(comment2 == null && comment1 === '');
     }
+    /**
+     * `from` is the introspected DB state, `to` is the target metadata. A column-level `COLLATE`
+     * clause naming the table/database default is just verbose syntax for inheriting that default,
+     * so both sides are normalized — anything matching `tableDefault` collapses to `undefined` and
+     * compares equal to "no explicit collation". Comparison is case-insensitive on dialects that
+     * treat collation identifiers as case-insensitive (MySQL/MSSQL/SQLite); PostgreSQL's
+     * `pg_collation.collname` is case-sensitive and is compared verbatim.
+     */
+    diffCollation(fromCollation, toCollation, tableDefault) {
+        const fold = this.#platform.caseInsensitiveCollationNames() ? (s) => s.toLowerCase() : (s) => s;
+        const norm = (c) => c && tableDefault && fold(c) === fold(tableDefault) ? undefined : c == null ? undefined : fold(c);
+        return norm(fromCollation) !== norm(toCollation);
+    }
     /**
      * Finds the difference between the indexes index1 and index2.
      * Compares index1 with index2 and returns index2 if there are any differences or false in case there are no differences.
      */
     diffIndex(index1, index2) {
-        // if one of them is a custom expression or full text index, compare only by name
+        // Opaque raw expressions (`expression` escape hatch) and full-text indexes can't be
+        // compared structurally — fall back to name-only matching.
         if (index1.expression || index2.expression || index1.type === 'fulltext' || index2.type === 'fulltext') {
             return index1.keyName !== index2.keyName;
         }
@@ -593,6 +813,11 @@ export class SchemaComparator {
         if (!!index1.clustered !== !!index2.clustered) {
             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 ?? '')) {
+            return false;
+        }
         if (!index1.unique && !index1.primary) {
             // this is a special case: If the current key is neither primary or unique, any unique or
             // primary key will always have the same effect for the index and there cannot be any constraint
@@ -714,6 +939,30 @@ export class SchemaComparator {
         }
         return true;
     }
+    diffTrigger(from, to) {
+        // Raw DDL expression cannot be meaningfully compared to introspected
+        // trigger metadata, so skip diffing when the metadata side uses it.
+        if (to.expression) {
+            // Both sides have expression — compare the raw DDL directly
+            if (from.expression) {
+                return this.diffExpression(from.expression, to.expression);
+            }
+            // Only metadata side has expression — the raw DDL cannot be compared to
+            // introspected metadata. Changes to the expression value won't be detected;
+            // drop and recreate the trigger manually to apply expression changes.
+            return false;
+        }
+        if (from.timing !== to.timing || from.forEach !== to.forEach) {
+            return true;
+        }
+        if ([...from.events].sort().join(',') !== [...to.events].sort().join(',')) {
+            return true;
+        }
+        if ((from.when ?? '') !== (to.when ?? '')) {
+            return true;
+        }
+        return this.diffExpression(from.body, to.body);
+    }
     parseJsonDefault(defaultValue) {
         /* v8 ignore next */
         if (!defaultValue) {

package/schema/SchemaHelper.d.ts

@@ -1,9 +1,11 @@
 import { type Connection, type Dictionary, type Options, type Transaction, type RawQueryFragment } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
-import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../typings.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. */
+export declare function stripStatementNewlines(body: string): string;
 /** Base class for database-specific schema helpers. Provides SQL generation for DDL operations. */
 export declare abstract class SchemaHelper {
     protected readonly platform: AbstractSqlPlatform;
@@ -16,6 +18,14 @@ export declare abstract class SchemaHelper {
     enableForeignKeysSQL(): string;
     /** Returns SQL to append to schema migration scripts (e.g., re-enabling FK checks). */
     getSchemaEnd(disableForeignKeys?: boolean): string;
+    /** Sets the current schema for the session (e.g. `SET search_path`). */
+    getSetSchemaSQL(_schema: string): string;
+    /** Whether the driver supports setting a runtime schema per migration run. */
+    supportsMigrationSchema(): boolean;
+    /** Restores the session's schema to the connection's default after a migration. */
+    getResetSchemaSQL(_defaultSchema: string): string;
+    /** Returns `undefined` for schemaless drivers, throws for drivers that have schemas but no session switch. */
+    resolveMigrationSchema(schema: string | undefined): string | undefined;
     finalizeTable(table: DatabaseTable, charset: string, collate?: string): string;
     appendComments(table: DatabaseTable): string[];
     supportsSchemaConstraints(): boolean;
@@ -31,6 +41,8 @@ export declare abstract class SchemaHelper {
     getListTablesSQL(): string;
     /** Retrieves all tables from the database. */
     getAllTables(connection: AbstractSqlConnection, schemas?: string[], ctx?: Transaction): Promise<Table[]>;
+    /** Checks whether a specific table exists in a given schema (not the connection's current schema). */
+    tableExists(connection: AbstractSqlConnection, tableName: string, schemaName: string | undefined, ctx?: Transaction): Promise<boolean>;
     getListViewsSQL(): string;
     loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string, ctx?: Transaction): Promise<void>;
     /** Returns SQL to rename a column in a table. */
@@ -41,6 +53,46 @@ export declare abstract class SchemaHelper {
      * Hook for adding driver-specific index options (e.g., fill factor for PostgreSQL).
      */
     protected getCreateIndexSuffix(_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
+     * with its own `getCreateIndexSQL` that never calls this, and MariaDB refuses the feature
+     * entirely via an override on `getIndexColumns`.
+     */
+    protected getIndexWhereClause(index: IndexDef): string;
+    /**
+     * Wraps each indexed column in `(CASE WHEN <predicate> THEN <col> END)` for dialects that
+     * emulate partial indexes via functional indexes (MySQL/MariaDB/Oracle). Combined with NULL
+     * being treated as distinct in unique indexes, this enforces uniqueness only where the
+     * predicate holds. Throws if combined with the advanced `columns` option.
+     */
+    protected emulatePartialIndexColumns(index: IndexDef): string;
+    /**
+     * Strips `<col> IS NOT NULL` clauses (with the dialect's identifier quoting) from an
+     * introspected partial-index predicate when the column matches one of the index's own
+     * columns. MikroORM auto-emits this guard for unique indexes on nullable columns
+     * (MSSQL, Oracle) — it's an internal artifact, not user intent.
+     *
+     * Strips at most one guard per column (the tail-most occurrence), matching how MikroORM
+     * appends a single guard per index column. This preserves user intent when they redundantly
+     * include the same `<col> IS NOT NULL` in their predicate — the guard we added is removed,
+     * their copy survives.
+     */
+    protected stripAutoNotNullFilter(filterDef: string, columnNames: string[], identifierPattern: RegExp): string;
+    /**
+     * Whether `[…]` is a quoted identifier (MSSQL convention). Other dialects either reuse
+     * `[` for array literals/constructors or never produce it in introspected predicates,
+     * so the default is `false` and the MSSQL helper opts in.
+     */
+    protected get bracketQuotedIdentifiers(): boolean;
+    /**
+     * Splits on top-level ` AND ` (case-insensitive), ignoring matches that sit inside string
+     * literals, quoted identifiers, or parenthesized groups — so a predicate like
+     * `'foo AND bar' = col` or `(a AND b) OR c` is not mis-split.
+     */
+    protected splitTopLevelAnd(s: string): string[];
+    /** Returns true iff the leading `(` matches the trailing `)` (i.e. they wrap the whole string). */
+    protected isBalancedWrap(s: string): boolean;
     /**
      * Build the column list for an index, supporting advanced options like sort order, nulls ordering, and collation.
      * Note: Prefix length is only supported by MySQL/MariaDB which override this method.
@@ -57,6 +109,8 @@ export declare abstract class SchemaHelper {
     hasNonDefaultPrimaryKeyName(table: DatabaseTable): boolean;
     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. */
+    protected getCollateSQL(collation: string): string;
     createTableColumn(column: Column, table: DatabaseTable, changedProperties?: Set<string>): string | undefined;
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string[];
     getPostAlterTable(tableDiff: TableDifference, safe: boolean): string[];
@@ -84,6 +138,28 @@ export declare abstract class SchemaHelper {
     getReferencedTableName(referencedTableName: string, schema?: string): string;
     createIndex(index: IndexDef, table: DatabaseTable, createPrimary?: boolean): string;
     createCheck(table: DatabaseTable, check: CheckDef): string;
+    /**
+     * Generates SQL to create a database trigger on a table.
+     * Override in driver-specific helpers for custom DDL (e.g., PostgreSQL function wrapping).
+     */
+    createTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    /**
+     * Generates SQL to drop a database trigger from a table.
+     * Override in driver-specific helpers for custom DDL.
+     */
+    dropTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    /** Default no-op so SQLite/libSQL silent-skip routine DDL; routine-capable dialects override. */
+    createRoutine(_routine: SqlRoutineDef): string;
+    dropRoutine(_routine: SqlRoutineDef): string;
+    getAllRoutines(_connection: AbstractSqlConnection, _schemas?: string[]): Promise<SqlRoutineDef[]>;
+    /** 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;
+    /** T-SQL requires `@name` inside the body; PG/MySQL/Oracle use the bare name. */
+    routineParamReference(name: string): string;
+    /** T-SQL doesn't distinguish `OUT` from `INOUT` in the catalog — overrides fold `'out'` into `'inout'`. */
+    normaliseRoutineParamDirection(direction: 'in' | 'out' | 'inout'): 'in' | 'out' | 'inout';
+    protected qualifiedRoutineName(routine: SqlRoutineDef): string;
     /** @internal */
     getTableName(table: string, schema?: string): string;
     getTablesGroupedBySchemas(tables: Table[]): Map<string | undefined, Table[]>;