@mikro-orm/sql 7.0.0-dev.112 → 7.0.0-dev.114

package/query/QueryBuilder.js

@@ -47,8 +47,6 @@ export class QueryBuilder {
     _populate = [];
     /** @internal */
     _populateMap = {};
-    /** @internal */
-    rawFragments = new Set();
     aliasCounter = 0;
     flags = new Set([QueryFlag.CONVERT_CUSTOM_TYPES]);
     finalized = false;
@@ -277,14 +275,14 @@ export class QueryBuilder {
             }
             filterOptions = QueryHelper.mergePropertyFilters(join.prop.filters, filterOptions);
             const cond = await em.applyFilters(join.prop.type, join.cond, filterOptions, 'read');
-            if (Utils.hasObjectKeys(cond)) {
+            if (Utils.hasObjectKeys(cond) || RawQueryFragment.hasObjectFragments(cond)) {
                 // remove nested filters, we only care about scalars here, nesting would require another join branch
                 for (const key of Object.keys(cond)) {
                     if (Utils.isPlainObject(cond[key]) && Object.keys(cond[key]).every(k => !(Utils.isOperator(k) && !['$some', '$none', '$every'].includes(k)))) {
                         delete cond[key];
                     }
                 }
-                if (Utils.hasObjectKeys(join.cond)) {
+                if (Utils.hasObjectKeys(join.cond) || RawQueryFragment.hasObjectFragments(join.cond)) {
                     /* v8 ignore next */
                     join.cond = { $and: [join.cond, cond] };
                 }
@@ -296,7 +294,7 @@ export class QueryBuilder {
     }
     withSubQuery(subQuery, alias) {
         this.ensureNotFinalized();
-        if (subQuery instanceof RawQueryFragment) {
+        if (isRaw(subQuery)) {
             this.subQueries[alias] = this.platform.formatQuery(subQuery.sql, subQuery.params);
         }
         else {
@@ -306,9 +304,8 @@ export class QueryBuilder {
     }
     where(cond, params, operator) {
         this.ensureNotFinalized();
-        const rawField = RawQueryFragment.getKnownFragment(cond);
-        if (rawField) {
-            const sql = this.platform.formatQuery(rawField.sql, rawField.params);
+        if (isRaw(cond)) {
+            const sql = this.platform.formatQuery(cond.sql, cond.params);
             cond = { [raw(`(${sql})`)]: Utils.asArray(params) };
             operator ??= '$and';
         }
@@ -328,7 +325,7 @@ export class QueryBuilder {
             });
         }
         const op = operator || params;
-        const topLevel = !op || !Utils.hasObjectKeys(this._cond);
+        const topLevel = !op || !(Utils.hasObjectKeys(this._cond) || RawQueryFragment.hasObjectFragments(this._cond));
         const criteriaNode = CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, cond);
         const ignoreBranching = this.__populateWhere === 'infer';
         if ([QueryType.UPDATE, QueryType.DELETE].includes(this.type) && criteriaNode.willAutoJoin(this, undefined, { ignoreBranching })) {
@@ -370,6 +367,7 @@ export class QueryBuilder {
             this._orderBy = [];
         }
         Utils.asArray(orderBy).forEach(o => {
+            this.helper.validateQueryOrder(o);
             const processed = QueryHelper.processWhere({
                 where: o,
                 entityName: this.mainAlias.entityName,
@@ -553,9 +551,10 @@ export class QueryBuilder {
         this._query = {};
         this.finalize();
         const qb = this.getQueryBase(processVirtualEntity);
+        const isNotEmptyObject = (obj) => Utils.hasObjectKeys(obj) || RawQueryFragment.hasObjectFragments(obj);
         Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(this.type, this._cond, qb), this._cond && !this._onConflict);
-        Utils.runIfNotEmpty(() => qb.groupBy(this.prepareFields(this._groupBy, 'groupBy')), this._groupBy);
-        Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(this.type, this._having, qb, undefined, 'having'), this._having);
+        Utils.runIfNotEmpty(() => qb.groupBy(this.prepareFields(this._groupBy, 'groupBy')), isNotEmptyObject(this._groupBy));
+        Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(this.type, this._having, qb, undefined, 'having'), isNotEmptyObject(this._having));
         Utils.runIfNotEmpty(() => {
             const queryOrder = this.helper.getQueryOrder(this.type, this._orderBy, this._populateMap);
             if (queryOrder.length > 0) {
@@ -563,7 +562,7 @@ export class QueryBuilder {
                 qb.orderBy(sql);
                 return;
             }
-        }, this._orderBy);
+        }, isNotEmptyObject(this._orderBy));
         Utils.runIfNotEmpty(() => qb.limit(this._limit), this._limit != null);
         Utils.runIfNotEmpty(() => qb.offset(this._offset), this._offset);
         Utils.runIfNotEmpty(() => qb.comment(this._comments), this._comments);
@@ -573,16 +572,8 @@ export class QueryBuilder {
             this.helper.getLockSQL(qb, this.lockMode, this.lockTables, this._joins);
         }
         this.helper.finalize(this.type, qb, this.mainAlias.metadata, this._data, this._returning);
-        this.clearRawFragmentsCache();
         return this._query.qb = qb;
     }
-    /**
-     * @internal
-     */
-    clearRawFragmentsCache() {
-        this.rawFragments.forEach(key => RawQueryFragment.remove(key));
-        this.rawFragments.clear();
-    }
     /**
      * Returns the query with parameters as wildcards.
      */
@@ -892,16 +883,14 @@ export class QueryBuilder {
         const properties = [
             'flags', '_populate', '_populateWhere', '_populateFilter', '__populateWhere', '_populateMap', '_joins', '_joinedProps', '_cond', '_data', '_orderBy',
             '_schema', '_indexHint', '_cache', 'subQueries', 'lockMode', 'lockTables', '_groupBy', '_having', '_returning',
-            '_comments', '_hintComments', 'rawFragments', 'aliasCounter',
+            '_comments', '_hintComments', 'aliasCounter',
         ];
-        RawQueryFragment.cloneRegistry = this.rawFragments;
         for (const prop of Object.keys(this)) {
             if (reset.includes(prop) || ['_helper', '_query'].includes(prop)) {
                 continue;
             }
             qb[prop] = properties.includes(prop) ? Utils.copy(this[prop]) : this[prop];
         }
-        delete RawQueryFragment.cloneRegistry;
         /* v8 ignore next */
         if (this._fields && !reset.includes('_fields')) {
             qb._fields = [...this._fields];
@@ -935,7 +924,7 @@ export class QueryBuilder {
         if (res instanceof QueryBuilder) {
             return `(${res.getFormattedQuery()}) as ${this.platform.quoteIdentifier(this.alias)}`;
         }
-        if (res instanceof RawQueryFragment) {
+        if (isRaw(res)) {
             const query = this.platform.formatQuery(res.sql, res.params);
             return `(${query}) as ${this.platform.quoteIdentifier(this.alias)}`;
         }
@@ -954,7 +943,7 @@ export class QueryBuilder {
                 prop.targetMeta = field.mainAlias.metadata;
                 field = field.getNativeQuery();
             }
-            if (field instanceof RawQueryFragment) {
+            if (isRaw(field)) {
                 field = this.platform.formatQuery(field.sql, field.params);
             }
             const key = `${this.alias}.${prop.name}#${alias}`;
@@ -1029,11 +1018,6 @@ export class QueryBuilder {
             return this.helper.mapper(name, this.type, undefined, type === 'groupBy' ? null : undefined);
         };
         fields.forEach(field => {
-            const rawField = RawQueryFragment.getKnownFragment(field, false);
-            if (rawField) {
-                ret.push(rawField);
-                return;
-            }
             if (typeof field !== 'string') {
                 ret.push(field);
                 return;
@@ -1088,10 +1072,7 @@ export class QueryBuilder {
         }
         for (const f of Object.keys(this._populateMap)) {
             if (type === 'where' && this._joins[f]) {
-                const cols = this.helper.mapJoinColumns(this.type, this._joins[f]);
-                for (const col of cols) {
-                    ret.push(col);
-                }
+                ret.push(...this.helper.mapJoinColumns(this.type, this._joins[f]));
             }
         }
         return Utils.unique(ret);
@@ -1206,7 +1187,7 @@ export class QueryBuilder {
                 return `${prop.formula(alias)} as ${aliased}`;
             })
                 .filter(field => !this._fields.some(f => {
-                if (f instanceof RawQueryFragment) {
+                if (isRaw(f)) {
                     return f.sql === field && f.params.length === 0;
                 }
                 return f === field;
@@ -1372,11 +1353,10 @@ export class QueryBuilder {
         if (this._orderBy.length > 0) {
             const orderBy = [];
             for (const orderMap of this._orderBy) {
-                for (const [field, direction] of Object.entries(orderMap)) {
-                    if (RawQueryFragment.isKnownFragment(field)) {
-                        const rawField = RawQueryFragment.getKnownFragment(field, false);
-                        this.rawFragments.add(field);
-                        orderBy.push({ [rawField.clone()]: direction });
+                for (const field of Utils.getObjectQueryKeys(orderMap)) {
+                    const direction = orderMap[field];
+                    if (RawQueryFragment.isKnownFragmentSymbol(field)) {
+                        orderBy.push({ [field]: direction });
                         continue;
                     }
                     const [a, f] = this.helper.splitField(field);
@@ -1401,14 +1381,14 @@ export class QueryBuilder {
                     if (typeof field === 'object' && field && '__as' in field) {
                         return field.__as === prop;
                     }
-                    if (field instanceof RawQueryFragment) {
+                    if (isRaw(field)) {
                         // not perfect, but should work most of the time, ideally we should check only the alias (`... as alias`)
                         return field.sql.includes(prop);
                     }
                     return false;
                 });
                 /* v8 ignore next */
-                if (field instanceof RawQueryFragment) {
+                if (isRaw(field)) {
                     innerQuery.select(field);
                 }
                 else if (field instanceof NativeQueryBuilder) {
@@ -1425,7 +1405,7 @@ export class QueryBuilder {
         subSubQuery.select(pks).from(innerQuery);
         this._limit = undefined;
         this._offset = undefined;
-        if (!this._fields.some(f => RawQueryFragment.isKnownFragment(f))) {
+        if (!this._fields.some(field => isRaw(field))) {
             this.pruneExtraJoins(meta);
         }
         const { sql, params } = subSubQuery.compile();

package/query/QueryBuilderHelper.d.ts

@@ -1,4 +1,4 @@
-import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityProperty, type FlatQueryOrderMap, LockMode, type QBFilterQuery, RawQueryFragment } from '@mikro-orm/core';
+import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityProperty, type FlatQueryOrderMap, LockMode, type QBFilterQuery, type QBQueryOrderMap, Raw, type RawQueryFragmentSymbol } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums.js';
 import type { Field, JoinOptions } from '../typings.js';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver.js';
@@ -15,8 +15,8 @@ export declare class QueryBuilderHelper {
     private readonly platform;
     private readonly metadata;
     constructor(entityName: string, alias: string, aliasMap: Dictionary<Alias<any>>, subQueries: Dictionary<string>, driver: AbstractSqlDriver);
-    mapper(field: string | RawQueryFragment, type?: QueryType): string;
-    mapper(field: string | RawQueryFragment, type?: QueryType, value?: any, alias?: string | null): string;
+    mapper(field: string | Raw | RawQueryFragmentSymbol, type?: QueryType): string;
+    mapper(field: string | Raw | RawQueryFragmentSymbol, type?: QueryType, value?: any, alias?: string | null): string;
     processData(data: Dictionary, convertCustomTypes: boolean, multi?: boolean): any;
     joinOneToReference(prop: EntityProperty, ownerAlias: string, alias: string, type: JoinType, cond?: Dictionary, schema?: string): JoinOptions;
     joinManyToOneReference(prop: EntityProperty, ownerAlias: string, alias: string, type: JoinType, cond?: Dictionary, schema?: string): JoinOptions;
@@ -26,7 +26,7 @@ export declare class QueryBuilderHelper {
         sql: string;
         params: unknown[];
     };
-    mapJoinColumns(type: QueryType, join: JoinOptions): (string | RawQueryFragment)[];
+    mapJoinColumns(type: QueryType, join: JoinOptions): (string | Raw)[];
     isOneToOneInverse(field: string, meta?: EntityMetadata): boolean;
     getTableName(entityName: string): string;
     /**
@@ -45,6 +45,7 @@ export declare class QueryBuilderHelper {
     private processObjectSubCondition;
     private getValueReplacement;
     private getOperatorReplacement;
+    validateQueryOrder<T>(orderBy: QBQueryOrderMap<T>): void;
     getQueryOrder(type: QueryType, orderBy: FlatQueryOrderMap | FlatQueryOrderMap[], populate: Dictionary<string>): string[];
     getQueryOrderFromObject(type: QueryType, orderBy: FlatQueryOrderMap, populate: Dictionary<string>): string[];
     finalize(type: QueryType, qb: NativeQueryBuilder, meta?: EntityMetadata, data?: Dictionary, returning?: Field<any>[]): void;
@@ -66,7 +67,7 @@ export interface Alias<T> {
     subQuery?: NativeQueryBuilder;
 }
 export interface OnConflictClause<T> {
-    fields: string[] | RawQueryFragment;
+    fields: string[] | Raw;
     ignore?: boolean;
     merge?: EntityData<T> | Field<T>[];
     where?: QBFilterQuery<T>;

package/query/QueryBuilderHelper.js

@@ -1,4 +1,4 @@
-import { ALIAS_REPLACEMENT, ALIAS_REPLACEMENT_RE, ArrayType, isRaw, LockMode, OptimisticLockError, QueryOperator, QueryOrderNumeric, raw, RawQueryFragment, ReferenceKind, Utils, ValidationError, } from '@mikro-orm/core';
+import { ALIAS_REPLACEMENT, ALIAS_REPLACEMENT_RE, ArrayType, inspect, isRaw, LockMode, OptimisticLockError, QueryOperator, QueryOrderNumeric, raw, Raw, ReferenceKind, Utils, ValidationError, } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums.js';
 import { NativeQueryBuilder } from './NativeQueryBuilder.js';
 /**
@@ -25,6 +25,9 @@ export class QueryBuilderHelper {
         if (isRaw(field)) {
             return raw(field.sql, field.params);
         }
+        if (Raw.isKnownFragmentSymbol(field)) {
+            return Raw.getKnownFragment(field);
+        }
         /* v8 ignore next */
         if (typeof field !== 'string') {
             return field;
@@ -60,16 +63,11 @@ export class QueryBuilderHelper {
             }
             return raw('(' + parts.map(part => this.platform.quoteIdentifier(part)).join(', ') + ')');
         }
-        const rawField = RawQueryFragment.getKnownFragment(field);
-        if (rawField) {
-            return rawField;
-        }
         const aliasPrefix = isTableNameAliasRequired ? this.alias + '.' : '';
         const [a, f] = this.splitField(field);
         const prop = this.getProperty(f, a);
         const fkIdx2 = prop?.fieldNames.findIndex(name => name === f) ?? -1;
         const fkIdx = fkIdx2 === -1 ? 0 : fkIdx2;
-        let ret = field;
         // embeddable nested path instead of a regular property with table alias, reset alias
         if (prop?.name === a && prop.embeddedProps[f]) {
             return aliasPrefix + prop.fieldNames[fkIdx];
@@ -107,10 +105,7 @@ export class QueryBuilderHelper {
             }
             return raw(`${valueSQL} as ${this.platform.quoteIdentifier(alias ?? prop.fieldNames[fkIdx])}`);
         }
-        // do not wrap custom expressions
-        if (!rawField) {
-            ret = this.prefix(field, false, false, fkIdx);
-        }
+        let ret = this.prefix(field, false, false, fkIdx);
         if (alias) {
             ret += ' as ' + alias;
         }
@@ -243,7 +238,7 @@ export class QueryBuilderHelper {
         this.alias = oldAlias;
         if (subquery.sql) {
             conditions.push(subquery.sql);
-            params.push(...subquery.params);
+            subquery.params.forEach(p => params.push(p));
         }
         if (conditions.length > 0) {
             sql += ` on ${conditions.join(' and ')}`;
@@ -332,7 +327,7 @@ export class QueryBuilderHelper {
     _appendQueryCondition(type, cond, operator) {
         const parts = [];
         const params = [];
-        for (const k of Object.keys(cond)) {
+        for (const k of Utils.getObjectQueryKeys(cond)) {
             if (k === '$and' || k === '$or') {
                 if (operator) {
                     this.append(() => this.appendGroupCondition(type, k, cond[k]), parts, params, operator);
@@ -344,7 +339,7 @@ export class QueryBuilderHelper {
             if (k === '$not') {
                 const res = this._appendQueryCondition(type, cond[k]);
                 parts.push(`not (${res.sql})`);
-                params.push(...res.params);
+                res.params.forEach(p => params.push(p));
                 continue;
             }
             this.append(() => this.appendQuerySubCondition(type, cond, k), parts, params);
@@ -362,7 +357,6 @@ export class QueryBuilderHelper {
     appendQuerySubCondition(type, cond, key) {
         const parts = [];
         const params = [];
-        const fields = Utils.splitPrimaryKeys(key);
         if (this.isSimpleRegExp(cond[key])) {
             parts.push(`${this.platform.quoteIdentifier(this.mapper(key, type))} like ?`);
             params.push(this.getRegExpParam(cond[key]));
@@ -372,19 +366,21 @@ export class QueryBuilderHelper {
             return this.processObjectSubCondition(cond, key, type);
         }
         const op = cond[key] === null ? 'is' : '=';
-        const raw = RawQueryFragment.getKnownFragment(key);
-        if (raw) {
+        if (Raw.isKnownFragmentSymbol(key)) {
+            const raw = Raw.getKnownFragment(key);
             const sql = raw.sql.replaceAll(ALIAS_REPLACEMENT, this.alias);
             const value = Utils.asArray(cond[key]);
             params.push(...raw.params);
             if (value.length > 0) {
-                const val = this.getValueReplacement(fields, value[0], params, key);
+                const k = key;
+                const val = this.getValueReplacement([k], value[0], params, k);
                 parts.push(`${sql} ${op} ${val}`);
                 return { sql: parts.join(' and '), params };
             }
             parts.push(sql);
             return { sql: parts.join(' and '), params };
         }
+        const fields = Utils.splitPrimaryKeys(key);
         if (this.subQueries[key]) {
             const val = this.getValueReplacement(fields, cond[key], params, key);
             parts.push(`(${this.subQueries[key]}) ${op} ${val}`);
@@ -404,9 +400,7 @@ export class QueryBuilderHelper {
         }
         // grouped condition for one field, e.g. `{ age: { $gte: 10, $lt: 50 } }`
         if (size > 1) {
-            const rawField = RawQueryFragment.getKnownFragment(key);
             const subCondition = Object.entries(value).map(([subKey, subValue]) => {
-                key = rawField?.clone().toString() ?? key;
                 return ({ [key]: { [subKey]: subValue } });
             });
             for (const sub of subCondition) {
@@ -424,7 +418,8 @@ export class QueryBuilderHelper {
             throw ValidationError.invalidQueryCondition(cond);
         }
         const replacement = this.getOperatorReplacement(op, value);
-        const fields = Utils.splitPrimaryKeys(key);
+        const rawField = Raw.isKnownFragmentSymbol(key);
+        const fields = rawField ? [key] : Utils.splitPrimaryKeys(key);
         if (fields.length > 1 && Array.isArray(value[op])) {
             const singleTuple = !value[op].every((v) => Array.isArray(v));
             if (!this.platform.allowsComparingTuples()) {
@@ -452,12 +447,12 @@ export class QueryBuilderHelper {
             parts.push(`(${this.subQueries[key]}) ${replacement} ${val}`);
             return { sql: parts.join(' and '), params };
         }
-        const [a, f] = this.splitField(key);
-        const prop = this.getProperty(f, a);
+        const [a, f] = rawField ? [] : this.splitField(key);
+        const prop = f && this.getProperty(f, a);
         if (op === '$fulltext') {
             /* v8 ignore next */
             if (!prop) {
-                throw new Error(`Cannot use $fulltext operator on ${key}, property not found`);
+                throw new Error(`Cannot use $fulltext operator on ${String(key)}, property not found`);
             }
             const { sql, params: params2 } = raw(this.platform.getFullTextWhereClause(prop), {
                 column: this.mapper(key, type, undefined, null),
@@ -469,7 +464,7 @@ export class QueryBuilderHelper {
         else if (['$in', '$nin'].includes(op) && Array.isArray(value[op]) && value[op].length === 0) {
             parts.push(`1 = ${op === '$in' ? 0 : 1}`);
         }
-        else if (value[op] instanceof RawQueryFragment || value[op] instanceof NativeQueryBuilder) {
+        else if (value[op] instanceof Raw || value[op] instanceof NativeQueryBuilder) {
             const query = value[op] instanceof NativeQueryBuilder ? value[op].toRaw() : value[op];
             const mappedKey = this.mapper(key, type, query, null);
             let sql = query.sql;
@@ -501,7 +496,7 @@ export class QueryBuilderHelper {
                 params.push(item);
             }
             else {
-                value.forEach(v => params.push(v));
+                value.forEach(p => params.push(p));
             }
             return `(${value.map(() => '?').join(', ')})`;
         }
@@ -528,6 +523,31 @@ export class QueryBuilderHelper {
         }
         return replacement;
     }
+    validateQueryOrder(orderBy) {
+        const strKeys = [];
+        const rawKeys = [];
+        for (const key of Utils.getObjectQueryKeys(orderBy)) {
+            const raw = Raw.getKnownFragment(key);
+            if (raw) {
+                rawKeys.push(raw);
+            }
+            else {
+                strKeys.push(key);
+            }
+        }
+        if (strKeys.length > 0 && rawKeys.length > 0) {
+            const example = [
+                ...strKeys.map(key => ({ [key]: orderBy[key] })),
+                ...rawKeys.map(rawKey => ({ [`raw('${rawKey.sql}')`]: orderBy[rawKey] })),
+            ];
+            throw new Error([
+                `Invalid "orderBy": You are mixing field-based keys and raw SQL fragments inside a single object.`,
+                `This is not allowed because object key order cannot reliably preserve evaluation order.`,
+                `To fix this, split them into separate objects inside an array:\n`,
+                `orderBy: ${inspect(example, { depth: 5 }).replace(/"raw\('(.*)'\)"/g, `[raw('$1')]`)}`,
+            ].join('\n'));
+        }
+    }
     getQueryOrder(type, orderBy, populate) {
         if (Array.isArray(orderBy)) {
             return orderBy.flatMap(o => this.getQueryOrder(type, o, populate));
@@ -536,11 +556,11 @@ export class QueryBuilderHelper {
     }
     getQueryOrderFromObject(type, orderBy, populate) {
         const ret = [];
-        for (const key of Object.keys(orderBy)) {
+        for (const key of Utils.getObjectQueryKeys(orderBy)) {
             const direction = orderBy[key];
             const order = typeof direction === 'number' ? QueryOrderNumeric[direction] : direction;
-            const raw = RawQueryFragment.getKnownFragment(key);
-            if (raw) {
+            if (Raw.isKnownFragmentSymbol(key)) {
+                const raw = Raw.getKnownFragment(key);
                 ret.push(...this.platform.getOrderByExpression(this.platform.formatQuery(raw.sql, raw.params), order));
                 continue;
             }
@@ -549,7 +569,7 @@ export class QueryBuilderHelper {
                 let [alias, field] = this.splitField(f, true);
                 alias = populate[alias] || alias;
                 const prop = this.getProperty(field, alias);
-                const noPrefix = (prop?.persist === false && !prop.formula && !prop.embedded) || RawQueryFragment.isKnownFragment(f);
+                const noPrefix = (prop?.persist === false && !prop.formula && !prop.embedded) || Raw.isKnownFragment(f);
                 const column = this.mapper(noPrefix ? field : `${alias}.${field}`, type, undefined, null);
                 /* v8 ignore next */
                 const rawColumn = typeof column === 'string' ? column.split('.').map(e => this.platform.quoteIdentifier(e)).join('.') : column;
@@ -652,7 +672,7 @@ export class QueryBuilderHelper {
         if (!this.isPrefixed(field)) {
             const alias = always ? (quote ? this.alias : this.platform.quoteIdentifier(this.alias)) + '.' : '';
             const fieldName = this.fieldName(field, this.alias, always, idx);
-            if (fieldName instanceof RawQueryFragment) {
+            if (fieldName instanceof Raw) {
                 return fieldName.sql;
             }
             ret = alias + fieldName;
@@ -661,7 +681,7 @@ export class QueryBuilderHelper {
             const [a, ...rest] = field.split('.');
             const f = rest.join('.');
             const fieldName = this.fieldName(f, a, always, idx);
-            if (fieldName instanceof RawQueryFragment) {
+            if (fieldName instanceof Raw) {
                 return fieldName.sql;
             }
             ret = a + '.' + fieldName;
@@ -683,7 +703,7 @@ export class QueryBuilderHelper {
         }
         for (const sub of subCondition) {
             // skip nesting parens if the value is simple = scalar or object without operators or with only single key, being the operator
-            const keys = Object.keys(sub);
+            const keys = Utils.getObjectQueryKeys(sub);
             const val = sub[keys[0]];
             const simple = !Utils.isPlainObject(val) || Utils.getObjectKeysSize(val) === 1 || Object.keys(val).every(k => !Utils.isOperator(k));
             if (keys.length === 1 && simple) {

package/schema/DatabaseSchema.js

@@ -1,4 +1,4 @@
-import { ReferenceKind, RawQueryFragment, } from '@mikro-orm/core';
+import { ReferenceKind, isRaw, } from '@mikro-orm/core';
 import { DatabaseTable } from './DatabaseTable.js';
 /**
  * @internal
@@ -108,15 +108,11 @@ export class DatabaseSchema {
             table.addIndex(meta, { properties: meta.props.filter(prop => prop.primary).map(prop => prop.name) }, 'primary');
             for (const check of meta.checks) {
                 const columnName = check.property ? meta.properties[check.property].fieldNames[0] : undefined;
-                let expression = check.expression;
-                const raw = RawQueryFragment.getKnownFragment(expression);
-                if (raw) {
-                    expression = platform.formatQuery(raw.sql, raw.params);
-                }
+                const expression = isRaw(check.expression) ? platform.formatQuery(check.expression.sql, check.expression.params) : check.expression;
                 table.addCheck({
                     name: check.name,
                     expression,
-                    definition: `check (${check.expression})`,
+                    definition: `check (${expression})`,
                     columnName,
                 });
             }

package/schema/SchemaHelper.d.ts

@@ -1,4 +1,4 @@
-import { type Connection, type Dictionary } from '@mikro-orm/core';
+import { type Connection, type Dictionary, RawQueryFragment } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../typings.js';
@@ -39,7 +39,7 @@ export declare abstract class SchemaHelper {
     getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
     protected mapIndexes(indexes: IndexDef[]): Promise<IndexDef[]>;
     mapForeignKeys(fks: any[], tableName: string, schemaName?: string): Dictionary;
-    normalizeDefaultValue(defaultValue: string, length?: number, defaultValues?: Dictionary<string[]>): string | number;
+    normalizeDefaultValue(defaultValue: string | RawQueryFragment, length?: number, defaultValues?: Dictionary<string[]>): string | number;
     getCreateDatabaseSQL(name: string): string;
     getDropDatabaseSQL(name: string): string;
     getCreateNamespaceSQL(name: string): string;

package/schema/SchemaHelper.js

@@ -323,9 +323,8 @@ export class SchemaHelper {
         if (defaultValue == null) {
             return defaultValue;
         }
-        const raw = RawQueryFragment.getKnownFragment(defaultValue);
-        if (raw) {
-            return this.platform.formatQuery(raw.sql, raw.params);
+        if (defaultValue instanceof RawQueryFragment) {
+            return this.platform.formatQuery(defaultValue.sql, defaultValue.params);
         }
         const genericValue = defaultValue.replace(/\(\d+\)/, '(?)').toLowerCase();
         const norm = defaultValues[genericValue];