@mikro-orm/sql 7.1.0-dev.3 → 7.1.0-dev.30

package/schema/SchemaHelper.js

@@ -27,6 +27,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 +68,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 +101,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 +143,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 +152,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).
@@ -127,6 +160,153 @@ export class SchemaHelper {
     getCreateIndexSuffix(_index) {
         return '';
     }
+    /**
+     * 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`.
+     */
+    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) {
+            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;
+                }
+                if (c === quote) {
+                    quote = null;
+                }
+                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;
+                }
+            }
+            i++;
+        }
+        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.
@@ -204,6 +384,12 @@ export class SchemaHelper {
         for (const check of Object.values(diff.changedChecks)) {
             ret.push(this.dropConstraint(diff.name, check.name));
         }
+        for (const trigger of Object.values(diff.removedTriggers)) {
+            ret.push(this.dropTrigger(diff.toTable, trigger));
+        }
+        for (const trigger of Object.values(diff.changedTriggers)) {
+            ret.push(this.dropTrigger(diff.toTable, trigger));
+        }
         /* v8 ignore next */
         if (!safe && Object.values(diff.removedColumns).length > 0) {
             ret.push(this.getDropColumnsSQL(tableName, Object.values(diff.removedColumns), schemaName));
@@ -228,7 +414,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));
@@ -263,6 +449,12 @@ export class SchemaHelper {
         for (const check of Object.values(diff.changedChecks)) {
             ret.push(this.createCheck(diff.toTable, check));
         }
+        for (const trigger of Object.values(diff.addedTriggers)) {
+            ret.push(this.createTrigger(diff.toTable, trigger));
+        }
+        for (const trigger of Object.values(diff.changedTriggers)) {
+            ret.push(this.createTrigger(diff.toTable, trigger));
+        }
         if ('changedComment' in diff) {
             ret.push(this.alterTableComment(diff.toTable, diff.changedComment));
         }
@@ -299,7 +491,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('.');
@@ -311,7 +503,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}`);
@@ -322,6 +515,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);
@@ -329,6 +527,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);
@@ -521,6 +720,9 @@ export class SchemaHelper {
             for (const check of table.getChecks()) {
                 this.append(ret, this.createCheck(table, check));
             }
+            for (const trigger of table.getTriggers()) {
+                this.append(ret, this.createTrigger(table, trigger));
+            }
         }
         return ret;
     }
@@ -600,6 +802,33 @@ export class SchemaHelper {
     createCheck(table, check) {
         return `alter table ${table.getQuotedName()} add constraint ${this.quote(check.name)} check (${check.expression})`;
     }
+    /**
+     * Generates SQL to create a database trigger on a table.
+     * Override in driver-specific helpers for custom DDL (e.g., PostgreSQL function wrapping).
+     */
+    /* v8 ignore next 10 */
+    createTrigger(table, trigger) {
+        if (trigger.expression) {
+            return trigger.expression;
+        }
+        const timing = trigger.timing.toUpperCase();
+        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`;
+    }
+    /**
+     * Generates SQL to drop a database trigger from a table.
+     * Override in driver-specific helpers for custom DDL.
+     */
+    dropTrigger(table, trigger) {
+        if (trigger.events.length > 1) {
+            return trigger.events
+                .map(event => `drop trigger if exists ${this.quote(`${trigger.name}_${event}`)}`)
+                .join(';\n');
+        }
+        return `drop trigger if exists ${this.quote(trigger.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,13 @@ 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);
     }
-    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 +59,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()) {
@@ -225,13 +225,13 @@ 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);
+        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 };
@@ -300,11 +300,18 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
                 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)
+                for (const trigger of table.getTriggers()) {
+                    this.append(ret, this.helper.dropTrigger(table, trigger));
+                }
                 this.append(ret, this.helper.dropTableIfExists(table.name, table.schema));
             }
             if (Utils.hasObjectKeys(schemaDiff.removedTables)) {

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;