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

package/index.d.ts

@@ -17,3 +17,5 @@ export type * from './typings.js';
 export * from './plugin/index.js';
 export { SqlEntityManager as EntityManager } from './SqlEntityManager.js';
 export { SqlEntityRepository as EntityRepository } from './SqlEntityRepository.js';
+export * from './SqlMikroORM.js';
+export { SqlMikroORM as MikroORM, type SqlOptions as Options, defineSqlConfig as defineConfig } from './SqlMikroORM.js';

package/index.js

@@ -16,3 +16,5 @@ export * from './dialects/index.js';
 export * from './plugin/index.js';
 export { SqlEntityManager as EntityManager } from './SqlEntityManager.js';
 export { SqlEntityRepository as EntityRepository } from './SqlEntityRepository.js';
+export * from './SqlMikroORM.js';
+export { SqlMikroORM as MikroORM, defineSqlConfig as defineConfig } from './SqlMikroORM.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.0-dev.3",
+  "version": "7.1.0-dev.30",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",
@@ -47,13 +47,13 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "kysely": "0.28.16"
+    "kysely": "0.28.17"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.0.11"
+    "@mikro-orm/core": "^7.0.15"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.3"
+    "@mikro-orm/core": "7.1.0-dev.30"
   },
   "engines": {
     "node": ">= 22.17.0"

package/plugin/transformer.d.ts

@@ -1,5 +1,5 @@
-import { type EntityMetadata, type EntityProperty } from '@mikro-orm/core';
-import { type CommonTableExpressionNameNode, type DeleteQueryNode, type IdentifierNode, type InsertQueryNode, type JoinNode, type MergeQueryNode, type QueryId, type SelectQueryNode, type UpdateQueryNode, type WithNode, ColumnNode, OperationNodeTransformer, TableNode } from 'kysely';
+import { type EntityMetadata, type EntityProperty, type Type } from '@mikro-orm/core';
+import { type CommonTableExpressionNameNode, type DeleteQueryNode, type InsertQueryNode, type JoinNode, type MergeQueryNode, type OperationNode, type QueryId, type SelectQueryNode, type UpdateQueryNode, type WithNode, ColumnNode, IdentifierNode, OperationNodeTransformer, SelectionNode, TableNode, ValueNode } from 'kysely';
 import type { MikroKyselyPluginOptions } from './index.js';
 import type { SqlEntityManager } from '../SqlEntityManager.js';
 export declare class MikroTransformer extends OperationNodeTransformer {
@@ -28,10 +28,18 @@ export declare class MikroTransformer extends OperationNodeTransformer {
     processOnUpdateHooks(node: UpdateQueryNode, meta: EntityMetadata): UpdateQueryNode;
     processInsertValues(node: InsertQueryNode, meta: EntityMetadata): InsertQueryNode;
     processUpdateValues(node: UpdateQueryNode, meta: EntityMetadata): UpdateQueryNode;
+    processInputValueNode(prop: EntityProperty | undefined, fieldName: string | undefined, valueNode: ValueNode): OperationNode;
+    expandSelections(selections: readonly SelectionNode[]): readonly SelectionNode[];
+    expandSelection(sel: SelectionNode): SelectionNode[] | null;
+    expandStar(meta: EntityMetadata | undefined, table: TableNode | undefined, tableName: string | undefined): SelectionNode[] | null;
+    wrapRead(customType: Type<any>, fieldName: string, tableName: string | undefined): SelectionNode;
+    wrapWrite(prop: EntityProperty | undefined, fieldName: string | undefined, valueNode: ValueNode): OperationNode;
+    /** Resolve the customType for a specific field name (handles composite-PK FK fan-out via prop.customTypes[]). */
+    fieldType(prop: EntityProperty, fieldName: string): Type<any> | undefined;
+    findOwnerMeta(name: string | undefined): EntityMetadata | undefined;
     mapColumnsToProperties(columns: readonly ColumnNode[], meta: EntityMetadata): (EntityProperty | undefined)[];
     normalizeColumnName(identifier: IdentifierNode): string;
     findProperty(meta: EntityMetadata | undefined, columnName?: string): EntityProperty | undefined;
-    shouldConvertValues(): boolean;
     prepareInputValue(prop: EntityProperty | undefined, value: unknown, enabled: boolean): unknown;
     /**
      * Look up a table name/alias in the context stack.

package/plugin/transformer.js

@@ -1,5 +1,11 @@
 import { ReferenceKind, isRaw, } from '@mikro-orm/core';
-import { AliasNode, ColumnNode, ColumnUpdateNode, OperationNodeTransformer, PrimitiveValueListNode, ReferenceNode, SchemableIdentifierNode, TableNode, ValueListNode, ValueNode, ValuesNode, } from 'kysely';
+import { AliasNode, ColumnNode, ColumnUpdateNode, IdentifierNode, OperationNodeTransformer, PrimitiveValueListNode, RawNode, ReferenceNode, SchemableIdentifierNode, SelectAllNode, SelectionNode, TableNode, ValueListNode, ValueNode, ValuesNode, } from 'kysely';
+const EXPANDABLE_KINDS = new Set([
+    ReferenceKind.SCALAR,
+    ReferenceKind.EMBEDDED,
+    ReferenceKind.MANY_TO_ONE,
+    ReferenceKind.ONE_TO_ONE,
+]);
 export class MikroTransformer extends OperationNodeTransformer {
     /**
      * Context stack to support nested queries (subqueries, CTEs)
@@ -64,7 +70,14 @@ export class MikroTransformer extends OperationNodeTransformer {
                     this.processJoinNode(join, currentContext);
                 }
             }
-            return super.transformSelectQuery(node, queryId);
+            const transformed = super.transformSelectQuery(node, queryId);
+            if (this.#options.convertValues && transformed.selections?.length) {
+                const selections = this.expandSelections(transformed.selections);
+                if (selections !== transformed.selections) {
+                    return { ...transformed, selections };
+                }
+            }
+            return transformed;
         }
         finally {
             // Pop the context when exiting this query scope
@@ -365,32 +378,38 @@ export class MikroTransformer extends OperationNodeTransformer {
             return node;
         }
         const columnProps = this.mapColumnsToProperties(node.columns, meta);
-        const shouldConvert = this.shouldConvertValues();
+        const fieldNames = node.columns.map(c => this.normalizeColumnName(c.column));
+        // hasConvertToDatabaseValueSQL is set by MetadataDiscovery only when the SQL is non-trivial
+        // (i.e. it actually wraps `?`), so a no-op cast on sqlite won't force a row upgrade.
+        const needsSqlWrap = columnProps.some(p => p?.hasConvertToDatabaseValueSQL);
         let changed = false;
         const convertedRows = node.values.values.map(row => {
-            if (ValueListNode.is(row)) {
-                if (row.values.length !== columnProps.length) {
-                    return row;
-                }
+            if (ValueListNode.is(row) && row.values.length === columnProps.length) {
                 const values = row.values.map((valueNode, idx) => {
                     if (!ValueNode.is(valueNode)) {
                         return valueNode;
                     }
-                    const converted = this.prepareInputValue(columnProps[idx], valueNode.value, shouldConvert);
-                    if (converted === valueNode.value) {
-                        return valueNode;
+                    const newNode = this.processInputValueNode(columnProps[idx], fieldNames[idx], valueNode);
+                    if (newNode !== valueNode) {
+                        changed = true;
                     }
-                    changed = true;
-                    return valueNode.immediate ? ValueNode.createImmediate(converted) : ValueNode.create(converted);
+                    return newNode;
                 });
                 return ValueListNode.create(values);
             }
-            if (PrimitiveValueListNode.is(row)) {
-                if (row.values.length !== columnProps.length) {
-                    return row;
+            if (PrimitiveValueListNode.is(row) && row.values.length === columnProps.length) {
+                // upgrade to ValueListNode when any column needs SQL-side wrapping, since
+                // PrimitiveValueListNode can only hold primitives
+                if (needsSqlWrap) {
+                    changed = true;
+                    return ValueListNode.create(row.values.map((value, idx) => {
+                        const prop = columnProps[idx];
+                        const converted = this.prepareInputValue(prop, value, true);
+                        return this.wrapWrite(prop, fieldNames[idx], ValueNode.create(converted));
+                    }));
                 }
                 const values = row.values.map((value, idx) => {
-                    const converted = this.prepareInputValue(columnProps[idx], value, shouldConvert);
+                    const converted = this.prepareInputValue(columnProps[idx], value, true);
                     if (converted !== value) {
                         changed = true;
                     }
@@ -412,7 +431,6 @@ export class MikroTransformer extends OperationNodeTransformer {
         if (!node.updates?.length) {
             return node;
         }
-        const shouldConvert = this.shouldConvertValues();
         let changed = false;
         const updates = node.updates.map(updateNode => {
             if (!ValueNode.is(updateNode.value)) {
@@ -422,18 +440,12 @@ export class MikroTransformer extends OperationNodeTransformer {
                 ? this.normalizeColumnName(updateNode.column.column)
                 : undefined;
             const property = this.findProperty(meta, columnName);
-            const converted = this.prepareInputValue(property, updateNode.value.value, shouldConvert);
-            if (converted === updateNode.value.value) {
+            const newValue = this.processInputValueNode(property, columnName, updateNode.value);
+            if (newValue === updateNode.value) {
                 return updateNode;
             }
             changed = true;
-            const newValueNode = updateNode.value.immediate
-                ? ValueNode.createImmediate(converted)
-                : ValueNode.create(converted);
-            return {
-                ...updateNode,
-                value: newValueNode,
-            };
+            return { ...updateNode, value: newValue };
         });
         if (!changed) {
             return node;
@@ -443,6 +455,106 @@ export class MikroTransformer extends OperationNodeTransformer {
             updates,
         };
     }
+    processInputValueNode(prop, fieldName, valueNode) {
+        const converted = this.prepareInputValue(prop, valueNode.value, true);
+        const newValueNode = converted === valueNode.value
+            ? valueNode
+            : valueNode.immediate
+                ? ValueNode.createImmediate(converted)
+                : ValueNode.create(converted);
+        return this.wrapWrite(prop, fieldName, newValueNode);
+    }
+    expandSelections(selections) {
+        const out = [];
+        let changed = false;
+        for (const sel of selections) {
+            const replaced = this.expandSelection(sel);
+            if (replaced) {
+                out.push(...replaced);
+                changed = true;
+            }
+            else {
+                out.push(sel);
+            }
+        }
+        return changed ? out : selections;
+    }
+    expandSelection(sel) {
+        const inner = sel.selection;
+        if (SelectAllNode.is(inner)) {
+            return this.expandStar(this.findOwnerMeta(undefined), undefined, undefined);
+        }
+        if (!ReferenceNode.is(inner)) {
+            return null;
+        }
+        const table = inner.table;
+        const tableName = table ? this.getTableName(table) : undefined;
+        const meta = this.findOwnerMeta(tableName);
+        if (!meta) {
+            return null;
+        }
+        if (SelectAllNode.is(inner.column)) {
+            return this.expandStar(meta, table, tableName);
+        }
+        const fieldName = inner.column.column.name;
+        const prop = this.findProperty(meta, fieldName);
+        const ct = prop && this.fieldType(prop, fieldName);
+        return ct?.convertToJSValueSQL ? [this.wrapRead(ct, fieldName, tableName)] : null;
+    }
+    expandStar(meta, table, tableName) {
+        if (!meta || !meta.props.some(p => p.hasConvertToJSValueSQL)) {
+            return null;
+        }
+        const out = [];
+        for (const prop of meta.props) {
+            if (prop.persist === false || !prop.fieldNames?.length || !EXPANDABLE_KINDS.has(prop.kind)) {
+                continue;
+            }
+            for (const fieldName of prop.fieldNames) {
+                const ct = this.fieldType(prop, fieldName);
+                out.push(ct?.convertToJSValueSQL
+                    ? this.wrapRead(ct, fieldName, tableName)
+                    : SelectionNode.create(table ? ReferenceNode.create(ColumnNode.create(fieldName), table) : ColumnNode.create(fieldName)));
+            }
+        }
+        return out;
+    }
+    wrapRead(customType, fieldName, tableName) {
+        const key = this.#platform.quoteIdentifier(tableName ? `${tableName}.${fieldName}` : fieldName);
+        const sql = customType.convertToJSValueSQL(key, this.#platform);
+        return SelectionNode.create(AliasNode.create(RawNode.createWithSql(sql), IdentifierNode.create(fieldName)));
+    }
+    wrapWrite(prop, fieldName, valueNode) {
+        if (!prop?.hasConvertToDatabaseValueSQL || !fieldName || valueNode.value == null || isRaw(valueNode.value)) {
+            return valueNode;
+        }
+        const customType = this.fieldType(prop, fieldName);
+        if (!customType?.convertToDatabaseValueSQL) {
+            return valueNode;
+        }
+        const fragments = customType.convertToDatabaseValueSQL('?', this.#platform).split('?');
+        return RawNode.create(fragments, fragments.slice(0, -1).map(() => valueNode));
+    }
+    /** Resolve the customType for a specific field name (handles composite-PK FK fan-out via prop.customTypes[]). */
+    fieldType(prop, fieldName) {
+        return prop.customType ?? prop.customTypes?.[prop.fieldNames.indexOf(fieldName)];
+    }
+    findOwnerMeta(name) {
+        if (name) {
+            return this.lookupInContextStack(name) ?? this.#subqueryAliasMap.get(name) ?? this.findEntityMetadata(name);
+        }
+        let single;
+        for (const meta of this.#contextStack[this.#contextStack.length - 1].values()) {
+            if (!meta) {
+                continue;
+            }
+            if (single && single !== meta) {
+                return undefined;
+            }
+            single = meta;
+        }
+        return single;
+    }
     mapColumnsToProperties(columns, meta) {
         return columns.map(column => {
             const columnName = this.normalizeColumnName(column.column);
@@ -466,9 +578,6 @@ export class MikroTransformer extends OperationNodeTransformer {
         }
         return meta.props.find(prop => prop.fieldNames?.includes(columnName));
     }
-    shouldConvertValues() {
-        return !!this.#options.convertValues;
-    }
     prepareInputValue(prop, value, enabled) {
         if (!enabled || !prop || value == null) {
             return value;

package/query/CriteriaNode.d.ts

@@ -21,7 +21,7 @@ export declare class CriteriaNode<T extends object> implements ICriteriaNode<T>
     shouldInline(payload: any): boolean;
     willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;
     shouldRename(payload: any): boolean;
-    renameFieldToPK<T>(qb: IQueryBuilder<T>, ownerAlias?: string): string;
+    renameFieldToPK<T>(qb: IQueryBuilder<T>, ownerAlias?: string, options?: ICriteriaNodeProcessOptions): string;
     getPath(opts?: {
         addIndex?: boolean;
         parentPath?: string;

package/query/CriteriaNode.js

@@ -83,8 +83,8 @@ export class CriteriaNode {
                 return false;
         }
     }
-    renameFieldToPK(qb, ownerAlias) {
-        const joinAlias = qb.getAliasForJoinPath(this.getPath(), { matchPopulateJoins: true });
+    renameFieldToPK(qb, ownerAlias, options) {
+        const joinAlias = qb.getAliasForJoinPath(this.getPath(), { ...options, matchPopulateJoins: true });
         if (!joinAlias &&
             this.parent &&
             [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind) &&

package/query/ObjectCriteriaNode.js

@@ -105,7 +105,7 @@ export class ObjectCriteriaNode extends CriteriaNode {
                 this.inlineChildPayload(o, payload, field, a, childAlias);
             }
             else if (childNode.shouldRename(payload)) {
-                this.inlineCondition(childNode.renameFieldToPK(qb, alias), o, payload);
+                this.inlineCondition(childNode.renameFieldToPK(qb, alias, options), o, payload);
             }
             else if (isRawField) {
                 const rawField = RawQueryFragment.getKnownFragment(field);

package/query/QueryBuilder.d.ts

@@ -11,6 +11,20 @@ export interface ExecuteOptions {
     mergeResults?: boolean;
 }
 export interface QBStreamOptions {
+    /**
+     * How many rows to fetch in one round-trip.
+     * Lower values will result in more queries and network bandwidth, but less memory usage.
+     * Higher values will result in fewer queries and network bandwidth, but higher memory usage.
+     * Note that the results are iterated one row at a time regardless of this value.
+     *
+     * Honored on PostgreSQL (cursor-based fetch), MSSQL (tedious stream chunk size)
+     * and Oracle (mapped to `fetchArraySize`). Ignored on MySQL, MariaDB, SQLite and
+     * libSQL, where the underlying driver already streams row-by-row with no batching
+     * knob.
+     *
+     * @default 100 on dialects that honor it.
+     */
+    chunkSize?: number;
     /**
      * Results are mapped to entities, if you set `mapResults: false` you will get POJOs instead.
      *
@@ -193,6 +207,11 @@ export interface QBState<Entity extends object> {
     })[];
     tptJoinsApplied: boolean;
     autoJoinedPaths: string[];
+    partitionLimit?: {
+        partitionBy: string;
+        limit: number;
+        offset?: number;
+    };
 }
 /**
  * SQL query builder with fluent interface.
@@ -675,6 +694,12 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     setFlag(flag: QueryFlag): this;
     unsetFlag(flag: QueryFlag): this;
     hasFlag(flag: QueryFlag): boolean;
+    /** @internal */
+    setPartitionLimit(opts: {
+        partitionBy: string;
+        limit: number;
+        offset?: number;
+    }): this;
     cache(config?: boolean | number | [string, number]): this;
     /**
      * Adds index hint to the FROM clause.
@@ -952,6 +977,17 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     private processNestedJoins;
     private hasToManyJoins;
     protected wrapPaginateSubQuery(meta: EntityMetadata): void;
+    /**
+     * 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.
+     */
+    protected wrapPartitionLimitSubQuery(innerQb: NativeQueryBuilder): NativeQueryBuilder;
+    /**
+     * 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().
+     */
+    protected preparePartitionLimit(): void;
     /**
      * Computes the set of populate paths from the _populate hints.
      */

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;
 }