@mikro-orm/sql 7.1.0-dev.5 → 7.1.0-dev.50

package/query/QueryBuilder.d.ts

@@ -1,4 +1,4 @@
-import { type AnyEntity, type AutoPath, type Collection, type ConnectionType, type Dictionary, type EntityData, type EntityDTOFlat, type EntityDTOProp, type EntityKey, type EntityManager, EntityMetadata, type EntityName, type EntityProperty, type ExpandProperty, type FilterObject, type FilterOptions, type FilterValue, type FlushMode, type GroupOperator, type Loaded, LockMode, type LoggingOptions, type MetadataStorage, type PrimaryProperty, type ObjectQuery, PopulateHint, type PopulateOptions, type PopulatePath, QueryFlag, type QueryOrderKeysFlat, type QueryOrderMap, type QueryResult, RawQueryFragment, type Raw, type RequiredEntityData, type Scalar, type SerializeDTO, type Subquery, type Transaction } from '@mikro-orm/core';
+import { type AbortQueryOptions, type AnyEntity, type AutoPath, type Collection, type ConnectionType, type Dictionary, type EntityData, type EntityDTOFlat, type EntityDTOProp, type EntityKey, type EntityManager, EntityMetadata, type EntityName, type EntityProperty, type ExpandProperty, type FilterObject, type FilterOptions, type FilterValue, type FlushMode, type GroupOperator, type Loaded, LockMode, type LoggingOptions, type MetadataStorage, type PrimaryProperty, type ObjectQuery, PopulateHint, type PopulateOptions, type PopulatePath, QueryFlag, type QueryOrderKeysFlat, type QueryOrderMap, type QueryResult, RawQueryFragment, type Raw, type RequiredEntityData, type Scalar, type SerializeDTO, type Subquery, type Transaction } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums.js';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';
 import { type Alias, type OnConflictClause, QueryBuilderHelper } from './QueryBuilderHelper.js';
@@ -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.
@@ -890,6 +915,11 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      * Gets logger context for this query builder.
      */
     getLoggerContext<T extends Dictionary & LoggingOptions = Dictionary>(): T;
+    /**
+     * 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: AbortQueryOptions | undefined): void;
     private fromVirtual;
     /**
      * Adds a join from a property object. Used internally for TPT joins where the property
@@ -952,6 +982,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

@@ -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;
@@ -220,9 +239,127 @@ 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;
     }
+    /** 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;
@@ -323,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 } 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;
 }