@mikro-orm/sql 7.1.0-dev.9 → 7.1.1-dev.0

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, SqlTriggerDef } 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[];
@@ -94,6 +148,18 @@ export declare abstract class SchemaHelper {
      * 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[]>;

package/schema/SchemaHelper.js

@@ -1,4 +1,8 @@
 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. */
+export function stripStatementNewlines(body) {
+    return body.replace(/;[\t ]*\r?\n/g, '; ');
+}
 /** Base class for database-specific schema helpers. Provides SQL generation for DDL operations. */
 export class SchemaHelper {
     platform;
@@ -27,6 +31,32 @@ export class SchemaHelper {
         }
         return '';
     }
+    /** Sets the current schema for the session (e.g. `SET search_path`). */
+    getSetSchemaSQL(_schema) {
+        return '';
+    }
+    /** Whether the driver supports setting a runtime schema per migration run. */
+    supportsMigrationSchema() {
+        return false;
+    }
+    /** Restores the session's schema to the connection's default after a migration. */
+    getResetSchemaSQL(_defaultSchema) {
+        return '';
+    }
+    /** Returns `undefined` for schemaless drivers, throws for drivers that have schemas but no session switch. */
+    resolveMigrationSchema(schema) {
+        if (!schema) {
+            return undefined;
+        }
+        if (this.supportsMigrationSchema()) {
+            return schema;
+        }
+        if (!this.platform.supportsSchemas()) {
+            return undefined;
+        }
+        const driverName = this.platform.constructor.name.replace(/Platform$/, 'Driver');
+        throw new Error(`Runtime schema for migrations is not supported by the ${driverName}`);
+    }
     finalizeTable(table, charset, collate) {
         return '';
     }
@@ -42,7 +72,7 @@ export class SchemaHelper {
     }
     inferLengthFromColumnType(type) {
         const match = /^\w+\s*(?:\(\s*(\d+)\s*\)|$)/.exec(type);
-        if (!match) {
+        if (match?.[1] == null) {
             return;
         }
         return +match[1];
@@ -75,6 +105,13 @@ export class SchemaHelper {
     async getAllTables(connection, schemas, ctx) {
         return connection.execute(this.getListTablesSQL(), [], 'all', ctx);
     }
+    /** Checks whether a specific table exists in a given schema (not the connection's current schema). */
+    async tableExists(connection, tableName, schemaName, ctx) {
+        const qv = (v) => this.platform.quoteValue(v ?? '');
+        const resolved = schemaName ?? this.platform.getDefaultSchemaName();
+        const rows = await connection.execute(`select 1 from information_schema.tables where table_schema = ${qv(resolved)} and table_name = ${qv(tableName)}`, [], 'all', ctx);
+        return rows.length > 0;
+    }
     getListViewsSQL() {
         throw new Error('Not supported by given driver');
     }
@@ -110,7 +147,7 @@ export class SchemaHelper {
             // 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}`;
             const columns = this.platform.getJsonIndexDefinition(index);
-            return `${sql} (${columns.join(', ')})${this.getCreateIndexSuffix(index)}${defer}`;
+            return `${sql} (${columns.join(', ')})${this.getCreateIndexSuffix(index)}${this.getIndexWhereClause(index)}${defer}`;
         }
         // Build column list with advanced options
         const columns = this.getIndexColumns(index);
@@ -119,7 +156,7 @@ export class SchemaHelper {
         if (index.include?.length) {
             sql += ` include (${index.include.map(c => this.quote(c)).join(', ')})`;
         }
-        return sql + this.getCreateIndexSuffix(index) + defer;
+        return sql + this.getCreateIndexSuffix(index) + this.getIndexWhereClause(index) + defer;
     }
     /**
      * Hook for adding driver-specific index options (e.g., fill factor for PostgreSQL).
@@ -128,31 +165,176 @@ export class SchemaHelper {
         return '';
     }
     /**
-     * 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.
+     * 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`.
      */
-    getIndexColumns(index) {
+    getIndexWhereClause(index) {
+        return index.where ? ` where ${index.where}` : '';
+    }
+    /**
+     * 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.
+     */
+    emulatePartialIndexColumns(index) {
         if (index.columns?.length) {
-            return index.columns
-                .map(col => {
-                let colDef = this.quote(col.name);
-                // Collation comes after column name (SQLite syntax: column COLLATE name)
-                if (col.collation) {
-                    colDef += ` collate ${col.collation}`;
+            throw new Error(`Index '${index.keyName}': combining \`where\` with advanced \`columns\` options is not supported when emulating a partial index via functional expressions; use plain \`properties\` (or \`columnNames\`).`);
+        }
+        const predicate = index.where;
+        return index.columnNames.map(c => `(case when ${predicate} then ${this.quote(c)} end)`).join(', ');
+    }
+    /**
+     * 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.
+     */
+    stripAutoNotNullFilter(filterDef, columnNames, identifierPattern) {
+        // Peel off any number of balanced wrapping paren layers. Introspection sources differ
+        // (MSSQL `filter_definition` wraps once, Oracle `INDEX_EXPRESSIONS` typically not at all),
+        // and a user `where` round-tripped through a dialect that double-wraps would otherwise slip
+        // past the auto-NOT-NULL recognizer below.
+        let inner = filterDef.trim();
+        while (inner.startsWith('(') && inner.endsWith(')') && this.isBalancedWrap(inner)) {
+            inner = inner.slice(1, -1).trim();
+        }
+        const clauses = this.splitTopLevelAnd(inner);
+        const autoCol = (clause) => {
+            let trimmed = clause.trim();
+            while (trimmed.startsWith('(') && trimmed.endsWith(')') && this.isBalancedWrap(trimmed)) {
+                trimmed = trimmed.slice(1, -1).trim();
+            }
+            const match = identifierPattern.exec(trimmed);
+            return match && columnNames.includes(match[1]) ? match[1] : null;
+        };
+        const seen = new Set();
+        const kept = [];
+        for (let i = clauses.length - 1; i >= 0; i--) {
+            const col = autoCol(clauses[i]);
+            if (col && !seen.has(col)) {
+                seen.add(col);
+                continue;
+            }
+            kept.unshift(clauses[i]);
+        }
+        return kept.join(' and ').trim();
+    }
+    /**
+     * 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.
+     */
+    get bracketQuotedIdentifiers() {
+        return false;
+    }
+    /**
+     * 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.
+     */
+    splitTopLevelAnd(s) {
+        const parts = [];
+        let depth = 0;
+        let quote = null;
+        let start = 0;
+        let i = 0;
+        while (i < s.length) {
+            const c = s[i];
+            if (quote) {
+                // Handle SQL's doubled-delimiter escape inside quoted strings/identifiers:
+                // `'` → `''`, `"` → `""`, `` ` `` → ```` `` ````, MSSQL `]` → `]]`.
+                if (c === quote && s[i + 1] === quote) {
+                    i += 2;
+                    continue;
                 }
-                // Sort order
-                if (col.sort) {
-                    colDef += ` ${col.sort}`;
+                if (c === quote) {
+                    quote = null;
                 }
-                // NULLS ordering (PostgreSQL)
-                if (col.nulls) {
-                    colDef += ` nulls ${col.nulls}`;
+                i++;
+                continue;
+            }
+            if (c === "'" || c === '"' || c === '`') {
+                quote = c;
+                i++;
+                continue;
+            }
+            if (c === '[' && this.bracketQuotedIdentifiers) {
+                quote = ']';
+                i++;
+                continue;
+            }
+            if (c === '(') {
+                depth++;
+                i++;
+                continue;
+            }
+            if (c === ')') {
+                depth--;
+                i++;
+                continue;
+            }
+            if (depth === 0 && /\s/.test(c)) {
+                const m = /^\s+and\s+/i.exec(s.slice(i));
+                if (m) {
+                    parts.push(s.slice(start, i).trim());
+                    i += m[0].length;
+                    start = i;
+                    continue;
                 }
-                return colDef;
-            })
-                .join(', ');
+            }
+            i++;
         }
-        return index.columnNames.map(c => this.quote(c)).join(', ');
+        parts.push(s.slice(start).trim());
+        return parts.filter(p => p.length > 0);
+    }
+    /** Returns true iff the leading `(` matches the trailing `)` (i.e. they wrap the whole string). */
+    isBalancedWrap(s) {
+        let depth = 0;
+        for (let i = 0; i < s.length; i++) {
+            if (s[i] === '(') {
+                depth++;
+            }
+            else if (s[i] === ')') {
+                depth--;
+                if (depth === 0 && i < s.length - 1) {
+                    return false;
+                }
+            }
+        }
+        return depth === 0;
+    }
+    /**
+     * 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.
+     */
+    getIndexColumns(index) {
+        return index.columnNames
+            .map(name => {
+            const col = index.columns?.find(c => c.name === name);
+            let colDef = this.quote(name);
+            // Collation comes after column name (SQLite syntax: column COLLATE name)
+            if (col?.collation) {
+                colDef += ` collate ${col.collation}`;
+            }
+            // Sort order
+            if (col?.sort) {
+                colDef += ` ${col.sort}`;
+            }
+            // NULLS ordering (PostgreSQL)
+            if (col?.nulls) {
+                colDef += ` nulls ${col.nulls}`;
+            }
+            return colDef;
+        })
+            .join(', ');
     }
     /** Returns SQL to drop an index. */
     getDropIndexSQL(tableName, index) {
@@ -234,7 +416,7 @@ 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'].some(t => changedProperties.has(t))) {
+            if (['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));
@@ -311,7 +493,7 @@ export class SchemaHelper {
         if (changedProperties.has('default') && column.default == null) {
             sql.push(`alter table ${table.getQuotedName()} alter column ${this.quote(column.name)} drop default`);
         }
-        if (changedProperties.has('type')) {
+        if (changedProperties.has('type') || changedProperties.has('collation')) {
             let type = column.type + (column.generated ? ` generated always as ${column.generated}` : '');
             if (column.nativeEnumName) {
                 const parts = type.split('.');
@@ -323,7 +505,8 @@ export class SchemaHelper {
                 }
                 type = this.quote(type);
             }
-            sql.push(`alter table ${table.getQuotedName()} alter column ${this.quote(column.name)} type ${type + this.castColumn(column.name, type)}`);
+            const collateClause = column.collation ? ` ${this.getCollateSQL(column.collation)}` : '';
+            sql.push(`alter table ${table.getQuotedName()} alter column ${this.quote(column.name)} type ${type + collateClause + this.castColumn(column.name, type)}`);
         }
         if (changedProperties.has('default') && column.default != null) {
             sql.push(`alter table ${table.getQuotedName()} alter column ${this.quote(column.name)} set default ${column.default}`);
@@ -334,6 +517,11 @@ export class SchemaHelper {
         }
         return sql;
     }
+    /** Returns the bare `collate <name>` clause for column DDL. Overridden by PostgreSQL to quote the identifier. */
+    getCollateSQL(collation) {
+        this.platform.validateCollationName(collation);
+        return `collate ${collation}`;
+    }
     createTableColumn(column, table, changedProperties) {
         const compositePK = table.getPrimaryKey()?.composite;
         const primaryKey = !changedProperties && !this.hasNonDefaultPrimaryKeyName(table);
@@ -341,6 +529,7 @@ export class SchemaHelper {
         const useDefault = column.default != null && column.default !== 'null' && !column.autoincrement;
         const col = [this.quote(column.name), columnType];
         Utils.runIfNotEmpty(() => col.push('unsigned'), column.unsigned && this.platform.supportsUnsigned());
+        Utils.runIfNotEmpty(() => col.push(this.getCollateSQL(column.collation)), column.collation);
         Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
         Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable && !column.generated);
         Utils.runIfNotEmpty(() => col.push('auto_increment'), column.autoincrement);
@@ -642,6 +831,47 @@ export class SchemaHelper {
         }
         return `drop trigger if exists ${this.quote(trigger.name)}`;
     }
+    /** Default no-op so SQLite/libSQL silent-skip routine DDL; routine-capable dialects override. */
+    createRoutine(_routine) {
+        return '';
+    }
+    dropRoutine(_routine) {
+        return '';
+    }
+    async getAllRoutines(_connection, _schemas = []) {
+        return [];
+    }
+    /** 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();
+        if (/^begin\b/i.test(trimmed)) {
+            return trimmed;
+        }
+        const withSemi = /;\s*$/.test(trimmed) ? trimmed : `${trimmed};`;
+        return `begin ${withSemi} end`;
+    }
+    stripRoutineBody(body) {
+        const match = /^\s*begin\s+([\s\S]*?)\s*end\s*;?\s*$/i.exec(body.trim());
+        if (match) {
+            return match[1].trim().replace(/;\s*$/, '');
+        }
+        return body.trim();
+    }
+    /** T-SQL requires `@name` inside the body; PG/MySQL/Oracle use the bare name. */
+    routineParamReference(name) {
+        return name;
+    }
+    /** T-SQL doesn't distinguish `OUT` from `INOUT` in the catalog — overrides fold `'out'` into `'inout'`. */
+    normaliseRoutineParamDirection(direction) {
+        return direction;
+    }
+    qualifiedRoutineName(routine) {
+        const defaultSchema = this.platform.getDefaultSchemaName();
+        if (routine.schema && routine.schema !== defaultSchema) {
+            return `${this.platform.quoteIdentifier(routine.schema)}.${this.platform.quoteIdentifier(routine.name)}`;
+        }
+        return this.platform.quoteIdentifier(routine.name);
+    }
     /** @internal */
     getTableName(table, schema) {
         if (schema && schema !== this.platform.getDefaultSchemaName()) {

package/schema/SqlSchemaGenerator.d.ts

@@ -15,8 +15,8 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
      * Returns true if the database was created.
      */
     ensureDatabase(options?: EnsureDatabaseOptions): Promise<boolean>;
-    getTargetSchema(schema?: string): DatabaseSchema;
-    protected getOrderedMetadata(schema?: string): EntityMetadata[];
+    getTargetSchema(schema?: string, includeWildcardSchema?: boolean): DatabaseSchema;
+    protected getOrderedMetadata(schema?: string, includeWildcardSchema?: boolean): EntityMetadata[];
     getCreateSchemaSQL(options?: CreateSchemaOptions): Promise<string>;
     drop(options?: DropSchemaOptions): Promise<void>;
     createNamespace(name: string): Promise<void>;

package/schema/SqlSchemaGenerator.js

@@ -44,13 +44,18 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         }
         return false;
     }
-    getTargetSchema(schema) {
-        const metadata = this.getOrderedMetadata(schema);
+    getTargetSchema(schema, includeWildcardSchema = false) {
+        const metadata = this.getOrderedMetadata(schema, includeWildcardSchema);
         const schemaName = schema ?? this.config.get('schema') ?? this.platform.getDefaultSchemaName();
-        return DatabaseSchema.fromMetadata(metadata, this.platform, this.config, schemaName, this.em);
+        const target = DatabaseSchema.fromMetadata(metadata, this.platform, this.config, schemaName, this.em);
+        const routines = this.config.getRoutines();
+        if (routines.length > 0) {
+            target.addRoutinesFromMetadata(routines, this.platform, this.em);
+        }
+        return target;
     }
-    getOrderedMetadata(schema) {
-        const metadata = super.getOrderedMetadata(schema);
+    getOrderedMetadata(schema, includeWildcardSchema = false) {
+        const metadata = super.getOrderedMetadata(schema, includeWildcardSchema);
         // Filter out skipped tables
         return metadata.filter(meta => {
             const tableName = meta.tableName;
@@ -59,7 +64,7 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         });
     }
     async getCreateSchemaSQL(options = {}) {
-        const toSchema = this.getTargetSchema(options.schema);
+        const toSchema = this.getTargetSchema(options.schema, options.includeWildcardSchema);
         const ret = [];
         for (const namespace of toSchema.getNamespaces()) {
             if (namespace === this.platform.getDefaultSchemaName()) {
@@ -93,6 +98,10 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         for (const view of sortedViews) {
             this.appendViewCreation(ret, view);
         }
+        for (const routine of toSchema.getRoutines()) {
+            // pad=true so each routine is its own batch — MSSQL requires CREATE PROC to be first in a batch.
+            this.append(ret, this.helper.createRoutine(routine), true);
+        }
         return this.wrapSchema(ret, options);
     }
     async drop(options = {}) {
@@ -161,6 +170,10 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
                 this.append(ret, this.helper.dropViewIfExists(view.name, view.schema));
             }
         }
+        // Drop routines before tables - most stored routines reference table columns.
+        for (const routine of targetSchema.getRoutines()) {
+            this.append(ret, this.helper.dropRoutine(routine), true);
+        }
         // remove FKs explicitly if we can't use a cascading statement and we don't disable FK checks (we need this for circular relations)
         for (const meta of metadata) {
             if (!this.platform.usesCascadeStatement() && (!this.options.disableForeignKeys || options.dropForeignKeys)) {
@@ -225,13 +238,18 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
     async prepareSchemaForComparison(options) {
         options.safe ??= false;
         options.dropTables ??= true;
-        const toSchema = this.getTargetSchema(options.schema);
+        const toSchema = this.getTargetSchema(options.schema, options.includeWildcardSchema);
         const schemas = toSchema.getNamespaces();
         const fromSchema = options.fromSchema ??
             (await DatabaseSchema.create(this.connection, this.platform, this.config, options.schema, schemas, undefined, this.options.skipTables, this.options.skipViews));
-        const wildcardSchemaTables = [...this.metadata.getAll().values()]
-            .filter(meta => meta.schema === '*')
-            .map(meta => meta.tableName);
+        // Always load DB routines so orphans are detected when the user removes the last metadata
+        // routine. Dialects without routine support return []; that's the silent-skip path.
+        if (options.fromSchema == null) {
+            await fromSchema.loadRoutines(this.connection, this.platform, [...schemas]);
+        }
+        const wildcardSchemaTables = options.includeWildcardSchema
+            ? []
+            : [...this.metadata.getAll().values()].filter(meta => meta.schema === '*').map(meta => meta.tableName);
         fromSchema.prune(options.schema, wildcardSchemaTables);
         toSchema.prune(options.schema, wildcardSchemaTables);
         return { fromSchema, toSchema };
@@ -347,6 +365,18 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         for (const view of sortedChangedViews) {
             this.appendViewCreation(ret, view);
         }
+        if (options.dropTables && !options.safe) {
+            for (const routine of Object.values(schemaDiff.removedRoutines)) {
+                this.append(ret, this.helper.dropRoutine(routine), true);
+            }
+        }
+        for (const change of Object.values(schemaDiff.changedRoutines)) {
+            this.append(ret, this.helper.dropRoutine(change.from), true);
+            this.append(ret, this.helper.createRoutine(change.to), true);
+        }
+        for (const routine of Object.values(schemaDiff.newRoutines)) {
+            this.append(ret, this.helper.createRoutine(routine), true);
+        }
         return this.wrapSchema(ret, options);
     }
     /**

package/schema/partitioning.d.ts

@@ -0,0 +1,13 @@
+import { splitCommaSeparatedIdentifiers, type EntityMetadata, type EntityPartitionBy } from '@mikro-orm/core';
+import type { TablePartitioning } from '../typings.js';
+export { splitCommaSeparatedIdentifiers };
+/** @internal */
+export declare function normalizePartitionDefinition(value: string): string;
+/** @internal */
+export declare function normalizePartitionBound(value: string): string;
+/** @internal */
+export declare const getTablePartitioning: (meta: EntityMetadata, tableSchema: string | undefined, quoteIdentifier?: (id: string) => string) => TablePartitioning | undefined;
+/** @internal */
+export declare const diffPartitioning: (from: TablePartitioning | undefined, to: TablePartitioning | undefined, defaultSchema: string | undefined) => boolean;
+/** @internal */
+export declare const toEntityPartitionBy: (partitioning: TablePartitioning | undefined, parentTableName?: string, parentSchema?: string) => EntityPartitionBy | undefined;