@mikro-orm/sql 7.1.0-dev.8 → 7.1.0

package/query/QueryBuilder.js

@@ -35,6 +35,7 @@ export class QueryBuilder {
     #state = _a.createDefaultState();
     #helper;
     #query;
+    #abortOptions;
     /** @internal */
     static createDefaultState() {
         return {
@@ -721,6 +722,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 +832,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) {
@@ -1001,7 +1011,7 @@ export class QueryBuilder {
         if (cached?.data !== undefined) {
             return cached.data;
         }
-        const loggerContext = { id: this.em?.id, ...this.loggerContext };
+        const loggerContext = { id: this.em?.id, ...this.loggerContext, ...this.#abortOptions };
         const res = await this.getConnection().execute(query.sql, query.params, method, this.context, loggerContext);
         const meta = this.mainAlias.meta;
         if (!options.mapResults || !meta) {
@@ -1055,9 +1065,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 loggerContext = { id: this.em?.id, ...this.loggerContext, ...this.#abortOptions };
+        const res = this.getConnection().stream(query.sql, query.params, this.context, loggerContext, chunkSize);
         const meta = this.mainAlias.meta;
         if (options.rawResults || !meta) {
             yield* res;
@@ -1280,6 +1291,7 @@ export class QueryBuilder {
         qb.#state.finalized = false;
         qb.#query = undefined;
         qb.#helper = qb.createQueryBuilderHelper();
+        qb.#abortOptions = this.#abortOptions;
         return qb;
     }
     /**
@@ -1295,6 +1307,13 @@ export class QueryBuilder {
         this.loggerContext ??= {};
         return this.loggerContext;
     }
+    /**
+     * Configures cancellation behavior for this query builder. The signal is forwarded to the
+     * underlying database client; see {@apilink AbortQueryOptions} for the available strategies.
+     */
+    setAbortOptions(options) {
+        this.#abortOptions = options;
+    }
     fromVirtual(meta) {
         if (typeof meta.expression === 'string') {
             return `(${meta.expression}) as ${this.platform.quoteIdentifier(this.alias)}`;
@@ -1385,6 +1404,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 +1434,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) {
@@ -1743,13 +1777,13 @@ export class QueryBuilder {
         }
         const types = Object.values(meta.root.discriminatorMap).map(cls => this.metadata.get(cls));
         const children = [];
-        const lookUpChildren = (ret, type) => {
-            const children = types.filter(meta2 => meta2.extends === type);
-            children.forEach(m => lookUpChildren(ret, m.class));
+        const lookUpChildren = (ret, parent) => {
+            const children = types.filter(meta2 => meta2.extends && this.metadata.find(meta2.extends) === parent);
+            children.forEach(m => lookUpChildren(ret, m));
             ret.push(...children.filter(c => c.discriminatorValue));
             return children;
         };
-        lookUpChildren(children, meta.class);
+        lookUpChildren(children, meta);
         this.andWhere({
             [meta.root.discriminatorColumn]: children.length > 0
                 ? { $in: [meta.discriminatorValue, ...children.map(c => c.discriminatorValue)] }
@@ -1899,6 +1933,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 +2155,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.d.ts

@@ -1,7 +1,7 @@
-import { type Configuration, type Dictionary, type EntityMetadata, type Transaction } from '@mikro-orm/core';
+import { type Configuration, type Dictionary, type EntityMetadata, type Routine, type Transaction, type Type } from '@mikro-orm/core';
 import { DatabaseTable } from './DatabaseTable.js';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection.js';
-import type { DatabaseView } from '../typings.js';
+import type { DatabaseView, SqlRoutineDef } from '../typings.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 /**
  * @internal
@@ -24,6 +24,8 @@ export declare class DatabaseSchema {
     setViews(views: DatabaseView[]): void;
     getView(name: string): DatabaseView | undefined;
     hasView(name: string): boolean;
+    addRoutine(routine: SqlRoutineDef): SqlRoutineDef;
+    getRoutines(): SqlRoutineDef[];
     setNativeEnums(nativeEnums: Dictionary<{
         name: string;
         schema?: string;
@@ -43,7 +45,32 @@ export declare class DatabaseSchema {
     hasNativeEnum(name: string): boolean;
     getNamespaces(): string[];
     static create(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, schemas?: string[], takeTables?: (string | RegExp)[], skipTables?: (string | RegExp)[], skipViews?: (string | RegExp)[], ctx?: Transaction): Promise<DatabaseSchema>;
+    /** Separate from `create()` so the comparator only pays for routine introspection when the user actually defined routines. SQLite/libSQL helpers return []. */
+    loadRoutines(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, schemas?: string[]): Promise<void>;
     static fromMetadata(metadata: EntityMetadata[], platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, em?: any): DatabaseSchema;
+    /** Separate from {@link fromMetadata} so the comparator only walks routines when the user defined any. */
+    addRoutinesFromMetadata(routines: readonly Routine[], platform: AbstractSqlPlatform, em?: any): void;
+    /**
+     * Normalises a routine's `returns` config to the `{ type, runtimeType, nullable }` shape the
+     * DDL side and introspection-comparator both consume. Supports both `{ type: SomeType }`
+     * (Type drives column + runtime types) and `{ runtimeType, columnType, ... }` (explicit).
+     *
+     * @internal
+     */
+    static normaliseRoutineReturns(returns: Routine['returns'], platform: AbstractSqlPlatform): {
+        type: string;
+        runtimeType: string;
+        nullable?: boolean;
+    } | undefined;
+    /**
+     * Maps a routine param's declared `type` to a dialect-specific SQL column type. A `Type`
+     * instance (when the user passed a `Type` class/instance at `type`) routes through
+     * `Type.getColumnType` so its dialect-aware mapping wins. String aliases (`'string'`,
+     * `'number'`, …) go through the platform's type registry; literal SQL types pass through.
+     *
+     * @internal
+     */
+    static resolveRoutineColumnType(type: string | Type<unknown>, platform: AbstractSqlPlatform): string;
     private static getViewDefinition;
     private static getSchemaName;
     /**

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
  */
@@ -7,6 +8,7 @@ export class DatabaseSchema {
     name;
     #tables = [];
     #views = [];
+    #routines = [];
     #namespaces = new Set();
     #nativeEnums = {}; // for postgres
     #platform;
@@ -64,6 +66,16 @@ export class DatabaseSchema {
     hasView(name) {
         return !!this.getView(name);
     }
+    addRoutine(routine) {
+        this.#routines.push(routine);
+        if (routine.schema != null) {
+            this.#namespaces.add(routine.schema);
+        }
+        return routine;
+    }
+    getRoutines() {
+        return this.#routines;
+    }
     setNativeEnums(nativeEnums) {
         this.#nativeEnums = nativeEnums;
         for (const nativeEnum of Object.values(nativeEnums)) {
@@ -110,6 +122,10 @@ export class DatabaseSchema {
         }
         return schema;
     }
+    /** Separate from `create()` so the comparator only pays for routine introspection when the user actually defined routines. SQLite/libSQL helpers return []. */
+    async loadRoutines(connection, platform, schemas = []) {
+        this.#routines = await platform.getSchemaHelper().getAllRoutines(connection, schemas);
+    }
     static fromMetadata(metadata, platform, config, schemaName, em) {
         const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema'));
         const nativeEnums = {};
@@ -173,6 +189,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;
@@ -237,6 +256,110 @@ export class DatabaseSchema {
         }
         return schema;
     }
+    /** Separate from {@link fromMetadata} so the comparator only walks routines when the user defined any. */
+    addRoutinesFromMetadata(routines, platform, em) {
+        const resolveBody = (raw) => {
+            if (raw == null) {
+                return undefined;
+            }
+            if (typeof raw === 'string') {
+                return raw;
+            }
+            if (isRaw(raw)) {
+                return platform.formatQuery(raw.sql, raw.params);
+            }
+            return undefined;
+        };
+        const helper = platform.getSchemaHelper();
+        for (const routine of routines) {
+            const paramMap = routine.params.reduce((o, p) => {
+                o[p.name] = helper.routineParamReference(p.name);
+                return o;
+            }, {});
+            const evaluated = typeof routine.body === 'function' ? routine.body(paramMap, em) : routine.body;
+            const body = resolveBody(evaluated);
+            const returns = DatabaseSchema.normaliseRoutineReturns(routine.returns, platform);
+            this.addRoutine({
+                name: routine.name,
+                // MySQL has no schema namespace for routines, so leave undefined to align with the introspection side.
+                schema: routine.schema ?? (platform.getDefaultSchemaName() != null ? this.name : undefined),
+                type: routine.type,
+                language: routine.language,
+                comment: routine.comment,
+                security: routine.security,
+                definer: routine.definer,
+                deterministic: routine.deterministic,
+                dataAccess: routine.dataAccess,
+                body,
+                expression: routine.expression,
+                ignoreSchemaChanges: routine.ignoreSchemaChanges,
+                params: routine.params.map(p => ({
+                    name: p.name,
+                    type: DatabaseSchema.resolveRoutineColumnType(p.type, platform),
+                    direction: helper.normaliseRoutineParamDirection(p.direction),
+                    nullable: p.nullable,
+                    defaultRaw: p.defaultRaw,
+                })),
+                returns,
+            });
+        }
+    }
+    /**
+     * Normalises a routine's `returns` config to the `{ type, runtimeType, nullable }` shape the
+     * DDL side and introspection-comparator both consume. Supports both `{ type: SomeType }`
+     * (Type drives column + runtime types) and `{ runtimeType, columnType, ... }` (explicit).
+     *
+     * @internal
+     */
+    static normaliseRoutineReturns(returns, platform) {
+        if (!returns || typeof returns !== 'object') {
+            return undefined;
+        }
+        if ('runtimeType' in returns) {
+            return {
+                type: (returns.columnType ?? returns.runtimeType),
+                runtimeType: returns.runtimeType,
+                nullable: returns.nullable,
+            };
+        }
+        if ('type' in returns && returns.type) {
+            const instance = typeof returns.type === 'function' ? new returns.type() : returns.type;
+            return {
+                type: DatabaseSchema.resolveRoutineColumnType(instance, platform),
+                runtimeType: instance.runtimeType,
+                nullable: returns.nullable,
+            };
+        }
+        return undefined;
+    }
+    /**
+     * Maps a routine param's declared `type` to a dialect-specific SQL column type. A `Type`
+     * instance (when the user passed a `Type` class/instance at `type`) routes through
+     * `Type.getColumnType` so its dialect-aware mapping wins. String aliases (`'string'`,
+     * `'number'`, …) go through the platform's type registry; literal SQL types pass through.
+     *
+     * @internal
+     */
+    static resolveRoutineColumnType(type, platform) {
+        if (typeof type !== 'string') {
+            return type.getColumnType({ columnTypes: [], runtimeType: 'any' }, platform);
+        }
+        const lower = type.toLowerCase();
+        const aliases = {
+            string: 'string',
+            number: 'integer',
+            bigint: 'bigint',
+            boolean: 'boolean',
+            date: 'datetime',
+            buffer: 'blob',
+        };
+        const mappedKey = aliases[lower];
+        if (!mappedKey) {
+            return type;
+        }
+        const t = platform.getMappedType(mappedKey);
+        return t.getColumnType({ type: mappedKey, length: undefined }, platform);
+    }
     static getViewDefinition(meta, em, platform) {
         if (typeof meta.expression === 'string') {
             return meta.expression;
@@ -337,12 +460,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, SqlTriggerDef } 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,6 +30,9 @@ 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;
@@ -67,6 +78,7 @@ export declare class DatabaseTable {
         name?: string;
         type?: string;
         expression?: string | IndexCallback<any>;
+        where?: string | Dictionary;
         deferMode?: DeferMode | `${DeferMode}`;
         options?: Dictionary;
         columns?: {
@@ -82,6 +94,7 @@ 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;