@mikro-orm/sql 7.0.0-dev.298 → 7.0.0-dev.300

package/query/QueryBuilder.js

@@ -1,4 +1,4 @@
-import { helper, inspect, isRaw, LoadStrategy, LockMode, PopulateHint, QueryFlag, QueryHelper, raw, RawQueryFragment, Reference, ReferenceKind, serialize, Utils, ValidationError, } from '@mikro-orm/core';
+import { EntityMetadata, helper, inspect, isRaw, LoadStrategy, LockMode, PopulateHint, QueryFlag, QueryHelper, raw, RawQueryFragment, Reference, ReferenceKind, serialize, Utils, ValidationError, } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums.js';
 import { QueryBuilderHelper } from './QueryBuilderHelper.js';
 import { CriteriaNodeFactory } from './CriteriaNodeFactory.js';
@@ -82,6 +82,7 @@ export class QueryBuilder {
     _helper;
     _query;
     _unionQuery;
+    _ctes = [];
     platform;
     tptJoinsApplied = false;
     autoJoinedPaths = [];
@@ -712,6 +713,9 @@ export class QueryBuilder {
         if (target instanceof QueryBuilder) {
             this.fromSubQuery(target, aliasName);
         }
+        else if (typeof target === 'string' && !this.metadata.find(target)) {
+            this.fromRawTable(target, aliasName);
+        }
         else {
             if (aliasName && this._mainAlias && Utils.className(target) !== this._mainAlias.aliasName) {
                 throw new Error(`Cannot override the alias to '${aliasName}' since a query already contains references to '${this._mainAlias.aliasName}'`);
@@ -737,6 +741,16 @@ export class QueryBuilder {
         this._query = {};
         this.finalize();
         const qb = this.getQueryBase(processVirtualEntity);
+        for (const cte of this._ctes) {
+            const query = cte.query;
+            const opts = { columns: cte.columns, materialized: cte.materialized };
+            if (cte.recursive) {
+                qb.withRecursive(cte.name, query, opts);
+            }
+            else {
+                qb.with(cte.name, query, opts);
+            }
+        }
         const schema = this.getSchema(this.mainAlias);
         const isNotEmptyObject = (obj) => Utils.hasObjectKeys(obj) || RawQueryFragment.hasObjectFragments(obj);
         Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(this.type, this._cond, qb), this._cond && !this._onConflict);
@@ -1121,6 +1135,28 @@ export class QueryBuilder {
         result._unionQuery = { sql: parts.join(` ${separator} `), params };
         return result;
     }
+    with(name, query, options) {
+        return this.addCte(name, query, options);
+    }
+    withRecursive(name, query, options) {
+        return this.addCte(name, query, options, true);
+    }
+    addCte(name, query, options, recursive) {
+        this.ensureNotFinalized();
+        if (this._ctes.some(cte => cte.name === name)) {
+            throw new Error(`CTE with name '${name}' already exists`);
+        }
+        // Eagerly compile QueryBuilder to RawQueryFragment — later mutations to the sub-query won't be reflected
+        const compiled = query instanceof QueryBuilder ? query.toRaw() : query;
+        this._ctes.push({
+            name,
+            query: compiled,
+            recursive,
+            columns: options?.columns,
+            materialized: options?.materialized,
+        });
+        return this;
+    }
     clone(reset, preserve) {
         const qb = new QueryBuilder(this.mainAlias.entityName, this.metadata, this.driver, this.context, this.mainAlias.aliasName, this.connectionType, this.em);
         reset = reset || [];
@@ -1140,6 +1176,9 @@ export class QueryBuilder {
         if (this._fields && reset !== true && !reset.includes('_fields')) {
             qb._fields = [...this._fields];
         }
+        if (this._ctes.length && reset !== true && !reset.includes('_ctes')) {
+            qb._ctes = this._ctes.map(cte => ({ ...cte }));
+        }
         qb._aliases = { ...this._aliases };
         qb._helper.aliasMap = qb._aliases;
         qb.finalized = false;
@@ -1457,22 +1496,24 @@ export class QueryBuilder {
     }
     getQueryBase(processVirtualEntity) {
         const qb = this.platform.createNativeQueryBuilder().setFlags(this.flags);
-        const { subQuery, aliasName, entityName, meta } = this.mainAlias;
+        const { subQuery, aliasName, entityName, meta, rawTableName } = this.mainAlias;
         const requiresAlias = this.finalized && (this._explicitAlias || this.helper.isTableNameAliasRequired(this.type));
         const alias = requiresAlias ? aliasName : undefined;
         const schema = this.getSchema(this.mainAlias);
-        const tableName = subQuery instanceof NativeQueryBuilder
-            ? subQuery.as(aliasName)
-            : subQuery
-                ? raw(`(${subQuery.sql}) as ${this.platform.quoteIdentifier(aliasName)}`, subQuery.params)
-                : this.helper.getTableName(entityName);
+        const tableName = rawTableName
+            ? rawTableName
+            : subQuery instanceof NativeQueryBuilder
+                ? subQuery.as(aliasName)
+                : subQuery
+                    ? raw(`(${subQuery.sql}) as ${this.platform.quoteIdentifier(aliasName)}`, subQuery.params)
+                    : this.helper.getTableName(entityName);
         const joinSchema = this._schema ?? this.em?.schema ?? schema;
         if (meta.virtual && processVirtualEntity) {
             qb.from(raw(this.fromVirtual(meta)), { indexHint: this._indexHint });
         }
         else {
             qb.from(tableName, {
-                schema,
+                schema: rawTableName ? undefined : schema,
                 alias,
                 indexHint: this._indexHint,
             });
@@ -2021,6 +2062,22 @@ export class QueryBuilder {
         aliasName ??= this._mainAlias?.aliasName ?? this.getNextAlias(entityName);
         this.createMainAlias(entityName, aliasName);
     }
+    fromRawTable(tableName, aliasName) {
+        aliasName ??= this._mainAlias?.aliasName ?? this.getNextAlias(tableName);
+        const meta = new EntityMetadata({
+            className: tableName,
+            collection: tableName,
+        });
+        meta.root = meta;
+        this._mainAlias = {
+            aliasName,
+            entityName: tableName,
+            meta,
+            rawTableName: tableName,
+        };
+        this._aliases[aliasName] = this._mainAlias;
+        this._helper = this.createQueryBuilderHelper();
+    }
     createQueryBuilderHelper() {
         return new QueryBuilderHelper(this.mainAlias.entityName, this.mainAlias.aliasName, this._aliases, this.subQueries, this.driver, this._tptAlias);
     }

package/query/QueryBuilderHelper.d.ts

@@ -72,6 +72,7 @@ export interface Alias<T> {
     entityName: EntityName<T>;
     meta: EntityMetadata<T>;
     subQuery?: NativeQueryBuilder | RawQueryFragment;
+    rawTableName?: string;
 }
 export interface OnConflictClause<T> {
     fields: string[] | Raw;

package/query/QueryBuilderHelper.js

@@ -803,7 +803,11 @@ export class QueryBuilderHelper {
     }
     getProperty(field, alias) {
         const entityName = this.aliasMap[alias]?.entityName || this.entityName;
-        const meta = this.metadata.get(entityName);
+        const meta = this.metadata.find(entityName);
+        // raw table name (e.g. CTE) — no metadata available
+        if (!meta) {
+            return undefined;
+        }
         // check if `alias` is not matching an embedded property name instead of alias, e.g. `address.city`
         if (alias) {
             const prop = meta.properties[alias];