@mikro-orm/sql 7.1.0-dev.2 → 7.1.0-dev.21

package/query/QueryBuilder.js

@@ -159,6 +159,41 @@ export class QueryBuilder {
     insert(data) {
         return this.init(QueryType.INSERT, data);
     }
+    /**
+     * Creates an INSERT ... SELECT query that copies rows from the source query.
+     *
+     * Column resolution (3 tiers):
+     * 1. No explicit select on source, no explicit columns → all cloneable columns derived from entity metadata
+     * 2. Explicit select on source, no explicit columns → columns derived from selected field names
+     * 3. Explicit `columns` option → user-provided column list
+     *
+     * @example
+     * ```ts
+     * // Clone all fields (columns auto-derived from metadata)
+     * const source = em.createQueryBuilder(User).where({ id: 1 });
+     * await em.createQueryBuilder(User).insertFrom(source).execute();
+     *
+     * // Clone with overrides via raw() aliases
+     * const source = em.createQueryBuilder(User)
+     *   .select(['name', raw("'new@email.com'").as('email')])
+     *   .where({ id: 1 });
+     * await em.createQueryBuilder(User).insertFrom(source).execute();
+     *
+     * // Explicit columns for full control
+     * await em.createQueryBuilder(User)
+     *   .insertFrom(source, { columns: ['name', 'email'] })
+     *   .execute();
+     * ```
+     */
+    insertFrom(subQuery, options) {
+        this.ensureNotFinalized();
+        this.#state.type = QueryType.INSERT;
+        this.#state.insertSubQuery = subQuery;
+        if (options?.columns) {
+            this.#state.insertColumns = Utils.asArray(options.columns);
+        }
+        return this;
+    }
     /**
      * Creates an UPDATE query with the given data.
      * Use `where()` to specify which rows to update.
@@ -686,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;
@@ -789,12 +830,18 @@ export class QueryBuilder {
         if (this.#state.lockMode) {
             this.helper.getLockSQL(qb, this.#state.lockMode, this.#state.lockTables, this.#state.joins);
         }
-        this.processReturningStatement(qb, this.mainAlias.meta, this.#state.data, this.#state.returning);
+        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) {
         const usesReturningStatement = this.platform.usesReturningStatement() || this.platform.usesOutputStatement();
-        if (!meta || !data || !usesReturningStatement) {
+        if (!meta || !usesReturningStatement) {
+            return;
+        }
+        if (!data && !this.#state.insertSubQuery) {
             return;
         }
         // always respect explicit returning hint
@@ -805,13 +852,13 @@ export class QueryBuilder {
         if (this.type === QueryType.INSERT) {
             const returningProps = meta.hydrateProps
                 .filter(prop => prop.returning || (prop.persist !== false && ((prop.primary && prop.autoincrement) || prop.defaultRaw)))
-                .filter(prop => !(prop.name in data));
+                .filter(prop => !data || !(prop.name in data));
             if (returningProps.length > 0) {
                 qb.returning(Utils.flatten(returningProps.map(prop => prop.fieldNames)));
             }
             return;
         }
-        if (this.type === QueryType.UPDATE) {
+        if (this.type === QueryType.UPDATE && data) {
             const returningProps = meta.hydrateProps.filter(prop => prop.fieldNames && isRaw(data[prop.fieldNames[0]]));
             if (returningProps.length > 0) {
                 qb.returning(returningProps.flatMap((prop) => {
@@ -1017,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;
@@ -1603,7 +1651,14 @@ export class QueryBuilder {
                 break;
             }
             case QueryType.INSERT:
-                qb.insert(this.#state.data);
+                if (this.#state.insertSubQuery) {
+                    const columns = this.resolveInsertFromColumns();
+                    const compiled = this.#state.insertSubQuery.toQuery();
+                    qb.insertSelect(columns, raw(compiled.sql, compiled.params));
+                }
+                else {
+                    qb.insert(this.#state.data);
+                }
                 break;
             case QueryType.UPDATE:
                 qb.update(this.#state.data);
@@ -1619,6 +1674,78 @@ export class QueryBuilder {
         }
         return qb;
     }
+    /**
+     * Resolves the INSERT column list for `insertFrom()`.
+     *
+     * Tier 1: Explicit `insertColumns` from `options.columns` → map property names to field names
+     * Tier 2: Source QB has explicit select fields → derive from those
+     * Tier 3: Derive from target entity metadata (all cloneable columns), auto-populate source select
+     */
+    resolveInsertFromColumns() {
+        const meta = this.mainAlias.meta;
+        const subQuery = this.#state.insertSubQuery;
+        // Tier 1: explicit columns
+        if (this.#state.insertColumns?.length) {
+            return this.#state.insertColumns.flatMap(col => {
+                const prop = meta?.properties[col];
+                return prop?.fieldNames ?? [col];
+            });
+        }
+        // Tier 2: source QB has explicit select fields
+        const sourceFields = subQuery.state.fields;
+        if (sourceFields && subQuery.state.type === QueryType.SELECT) {
+            return sourceFields
+                .filter((field) => typeof field === 'string' || isRaw(field))
+                .flatMap((field) => {
+                if (typeof field === 'string') {
+                    // Strip alias prefix like 'a0.'
+                    const bare = field.replace(/^\w+\./, '');
+                    const prop = meta?.properties[bare];
+                    return prop?.fieldNames ?? [bare];
+                }
+                // RawQueryFragment with alias: raw('...').as('name')
+                const alias = String(field.params[field.params.length - 1]);
+                const prop = meta?.properties[alias];
+                return prop?.fieldNames ?? [alias];
+            });
+        }
+        // Tier 3: derive from metadata — all cloneable columns
+        const cloneableProps = this.getCloneableProps(meta);
+        const selectFields = [];
+        const columns = [];
+        for (const prop of cloneableProps) {
+            for (const fieldName of prop.fieldNames) {
+                columns.push(fieldName);
+                selectFields.push(fieldName);
+            }
+        }
+        // Auto-populate source select with matching fields
+        if (!sourceFields) {
+            subQuery.select(selectFields);
+        }
+        return columns;
+    }
+    /** Returns properties that are safe to clone (persistable, non-PK, non-generated). */
+    getCloneableProps(meta) {
+        return meta.props.filter(prop => {
+            if (prop.persist === false) {
+                return false;
+            }
+            if (prop.primary) {
+                return false;
+            }
+            if (!prop.fieldNames?.length) {
+                return false;
+            }
+            if ([ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
+                return false;
+            }
+            if (prop.kind === ReferenceKind.EMBEDDED && !prop.object) {
+                return false;
+            }
+            return true;
+        });
+    }
     applyDiscriminatorCondition() {
         const meta = this.mainAlias.meta;
         if (meta.root.inheritanceType !== 'sti' || !meta.discriminatorValue) {
@@ -1782,6 +1909,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);
@@ -2001,6 +2131,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,7 @@ export declare class DatabaseTable {
         items: string[];
     }>;
     comment?: string;
+    partitioning?: TablePartitioning;
     constructor(platform: AbstractSqlPlatform, name: string, schema?: string | undefined);
     getQuotedName(): string;
     getColumns(): Column[];
@@ -22,11 +23,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 +54,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 +71,7 @@ export declare class DatabaseTable {
         name?: string;
         type?: string;
         expression?: string | IndexCallback<any>;
+        where?: string | Dictionary;
         deferMode?: DeferMode | `${DeferMode}`;
         options?: Dictionary;
         columns?: {
@@ -77,6 +87,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;
 }