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

package/query/QueryBuilder.js

@@ -721,6 +721,12 @@ export class QueryBuilder {
     hasFlag(flag) {
         return this.#state.flags.has(flag);
     }
+    /** @internal */
+    setPartitionLimit(opts) {
+        this.ensureNotFinalized();
+        this.#state.partitionLimit = opts;
+        return this;
+    }
     cache(config = true) {
         this.ensureNotFinalized();
         this.#state.cache = config;
@@ -825,6 +831,9 @@ export class QueryBuilder {
             this.helper.getLockSQL(qb, this.#state.lockMode, this.#state.lockTables, this.#state.joins);
         }
         this.processReturningStatement(qb, this.mainAlias.meta, this.#state.insertSubQuery ? undefined : this.#state.data, this.#state.returning);
+        if (this.#state.partitionLimit) {
+            return (this.#query.qb = this.wrapPartitionLimitSubQuery(qb));
+        }
         return (this.#query.qb = qb);
     }
     processReturningStatement(qb, meta, data, returning) {
@@ -1055,9 +1064,10 @@ export class QueryBuilder {
         options ??= {};
         options.mergeResults ??= true;
         options.mapResults ??= true;
+        const chunkSize = options.chunkSize ?? 100;
         const query = this.toQuery();
         const loggerContext = { id: this.em?.id, ...this.loggerContext };
-        const res = this.getConnection().stream(query.sql, query.params, this.context, loggerContext);
+        const res = this.getConnection().stream(query.sql, query.params, this.context, loggerContext, chunkSize);
         const meta = this.mainAlias.meta;
         if (options.rawResults || !meta) {
             yield* res;
@@ -1385,6 +1395,7 @@ export class QueryBuilder {
             aliased: [QueryType.SELECT, QueryType.COUNT].includes(this.type),
         });
         const criteriaNode = CriteriaNodeFactory.createNode(this.metadata, prop.targetMeta.class, cond);
+        const joinCountBefore = Object.keys(this.#state.joins).length;
         cond = criteriaNode.process(this, { ignoreBranching: true, alias });
         let aliasedName = `${fromAlias}.${prop.name}#${alias}`;
         path ??= `${Object.values(this.#state.joins).find(j => j.alias === fromAlias)?.path ?? Utils.className(entityName)}.${prop.name}`;
@@ -1414,6 +1425,20 @@ export class QueryBuilder {
             this.#state.joins[aliasedName] = this.helper.joinManyToOneReference(prop, ownerAlias, alias, type, cond, schema);
             this.#state.joins[aliasedName].path ??= path;
         }
+        // auto-joins added by cond processing that depend on the new alias would otherwise produce a
+        // forward reference (the auto-join's ON refers to alias, while alias's ON refers back to it);
+        // fold them into the new join so both aliases share scope in the outer ON clause (issue #7681)
+        const condJoin = this.#state.joins[aliasedName];
+        const joinKeys = Object.keys(this.#state.joins);
+        for (let i = joinCountBefore; i < joinKeys.length; i++) {
+            const j = this.#state.joins[joinKeys[i]];
+            if (j === condJoin || j.ownerAlias !== alias) {
+                continue;
+            }
+            const nested = (condJoin.nested ??= new Set());
+            j.type = j.type === JoinType.innerJoin ? JoinType.nestedInnerJoin : JoinType.nestedLeftJoin;
+            nested.add(j);
+        }
         return { prop, key: aliasedName };
     }
     prepareFields(fields, type = 'where', schema) {
@@ -1899,6 +1924,9 @@ export class QueryBuilder {
             (this.#state.limit > 0 || this.#state.offset > 0)) {
             this.wrapPaginateSubQuery(meta);
         }
+        if (this.#state.partitionLimit) {
+            this.preparePartitionLimit();
+        }
         if (meta &&
             (this.#state.flags.has(QueryFlag.UPDATE_SUB_QUERY) || this.#state.flags.has(QueryFlag.DELETE_SUB_QUERY))) {
             this.wrapModifySubQuery(meta);
@@ -2118,6 +2146,40 @@ export class QueryBuilder {
             [Utils.getPrimaryKeyHash(meta.primaryKeys)]: { $in: raw(sql, params) },
         });
     }
+    /**
+     * Wraps the inner query (which has ROW_NUMBER in SELECT) with an outer query
+     * that filters by the __rn column to apply per-parent limiting.
+     */
+    wrapPartitionLimitSubQuery(innerQb) {
+        const { limit, offset = 0 } = this.#state.partitionLimit;
+        const rnCol = this.platform.quoteIdentifier('__rn');
+        innerQb.as(this.mainAlias.aliasName);
+        const outerQb = this.platform.createNativeQueryBuilder();
+        outerQb.select('*').from(innerQb);
+        outerQb.where(`${rnCol} > ? and ${rnCol} <= ?`, [offset, offset + limit]);
+        outerQb.orderBy(rnCol);
+        return outerQb;
+    }
+    /**
+     * Adds ROW_NUMBER() OVER (PARTITION BY ...) to the SELECT list and prepares
+     * the query state for per-parent limiting. The actual wrapping into a subquery
+     * with __rn filtering happens in getNativeQuery().
+     */
+    preparePartitionLimit() {
+        const { partitionBy } = this.#state.partitionLimit;
+        // `partitionBy` is always a declared property name, so mapper returns a string here.
+        const partitionCol = this.helper.mapper(partitionBy, this.type, undefined, null);
+        const quotedPartition = partitionCol
+            .split('.')
+            .map(e => this.platform.quoteIdentifier(e))
+            .join('.');
+        const queryOrder = this.helper.getQueryOrder(this.type, this.#state.orderBy, this.#state.populateMap, this.#state.collation);
+        const orderBySql = queryOrder.length > 0 ? Utils.unique(queryOrder).join(', ') : quotedPartition;
+        const rnAlias = this.platform.quoteIdentifier('__rn');
+        this.#state.fields.push(raw(`row_number() over (partition by ${quotedPartition} order by ${orderBySql}) as ${rnAlias}`));
+        // Moved into the OVER clause; outer query re-applies via wrapPartitionLimitSubQuery
+        this.#state.orderBy = [];
+    }
     /**
      * Computes the set of populate paths from the _populate hints.
      */

package/schema/DatabaseSchema.js

@@ -1,5 +1,6 @@
 import { ReferenceKind, isRaw, } from '@mikro-orm/core';
 import { DatabaseTable } from './DatabaseTable.js';
+import { getTablePartitioning } from './partitioning.js';
 /**
  * @internal
  */
@@ -173,6 +174,9 @@ export class DatabaseSchema {
             }
             const table = schema.addTable(meta.collection, this.getSchemaName(meta, config, schemaName));
             table.comment = meta.comment;
+            if (meta.partitionBy) {
+                table.setPartitioning(getTablePartitioning(meta, this.getSchemaName(meta, config, schemaName), id => platform.quoteIdentifier(id)));
+            }
             // For TPT child entities, only use ownProps (properties defined in this entity only)
             // For all other entities (including TPT root), use all props
             const propsToProcess = meta.inheritanceType === 'tpt' && meta.tptParent && meta.ownProps ? meta.ownProps : meta.props;
@@ -220,6 +224,20 @@ export class DatabaseSchema {
                     columnName,
                 });
             }
+            for (const trigger of meta.triggers) {
+                const body = isRaw(trigger.body)
+                    ? platform.formatQuery(trigger.body.sql, trigger.body.params)
+                    : trigger.body;
+                table.addTrigger({
+                    name: trigger.name,
+                    timing: trigger.timing,
+                    events: trigger.events,
+                    forEach: trigger.forEach ?? 'row',
+                    body: body ?? '',
+                    when: trigger.when,
+                    expression: trigger.expression,
+                });
+            }
         }
         return schema;
     }
@@ -323,12 +341,16 @@ export class DatabaseSchema {
             (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner));
     }
     toJSON() {
+        // locale-independent comparison so the snapshot is stable across machines
+        const byString = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+        const tableKey = (t) => `${t.schema ?? ''}.${t.name}`;
+        const byTable = (a, b) => byString(tableKey(a), tableKey(b));
         return {
             name: this.name,
-            namespaces: [...this.#namespaces],
-            tables: this.#tables,
-            views: this.#views,
-            nativeEnums: this.#nativeEnums,
+            namespaces: [...this.#namespaces].sort(),
+            tables: [...this.#tables].sort(byTable),
+            views: [...this.#views].sort(byTable),
+            nativeEnums: Object.fromEntries(Object.entries(this.#nativeEnums).sort(([a], [b]) => byString(a, b))),
         };
     }
     prune(schema, wildcardSchemaTables) {

package/schema/DatabaseTable.d.ts

@@ -1,6 +1,6 @@
 import { type Configuration, type DeferMode, type Dictionary, type EntityMetadata, type EntityProperty, type IndexCallback, type NamingStrategy } from '@mikro-orm/core';
 import type { SchemaHelper } from './SchemaHelper.js';
-import type { CheckDef, Column, ForeignKey, IndexDef } from '../typings.js';
+import type { CheckDef, Column, ForeignKey, IndexDef, TablePartitioning, SqlTriggerDef } from '../typings.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 /**
  * @internal
@@ -15,6 +15,14 @@ export declare class DatabaseTable {
         items: string[];
     }>;
     comment?: string;
+    partitioning?: TablePartitioning;
+    /**
+     * Effective collation the column defaults to when no explicit `COLLATE` is set on a column.
+     * For MySQL/MariaDB this is the table collation; for PostgreSQL and MSSQL this is the database default;
+     * SQLite has no configurable default. Used by `SchemaComparator.diffCollation` to avoid flapping
+     * when a property explicitly names the default collation.
+     */
+    collation?: string;
     constructor(platform: AbstractSqlPlatform, name: string, schema?: string | undefined);
     getQuotedName(): string;
     getColumns(): Column[];
@@ -22,11 +30,17 @@ export declare class DatabaseTable {
     removeColumn(name: string): void;
     getIndexes(): IndexDef[];
     getChecks(): CheckDef[];
+    getPartitioning(): TablePartitioning | undefined;
+    /** @internal */
+    setPartitioning(partitioning?: TablePartitioning): void;
+    getTriggers(): SqlTriggerDef[];
     /** @internal */
     setIndexes(indexes: IndexDef[]): void;
     /** @internal */
     setChecks(checks: CheckDef[]): void;
     /** @internal */
+    setTriggers(triggers: SqlTriggerDef[]): void;
+    /** @internal */
     setForeignKeys(fks: Dictionary<ForeignKey>): void;
     init(cols: Column[], indexes: IndexDef[] | undefined, checks: CheckDef[] | undefined, pks: string[], fks?: Dictionary<ForeignKey>, enums?: Dictionary<string[]>): void;
     addColumn(column: Column): void;
@@ -47,6 +61,8 @@ export declare class DatabaseTable {
     hasIndex(indexName: string): boolean;
     getCheck(checkName: string): CheckDef | undefined;
     hasCheck(checkName: string): boolean;
+    getTrigger(triggerName: string): SqlTriggerDef | undefined;
+    hasTrigger(triggerName: string): boolean;
     getPrimaryKey(): IndexDef | undefined;
     hasPrimaryKey(): boolean;
     private getForeignKeyDeclaration;
@@ -62,6 +78,7 @@ export declare class DatabaseTable {
         name?: string;
         type?: string;
         expression?: string | IndexCallback<any>;
+        where?: string | Dictionary;
         deferMode?: DeferMode | `${DeferMode}`;
         options?: Dictionary;
         columns?: {
@@ -77,6 +94,8 @@ export declare class DatabaseTable {
         disabled?: boolean;
         clustered?: boolean;
     }, type: 'index' | 'unique' | 'primary'): void;
+    private processIndexWhere;
     addCheck(check: CheckDef): void;
+    addTrigger(trigger: SqlTriggerDef): void;
     toJSON(): Dictionary;
 }

package/schema/DatabaseTable.js

@@ -1,4 +1,5 @@
 import { DecimalType, EntitySchema, isRaw, ReferenceKind, t, Type, UnknownType, Utils, } from '@mikro-orm/core';
+import { toEntityPartitionBy } from './partitioning.js';
 /**
  * @internal
  */
@@ -8,10 +9,19 @@ export class DatabaseTable {
     #columns = {};
     #indexes = [];
     #checks = [];
+    #triggers = [];
     #foreignKeys = {};
     #platform;
     nativeEnums = {}; // for postgres
     comment;
+    partitioning;
+    /**
+     * Effective collation the column defaults to when no explicit `COLLATE` is set on a column.
+     * For MySQL/MariaDB this is the table collation; for PostgreSQL and MSSQL this is the database default;
+     * SQLite has no configurable default. Used by `SchemaComparator.diffCollation` to avoid flapping
+     * when a property explicitly names the default collation.
+     */
+    collation;
     constructor(platform, name, schema) {
         this.name = name;
         this.schema = schema;
@@ -35,6 +45,16 @@ export class DatabaseTable {
     getChecks() {
         return this.#checks;
     }
+    getPartitioning() {
+        return this.partitioning;
+    }
+    /** @internal */
+    setPartitioning(partitioning) {
+        this.partitioning = partitioning;
+    }
+    getTriggers() {
+        return this.#triggers;
+    }
     /** @internal */
     setIndexes(indexes) {
         this.#indexes = indexes;
@@ -44,6 +64,10 @@ export class DatabaseTable {
         this.#checks = checks;
     }
     /** @internal */
+    setTriggers(triggers) {
+        this.#triggers = triggers;
+    }
+    /** @internal */
     setForeignKeys(fks) {
         this.#foreignKeys = fks;
     }
@@ -51,6 +75,7 @@ export class DatabaseTable {
         this.#indexes = indexes;
         this.#checks = checks;
         this.#foreignKeys = fks;
+        const helper = this.#platform.getSchemaHelper();
         this.#columns = cols.reduce((o, v) => {
             const index = indexes.filter(i => i.columnNames[0] === v.name);
             v.primary = v.primary || pks.includes(v.name);
@@ -59,6 +84,11 @@ export class DatabaseTable {
             v.mappedType = this.#platform.getMappedType(type);
             v.default = v.default?.toString().startsWith('nextval(') ? null : v.default;
             v.enumItems ??= enums[v.name] || [];
+            // recover length from the declared type so introspection matches `addColumnFromProperty`;
+            // scoped to types with `getDefaultLength` to skip mysql's `tinyint(1)` boolean width
+            if (v.length == null && v.type && helper && typeof v.mappedType.getDefaultLength !== 'undefined') {
+                v.length = helper.inferLengthFromColumnType(v.type);
+            }
             o[v.name] = v;
             return o;
         }, {});
@@ -68,7 +98,9 @@ export class DatabaseTable {
     }
     addColumnFromProperty(prop, meta, config) {
         prop.fieldNames?.forEach((field, idx) => {
-            const type = prop.enum ? 'enum' : prop.columnTypes[idx];
+            // numeric enums fall through to the underlying numeric type — no platform emits a CHECK we could parse back
+            const isStringEnum = !!prop.nativeEnumName || !!prop.items?.every(item => typeof item === 'string');
+            const type = prop.enum && isStringEnum ? 'enum' : prop.columnTypes[idx];
             const mappedType = this.#platform.getMappedType(type);
             if (mappedType instanceof DecimalType) {
                 const match = /\w+\((\d+), ?(\d+)\)/.exec(prop.columnTypes[idx]);
@@ -105,6 +137,7 @@ export class DatabaseTable {
                 default: prop.defaultRaw,
                 enumItems: prop.nativeEnumName || prop.items?.every(i => typeof i === 'string') ? prop.items : undefined,
                 comment: prop.comment,
+                collation: prop.collation,
                 extra: prop.extra,
                 ignoreSchemaChanges: prop.ignoreSchemaChanges,
             };
@@ -177,6 +210,7 @@ export class DatabaseTable {
         const { fksOnColumnProps, fksOnStandaloneProps, columnFks, fkIndexes, nullableForeignKeys, skippedColumnNames } = this.foreignKeysToProps(namingStrategy, scalarPropertiesForRelations);
         const name = namingStrategy.getEntityName(this.name, this.schema);
         const schema = new EntitySchema({ name, collection: this.name, schema: this.schema, comment: this.comment });
+        schema.meta.partitionBy = toEntityPartitionBy(this.partitioning, this.name, this.schema);
         const compositeFkIndexes = {};
         const compositeFkUniques = {};
         const potentiallyUnmappedIndexes = this.#indexes.filter(index => !index.primary && // Skip primary index. Whether it's in use by scalar column or FK, it's already mapped.
@@ -196,6 +230,7 @@ export class DatabaseTable {
                 name: index.keyName,
                 deferMode: index.deferMode,
                 expression: index.expression,
+                where: index.where,
                 // Advanced index options - convert column names to property names
                 columns: index.columns?.map(col => ({
                     ...col,
@@ -226,7 +261,7 @@ export class DatabaseTable {
                 index.invisible ||
                 index.disabled ||
                 index.clustered;
-            const isTrivial = !index.deferMode && !index.expression && !hasAdvancedOptions;
+            const isTrivial = !index.deferMode && !index.expression && !index.where && !hasAdvancedOptions;
             if (isTrivial) {
                 // Index is for FK. Map to the FK prop and move on.
                 const fkForIndex = fkIndexes.get(index);
@@ -598,6 +633,12 @@ export class DatabaseTable {
     hasCheck(checkName) {
         return !!this.getCheck(checkName);
     }
+    getTrigger(triggerName) {
+        return this.#triggers.find(t => t.name === triggerName);
+    }
+    hasTrigger(triggerName) {
+        return !!this.getTrigger(triggerName);
+    }
     getPrimaryKey() {
         return this.#indexes.find(i => i.primary);
     }
@@ -632,6 +673,7 @@ export class DatabaseTable {
             columnOptions.scale = column.scale;
             columnOptions.extra = column.extra;
             columnOptions.comment = column.comment;
+            columnOptions.collation = column.collation;
             columnOptions.enum = !!column.enumItems?.length;
             columnOptions.items = column.enumItems;
         }
@@ -698,6 +740,7 @@ export class DatabaseTable {
             scale: column.scale,
             extra: column.extra,
             comment: column.comment,
+            collation: column.collation,
             index: index ? index.keyName : undefined,
             unique: unique ? unique.keyName : undefined,
             enum: !!column.enumItems?.length,
@@ -862,16 +905,25 @@ export class DatabaseTable {
         if (index.fillFactor != null && (index.fillFactor < 0 || index.fillFactor > 100)) {
             throw new Error(`fillFactor must be between 0 and 100, got ${index.fillFactor} for index '${name}' on entity '${meta.className}'`);
         }
+        // The `expression` escape hatch takes the full index definition as raw SQL; combining it
+        // with `where` is dialect-dependent (PG/Oracle/MySQL drop `where`, MSSQL appends it) so we
+        // reject the combination up-front and ask users to inline the predicate into `expression`.
+        if (index.expression && index.where != null) {
+            throw new Error(`Index '${name}' on entity '${meta.className}': cannot combine \`expression\` with \`where\` — inline the WHERE clause into the \`expression\` escape hatch, or drop \`expression\` and use structured \`properties\` + \`where\`.`);
+        }
+        const where = this.processIndexWhere(index.where, meta);
         this.#indexes.push({
             keyName: name,
             columnNames: properties,
             composite: properties.length > 1,
-            // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
-            constraint: type !== 'index' && !properties.some((d) => d.includes('.')),
+            // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them.
+            // Partial indexes (`where`) must use CREATE [UNIQUE] INDEX form — constraints can't carry predicates.
+            constraint: type !== 'index' && !properties.some((d) => d.includes('.')) && !where,
             primary: type === 'primary',
             unique: type !== 'index',
             type: index.type,
             expression: this.processIndexExpression(name, index.expression, meta),
+            where,
             options: index.options,
             deferMode: index.deferMode,
             columns,
@@ -882,56 +934,155 @@ export class DatabaseTable {
             clustered: index.clustered,
         });
     }
+    processIndexWhere(where, meta) {
+        if (where == null) {
+            return undefined;
+        }
+        // The driver is always an `AbstractSqlDriver` here — `DatabaseTable` is only instantiated
+        // by SQL-side schema code, so the platform's config-bound driver is guaranteed to be one.
+        const driver = this.#platform.getConfig().getDriver();
+        return driver.renderPartialIndexWhere(meta.class, where);
+    }
     addCheck(check) {
         this.#checks.push(check);
     }
+    addTrigger(trigger) {
+        this.#triggers.push(trigger);
+    }
     toJSON() {
         const columns = this.#columns;
-        const columnsMapped = Utils.keys(columns).reduce((o, col) => {
+        // locale-independent comparison so the snapshot is stable across machines
+        const byString = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+        const sortedColumnKeys = Utils.keys(columns).sort(byString);
+        // mirror `DatabaseTable.init()`: derive `primary`/`unique` from index membership
+        // so metadata (which keeps `primary: false` on composite PK columns) and introspection agree
+        const primaryColumns = new Set();
+        const uniqueColumns = new Set();
+        for (const idx of this.#indexes) {
+            if (idx.primary) {
+                idx.columnNames.forEach(c => primaryColumns.add(c));
+            }
+            if (idx.unique && !idx.primary && idx.columnNames.length > 0) {
+                uniqueColumns.add(idx.columnNames[0]);
+            }
+        }
+        // integer/float widths live in the type name (`int2`/`int4`/`float8`) — drop redundant precision/scale
+        const isFixedPrecisionFamily = (mappedType) => mappedType instanceof t.integer ||
+            mappedType instanceof t.smallint ||
+            mappedType instanceof t.tinyint ||
+            mappedType instanceof t.mediumint ||
+            mappedType instanceof t.bigint ||
+            mappedType instanceof t.float ||
+            mappedType instanceof t.double;
+        const supportsUnsigned = this.#platform.supportsUnsigned();
+        const columnsMapped = sortedColumnKeys.reduce((o, col) => {
             const c = columns[col];
+            // omit `autoincrement` from options so `serial` (metadata) and `int4` (introspection) collapse the same
+            const rawType = c.type?.toLowerCase();
+            const normOptions = { length: c.length, precision: c.precision, scale: c.scale };
+            const type = this.#platform.normalizeColumnType(c.type ?? '', normOptions)?.toLowerCase() || rawType;
+            const fixedPrecision = isFixedPrecisionFamily(c.mappedType);
             const normalized = {
                 name: c.name,
-                type: c.type,
-                unsigned: !!c.unsigned,
+                type,
+                unsigned: supportsUnsigned && !!c.unsigned,
                 autoincrement: !!c.autoincrement,
-                primary: !!c.primary,
+                primary: primaryColumns.has(c.name) || !!c.primary,
                 nullable: !!c.nullable,
-                unique: !!c.unique,
-                length: c.length ?? null,
-                precision: c.precision ?? null,
-                scale: c.scale ?? null,
+                unique: uniqueColumns.has(c.name) || !!c.unique,
+                length: c.length || null,
+                precision: fixedPrecision ? null : (c.precision ?? null),
+                scale: fixedPrecision ? null : (c.scale ?? null),
                 default: c.default ?? null,
                 comment: c.comment ?? null,
+                collation: c.collation ?? null,
                 enumItems: c.enumItems ?? [],
                 mappedType: Utils.keys(t).find(k => t[k] === c.mappedType.constructor),
             };
-            if (c.generated) {
-                normalized.generated = c.generated;
-            }
-            if (c.nativeEnumName) {
-                normalized.nativeEnumName = c.nativeEnumName;
-            }
-            if (c.extra) {
-                normalized.extra = c.extra;
-            }
-            if (c.ignoreSchemaChanges) {
-                normalized.ignoreSchemaChanges = c.ignoreSchemaChanges;
-            }
-            if (c.defaultConstraint) {
-                normalized.defaultConstraint = c.defaultConstraint;
+            for (const field of [
+                'generated',
+                'nativeEnumName',
+                'extra',
+                'ignoreSchemaChanges',
+                'defaultConstraint',
+            ]) {
+                if (c[field]) {
+                    normalized[field] = c[field];
+                }
             }
             o[col] = normalized;
             return o;
         }, {});
+        const normalizeIndex = (idx) => {
+            const out = {
+                columnNames: idx.columnNames,
+                composite: !!idx.composite,
+                // PK indexes are always backed by a constraint — force it so postgres introspection matches
+                constraint: !!idx.constraint || !!idx.primary,
+                keyName: idx.keyName,
+                primary: !!idx.primary,
+                unique: !!idx.unique,
+            };
+            const optional = [
+                'expression',
+                'type',
+                'deferMode',
+                'columns',
+                'include',
+                'fillFactor',
+                'invisible',
+                'disabled',
+                'clustered',
+            ];
+            for (const field of optional) {
+                if (idx[field] != null && idx[field] !== false) {
+                    out[field] = idx[field];
+                }
+            }
+            return out;
+        };
+        const normalizeFk = (fk) => {
+            const isNoAction = (rule) => !rule || rule.toLowerCase() === 'no action';
+            // JSON.stringify drops undefined properties — let them through instead of guarding
+            return {
+                columnNames: fk.columnNames,
+                constraintName: fk.constraintName,
+                localTableName: fk.localTableName,
+                referencedColumnNames: fk.referencedColumnNames,
+                referencedTableName: fk.referencedTableName,
+                updateRule: isNoAction(fk.updateRule) ? undefined : fk.updateRule,
+                deleteRule: isNoAction(fk.deleteRule) ? undefined : fk.deleteRule,
+                deferMode: fk.deferMode,
+            };
+        };
+        const normalizeCheck = (check) => {
+            const out = { name: check.name };
+            if (typeof check.expression === 'string') {
+                out.expression = check.expression;
+            }
+            for (const field of ['definition', 'columnName']) {
+                if (check[field]) {
+                    out[field] = check[field];
+                }
+            }
+            return out;
+        };
+        const sortedIndexes = [...this.#indexes].sort((a, b) => byString(a.keyName, b.keyName)).map(normalizeIndex);
+        const sortedChecks = [...this.#checks].sort((a, b) => byString(a.name, b.name)).map(normalizeCheck);
+        const sortedTriggers = [...this.#triggers].sort((a, b) => byString(a.name, b.name));
+        const sortedForeignKeys = Object.fromEntries(Object.entries(this.#foreignKeys)
+            .sort(([a], [b]) => byString(a, b))
+            .map(([k, v]) => [k, normalizeFk(v)]));
         return {
             name: this.name,
             schema: this.schema,
             columns: columnsMapped,
-            indexes: this.#indexes,
-            checks: this.#checks,
-            foreignKeys: this.#foreignKeys,
-            nativeEnums: this.nativeEnums,
-            comment: this.comment,
+            indexes: sortedIndexes,
+            checks: sortedChecks,
+            triggers: sortedTriggers,
+            foreignKeys: sortedForeignKeys,
+            // emit `comment` even when unset so introspection (which always reads it) matches metadata
+            comment: this.comment ?? null,
         };
     }
 }

package/schema/SchemaComparator.d.ts

@@ -39,6 +39,15 @@ export declare class SchemaComparator {
     diffColumn(fromColumn: Column, toColumn: Column, fromTable: DatabaseTable, logging?: boolean): Set<string>;
     diffEnumItems(items1?: string[], items2?: string[]): boolean;
     diffComment(comment1?: string, comment2?: string): boolean;
+    /**
+     * `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?: string, toCollation?: string, tableDefault?: string): boolean;
     /**
      * 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.
@@ -69,6 +78,7 @@ export declare class SchemaComparator {
      * @see https://github.com/mikro-orm/mikro-orm/issues/7308
      */
     private diffViewExpression;
+    private diffTrigger;
     parseJsonDefault(defaultValue?: string | null): Dictionary | string | null;
     hasSameDefaultValue(from: Column, to: Column): boolean;
     private mapColumnToProperty;