@mikro-orm/core 7.0.0-dev.113 → 7.0.0-dev.114

package/EntityManager.js

@@ -4,7 +4,7 @@ import { Cursor } from './utils/Cursor.js';
 import { DataloaderUtils } from './utils/DataloaderUtils.js';
 import { QueryHelper } from './utils/QueryHelper.js';
 import { TransactionContext } from './utils/TransactionContext.js';
-import { isRaw, RawQueryFragment } from './utils/RawQueryFragment.js';
+import { isRaw, Raw } from './utils/RawQueryFragment.js';
 import { EntityFactory } from './entity/EntityFactory.js';
 import { EntityAssigner } from './entity/EntityAssigner.js';
 import { validateEmptyWhere, validateParams, validatePrimaryKey, validateProperty } from './entity/validators.js';
@@ -457,7 +457,7 @@ export class EntityManager {
             }
             ret.push(cond);
         }
-        const conds = [...ret, where].filter(c => Utils.hasObjectKeys(c));
+        const conds = [...ret, where].filter(c => Utils.hasObjectKeys(c) || Raw.hasObjectFragments(c));
         return conds.length > 1 ? { $and: conds } : conds[0];
     }
     /**
@@ -468,12 +468,10 @@ export class EntityManager {
         const em = this.getContext(false);
         await em.tryFlush(entityName, options);
         options.flushMode = 'commit'; // do not try to auto flush again
-        return RawQueryFragment.run(async () => {
-            return Promise.all([
-                em.find(entityName, where, options),
-                em.count(entityName, where, options),
-            ]);
-        });
+        return Promise.all([
+            em.find(entityName, where, options),
+            em.count(entityName, where, options),
+        ]);
     }
     /**
      * Calls `em.find()` and `em.count()` with the same arguments (where applicable) and returns the results as {@apilink Cursor} object.
@@ -536,7 +534,7 @@ export class EntityManager {
         entityName = Utils.className(entityName);
         options.overfetch ??= true;
         options.where ??= {};
-        if (Utils.isEmpty(options.orderBy)) {
+        if (Utils.isEmpty(options.orderBy) && !Raw.hasObjectFragments(options.orderBy)) {
             throw new Error('Explicit `orderBy` option required');
         }
         const [entities, count] = options.includeCount !== false

package/drivers/DatabaseDriver.js

@@ -152,7 +152,7 @@ export class DatabaseDriver {
         }
         const createOrderBy = (prop, direction) => {
             if (Utils.isPlainObject(direction)) {
-                const value = Utils.keys(direction).reduce((o, key) => {
+                const value = Utils.getObjectQueryKeys(direction).reduce((o, key) => {
                     Object.assign(o, createOrderBy(key, direction[key]));
                     return o;
                 }, {});

package/drivers/IDatabaseDriver.d.ts

@@ -8,7 +8,7 @@ import type { EntityManager } from '../EntityManager.js';
 import type { DriverException } from '../exceptions.js';
 import type { Configuration } from '../utils/Configuration.js';
 import type { LoggingOptions, LogContext } from '../logging/Logger.js';
-import type { RawQueryFragment } from '../utils/RawQueryFragment.js';
+import type { Raw } from '../utils/RawQueryFragment.js';
 export declare const EntityManagerType: unique symbol;
 export interface IDatabaseDriver<C extends Connection = Connection> {
     [EntityManagerType]: EntityManager<this>;
@@ -189,7 +189,7 @@ export interface NativeInsertUpdateManyOptions<T> extends NativeInsertUpdateOpti
     processCollections?: boolean;
 }
 export interface UpsertOptions<Entity, Fields extends string = never> extends Omit<NativeInsertUpdateOptions<Entity>, 'upsert'> {
-    onConflictFields?: (keyof Entity)[] | RawQueryFragment;
+    onConflictFields?: (keyof Entity)[] | Raw;
     onConflictAction?: 'ignore' | 'merge';
     onConflictMergeFields?: AutoPath<Entity, Fields, `${PopulatePath.ALL}`>[];
     onConflictExcludeFields?: AutoPath<Entity, Fields, `${PopulatePath.ALL}`>[];

package/entity/Collection.js

@@ -4,6 +4,7 @@ import { DataloaderType, ReferenceKind } from '../enums.js';
 import { Reference } from './Reference.js';
 import { helper, wrap } from './wrap.js';
 import { QueryHelper } from '../utils/QueryHelper.js';
+import { Raw } from '../utils/RawQueryFragment.js';
 import { inspect } from '../logging/inspect.js';
 export class Collection {
     owner;
@@ -298,7 +299,7 @@ export class Collection {
         return cond;
     }
     createOrderBy(orderBy = []) {
-        if (Utils.isEmpty(orderBy) && this.property.orderBy) {
+        if (Utils.isEmpty(orderBy) && !Raw.hasObjectFragments(orderBy) && this.property.orderBy) {
             orderBy = this.property.orderBy;
         }
         return Utils.asArray(orderBy);

package/entity/EntityLoader.js

@@ -4,8 +4,8 @@ import { ValidationError } from '../errors.js';
 import { LoadStrategy, PopulatePath, ReferenceKind, } from '../enums.js';
 import { Reference } from './Reference.js';
 import { helper } from './wrap.js';
-import { raw, RawQueryFragment } from '../utils/RawQueryFragment.js';
 import { expandDotPaths } from './utils.js';
+import { Raw } from '../utils/RawQueryFragment.js';
 export class EntityLoader {
     em;
     metadata;
@@ -237,26 +237,12 @@ export class EntityLoader {
         if (typeof populateWhere === 'object') {
             populateWhere = await this.extractChildCondition({ where: populateWhere }, prop);
         }
-        if (!Utils.isEmpty(prop.where)) {
+        if (!Utils.isEmpty(prop.where) || Raw.hasObjectFragments(prop.where)) {
             where = { $and: [where, prop.where] };
         }
-        const propOrderBy = [];
-        if (prop.orderBy) {
-            for (const item of Utils.asArray(prop.orderBy)) {
-                for (const field of Utils.keys(item)) {
-                    const rawField = RawQueryFragment.getKnownFragment(field, false);
-                    if (rawField) {
-                        const raw2 = raw(rawField.sql, rawField.params);
-                        propOrderBy.push({ [raw2.toString()]: item[field] });
-                        continue;
-                    }
-                    propOrderBy.push({ [field]: item[field] });
-                }
-            }
-        }
-        const orderBy = [...Utils.asArray(options.orderBy), ...propOrderBy].filter((order, idx, array) => {
+        const orderBy = [...Utils.asArray(options.orderBy), ...Utils.asArray(prop.orderBy)].filter((order, idx, array) => {
             // skip consecutive ordering with the same key to get around mongo issues
-            return idx === 0 || !Utils.equals(Object.keys(array[idx - 1]), Object.keys(order));
+            return idx === 0 || !Utils.equals(Utils.getObjectQueryKeys(array[idx - 1]), Utils.getObjectQueryKeys(order));
         });
         const items = await this.em.find(prop.type, where, {
             filters, convertCustomTypes, lockMode, populateWhere, logging,
@@ -424,7 +410,7 @@ export class EntityLoader {
             if (where[op]) {
                 const child = where[op]
                     .map((cond) => cond[prop.name])
-                    .filter((sub) => sub != null && !(Utils.isPlainObject(sub) && Object.keys(sub).every(key => Utils.isOperator(key, false))))
+                    .filter((sub) => sub != null && !(Utils.isPlainObject(sub) && Utils.getObjectQueryKeys(sub).every(key => Utils.isOperator(key, false))))
                     .map((cond) => {
                     if (Utils.isPrimaryKey(cond)) {
                         return { [pk]: cond };

package/entity/validators.js

@@ -1,6 +1,6 @@
 import { Utils } from '../utils/Utils.js';
 import { ValidationError } from '../errors.js';
-import { isRaw } from '../utils/RawQueryFragment.js';
+import { isRaw, Raw } from '../utils/RawQueryFragment.js';
 import { SCALAR_TYPES } from '../enums.js';
 /** @internal */
 export function validateProperty(prop, givenValue, entity) {
@@ -59,7 +59,7 @@ export function validatePrimaryKey(entity, meta) {
 }
 /** @internal */
 export function validateEmptyWhere(where) {
-    if (Utils.isEmpty(where)) {
+    if (Utils.isEmpty(where) && !Raw.hasObjectFragments(where)) {
         throw new Error(`You cannot call 'EntityManager.findOne()' with empty 'where' parameter`);
     }
 }

package/hydration/ObjectHydrator.js

@@ -3,7 +3,7 @@ import { Collection } from '../entity/Collection.js';
 import { Reference, ScalarReference } from '../entity/Reference.js';
 import { parseJsonSafe, Utils } from '../utils/Utils.js';
 import { ReferenceKind } from '../enums.js';
-import { RawQueryFragment } from '../utils/RawQueryFragment.js';
+import { Raw } from '../utils/RawQueryFragment.js';
 export class ObjectHydrator extends Hydrator {
     hydrators = {
         'full~true': new Map(),
@@ -52,7 +52,7 @@ export class ObjectHydrator extends Hydrator {
         const registerCustomType = (prop, convertorKey, method, context) => {
             context.set(`${method}_${convertorKey}`, (val) => {
                 /* v8 ignore next */
-                if (RawQueryFragment.isKnownFragment(val)) {
+                if (Raw.isKnownFragment(val)) {
                     return val;
                 }
                 return prop.customType[method](val, this.platform, { mode: 'serialization' });

package/metadata/MetadataDiscovery.js

@@ -7,7 +7,7 @@ import { Cascade, ReferenceKind } from '../enums.js';
 import { MetadataError } from '../errors.js';
 import { t, Type } from '../types/index.js';
 import { colors } from '../logging/colors.js';
-import { raw, RawQueryFragment } from '../utils/RawQueryFragment.js';
+import { raw, Raw } from '../utils/RawQueryFragment.js';
 export class MetadataDiscovery {
     metadata;
     platform;
@@ -1025,7 +1025,7 @@ export class MetadataDiscovery {
             return;
         }
         let val = prop.default;
-        const raw = RawQueryFragment.getKnownFragment(val);
+        const raw = Raw.getKnownFragment(val);
         if (raw) {
             prop.defaultRaw = this.platform.formatQuery(raw.sql, raw.params);
             return;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.113",
+  "version": "7.0.0-dev.114",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "exports": {
     "./package.json": "./package.json",

package/platforms/Platform.js

@@ -5,7 +5,7 @@ import { ExceptionConverter } from './ExceptionConverter.js';
 import { ArrayType, BigIntType, BlobType, BooleanType, CharacterType, DateTimeType, DateType, DecimalType, DoubleType, EnumType, FloatType, IntegerType, IntervalType, JsonType, MediumIntType, SmallIntType, StringType, TextType, TimeType, TinyIntType, Type, Uint8ArrayType, UnknownType, UuidType, } from '../types/index.js';
 import { parseJsonSafe } from '../utils/Utils.js';
 import { ReferenceKind } from '../enums.js';
-import { RawQueryFragment } from '../utils/RawQueryFragment.js';
+import { Raw } from '../utils/RawQueryFragment.js';
 export const JsonProperty = Symbol('JsonProperty');
 export class Platform {
     exceptionConverter = new ExceptionConverter();
@@ -330,7 +330,7 @@ export class Platform {
         return value;
     }
     quoteIdentifier(id, quote = '`') {
-        const raw = RawQueryFragment.getKnownFragment(id);
+        const raw = Raw.getKnownFragment(id);
         if (raw) {
             return this.formatQuery(raw.sql, raw.params);
         }

package/typings.d.ts

@@ -14,7 +14,7 @@ import type { EntitySchema } from './metadata/EntitySchema.js';
 import type { Type, types } from './types/index.js';
 import type { Platform } from './platforms/Platform.js';
 import type { Configuration } from './utils/Configuration.js';
-import type { RawQueryFragment } from './utils/RawQueryFragment.js';
+import type { Raw } from './utils/RawQueryFragment.js';
 import type { EntityManager } from './EntityManager.js';
 import type { EventSubscriber } from './events/EventSubscriber.js';
 import type { FilterOptions, FindOneOptions, FindOptions, LoadHint } from './drivers/IDatabaseDriver.js';
@@ -314,7 +314,7 @@ type TableName = {
     schema?: string;
     toString: () => string;
 };
-export type IndexCallback<T> = (table: TableName, columns: Record<PropertyName<T>, string>, indexName: string) => string | RawQueryFragment;
+export type IndexCallback<T> = (table: TableName, columns: Record<PropertyName<T>, string>, indexName: string) => string | Raw;
 export type CheckCallback<T> = (columns: Record<PropertyName<T>, string>) => string;
 export type GeneratedColumnCallback<T> = (columns: Record<keyof T, string>) => string;
 export interface CheckConstraint<T = any> {
@@ -443,7 +443,7 @@ export interface EntityMetadata<T = any> {
     schema?: string;
     pivotTable?: boolean;
     virtual?: boolean;
-    expression?: string | ((em: any, where: ObjectQuery<T>, options: FindOptions<T, any, any, any>, stream?: boolean) => MaybePromise<RawQueryFragment | object | string>);
+    expression?: string | ((em: any, where: ObjectQuery<T>, options: FindOptions<T, any, any, any>, stream?: boolean) => MaybePromise<Raw | object | string>);
     discriminatorColumn?: EntityKey<T> | AnyString;
     discriminatorValue?: number | string;
     discriminatorMap?: Dictionary<string>;

package/utils/Cursor.js

@@ -2,7 +2,7 @@ import { Utils } from './Utils.js';
 import { ReferenceKind } from '../enums.js';
 import { Reference } from '../entity/Reference.js';
 import { helper } from '../entity/wrap.js';
-import { RawQueryFragment } from '../utils/RawQueryFragment.js';
+import { Raw } from '../utils/RawQueryFragment.js';
 import { CursorError } from '../errors.js';
 import { inspect } from '../logging/inspect.js';
 /**
@@ -147,8 +147,8 @@ export class Cursor {
     static getDefinition(meta, orderBy) {
         return Utils.asArray(orderBy).flatMap(order => {
             const ret = [];
-            for (const key of Utils.keys(order)) {
-                if (RawQueryFragment.isKnownFragment(key)) {
+            for (const key of Utils.getObjectQueryKeys(order)) {
+                if (Raw.isKnownFragmentSymbol(key)) {
                     ret.push([key, order[key]]);
                     continue;
                 }

package/utils/EntityComparator.js

@@ -2,7 +2,7 @@ import { clone } from './clone.js';
 import { ReferenceKind } from '../enums.js';
 import { compareArrays, compareBooleans, compareBuffers, compareObjects, equals, parseJsonSafe, Utils } from './Utils.js';
 import { JsonType } from '../types/JsonType.js';
-import { RawQueryFragment } from './RawQueryFragment.js';
+import { Raw } from './RawQueryFragment.js';
 export class EntityComparator {
     metadata;
     platform;
@@ -482,7 +482,7 @@ export class EntityComparator {
         const convertorKey = this.safeKey(prop.name);
         context.set(`convertToDatabaseValue_${convertorKey}`, (val) => {
             /* v8 ignore next */
-            if (RawQueryFragment.isKnownFragment(val)) {
+            if (Raw.isKnownFragment(val)) {
                 return val;
             }
             return prop.customType.convertToDatabaseValue(val, this.platform, { mode: 'serialization' });
@@ -597,7 +597,12 @@ export class EntityComparator {
         if (prop.customType) {
             if (prop.customType.compareValues) {
                 const idx = this.tmpIndex++;
-                context.set(`compareValues_${idx}`, (a, b) => prop.customType.compareValues(a, b));
+                context.set(`compareValues_${idx}`, (a, b) => {
+                    if (Raw.isKnownFragment(a) || Raw.isKnownFragment(b)) {
+                        return Raw.getKnownFragment(a) === Raw.getKnownFragment(b);
+                    }
+                    return prop.customType.compareValues(a, b);
+                });
                 return this.getGenericComparator(this.wrap(prop.name), `!compareValues_${idx}(last${this.wrap(prop.name)}, current${this.wrap(prop.name)})`);
             }
             type = prop.customType.compareAsType().toLowerCase();

package/utils/QueryHelper.d.ts

@@ -6,7 +6,7 @@ import type { FilterOptions } from '../drivers/IDatabaseDriver.js';
 export declare class QueryHelper {
     static readonly SUPPORTED_OPERATORS: string[];
     static processParams(params: unknown): any;
-    static processObjectParams<T extends object>(params?: T): T;
+    static processObjectParams<T extends Dictionary>(params?: T): T;
     /**
      * converts `{ account: { $or: [ [Object], [Object] ] } }`
      * to `{ $or: [ { account: [Object] }, { account: [Object] } ] }`

package/utils/QueryHelper.js

@@ -3,7 +3,7 @@ import { Utils } from './Utils.js';
 import { ARRAY_OPERATORS, GroupOperator, JSON_KEY_OPERATORS, ReferenceKind } from '../enums.js';
 import { JsonType } from '../types/JsonType.js';
 import { helper } from '../entity/wrap.js';
-import { isRaw, RawQueryFragment } from './RawQueryFragment.js';
+import { isRaw, Raw } from './RawQueryFragment.js';
 /** @internal */
 export class QueryHelper {
     static SUPPORTED_OPERATORS = ['>', '<', '<=', '>=', '!', '!='];
@@ -29,7 +29,7 @@ export class QueryHelper {
         return params;
     }
     static processObjectParams(params = {}) {
-        Utils.keys(params).forEach(k => {
+        Utils.getObjectQueryKeys(params).forEach(k => {
             params[k] = QueryHelper.processParams(params[k]);
         });
         return params;
@@ -138,12 +138,10 @@ export class QueryHelper {
         if (!Utils.isPlainObject(where)) {
             return where;
         }
-        return Object.keys(where).reduce((o, key) => {
+        return Utils.getObjectQueryKeys(where).reduce((o, key) => {
             let value = where[key];
-            const prop = this.findProperty(key, options);
-            const keys = prop?.joinColumns?.length ?? 0;
-            const composite = keys > 1;
-            if (Array.isArray(value) && value.length === 0 && RawQueryFragment.isKnownFragment(key)) {
+            const customExpression = Raw.isKnownFragmentSymbol(key);
+            if (Array.isArray(value) && value.length === 0 && customExpression) {
                 o[key] = value;
                 return o;
             }
@@ -157,6 +155,9 @@ export class QueryHelper {
                 o[rootPrimaryKey] = { [key]: QueryHelper.processWhere({ ...options, where: value, root: false }) };
                 return o;
             }
+            const prop = customExpression ? null : this.findProperty(key, options);
+            const keys = prop?.joinColumns?.length ?? 0;
+            const composite = keys > 1;
             if (prop?.customType && convertCustomTypes && !isRaw(value)) {
                 value = QueryHelper.processCustomType(prop, value, platform, undefined, true);
             }
@@ -164,7 +165,7 @@ export class QueryHelper {
             if (isJsonProperty && prop?.kind !== ReferenceKind.EMBEDDED) {
                 return this.processJsonCondition(o, value, [prop.fieldNames[0]], platform, aliased);
             }
-            if (Array.isArray(value) && !Utils.isOperator(key) && !QueryHelper.isSupportedOperator(key) && !key.includes('?') && options.type !== 'orderBy') {
+            if (Array.isArray(value) && !Utils.isOperator(key) && !QueryHelper.isSupportedOperator(key) && !(customExpression && Raw.getKnownFragment(key).params.length > 0) && options.type !== 'orderBy') {
                 // comparing single composite key - use $eq instead of $in
                 const op = composite && !value.every(v => Array.isArray(v)) ? '$eq' : '$in';
                 o[key] = { [op]: value };
@@ -231,8 +232,8 @@ export class QueryHelper {
     }
     static processCustomType(prop, cond, platform, key, fromQuery) {
         if (Utils.isPlainObject(cond)) {
-            return Utils.keys(cond).reduce((o, k) => {
-                if (Utils.isOperator(k, true) || prop.referencedPKs?.includes(k)) {
+            return Utils.getObjectQueryKeys(cond).reduce((o, k) => {
+                if (!Raw.isKnownFragmentSymbol(k) && (Utils.isOperator(k, true) || prop.referencedPKs?.includes(k))) {
                     o[k] = QueryHelper.processCustomType(prop, cond[k], platform, k, fromQuery);
                 }
                 else {

package/utils/RawQueryFragment.d.ts

@@ -1,23 +1,22 @@
 import type { AnyString, Dictionary, EntityKey } from '../typings.js';
+declare const rawFragmentSymbolBrand: unique symbol;
+export type RawQueryFragmentSymbol = symbol & {
+    readonly [rawFragmentSymbolBrand]: true;
+};
 export declare class RawQueryFragment {
     #private;
     readonly sql: string;
     readonly params: unknown[];
-    static cloneRegistry?: Set<string>;
     constructor(sql: string, params?: unknown[]);
+    get key(): RawQueryFragmentSymbol;
     as(alias: string): RawQueryFragment;
-    valueOf(): string;
+    [Symbol.toPrimitive](hint: 'string'): RawQueryFragmentSymbol;
+    get [Symbol.toStringTag](): string;
     toJSON(): string;
-    toString(): string;
-    clone(): RawQueryFragment;
-    static run<T>(cb: (...args: any[]) => Promise<T>): Promise<T>;
-    /**
-     * @internal allows testing we don't leak memory, as the raw fragments cache needs to be cleared automatically
-     */
-    static checkCacheSize(): number;
-    static isKnownFragment(key: string | RawQueryFragment): boolean;
-    static getKnownFragment(key: string | RawQueryFragment, cleanup?: boolean): RawQueryFragment | undefined;
-    static remove(key: string): void;
+    static isKnownFragmentSymbol(key: unknown): key is RawQueryFragmentSymbol;
+    static hasObjectFragments(object: unknown): boolean;
+    static isKnownFragment(key: unknown): key is RawQueryFragment | symbol;
+    static getKnownFragment(key: unknown): RawQueryFragment | undefined;
 }
 export { RawQueryFragment as Raw };
 export declare function isRaw(value: unknown): value is RawQueryFragment;

package/utils/RawQueryFragment.js

@@ -1,81 +1,58 @@
 import { Utils } from './Utils.js';
-import { createAsyncContext } from './AsyncContext.js';
 export class RawQueryFragment {
     sql;
     params;
-    static #rawQueryCache = new Map();
-    static #storage = createAsyncContext();
-    static #index = 0n;
-    static cloneRegistry;
-    #used = 0;
+    // holds a weak reference to fragments used as object keys
+    static #rawQueryReferences = new WeakMap();
     #key;
     constructor(sql, params = []) {
         this.sql = sql;
         this.params = params;
-        this.#key = `[raw]: ${this.sql} (#${RawQueryFragment.#index++})`;
+    }
+    get key() {
+        if (!this.#key) {
+            this.#key = Symbol(this.toJSON());
+            RawQueryFragment.#rawQueryReferences.set(this.#key, this);
+        }
+        return this.#key;
     }
     as(alias) {
         return new RawQueryFragment(`${this.sql} as ??`, [...this.params, alias]);
     }
-    valueOf() {
+    [Symbol.toPrimitive](hint) {
+        // if a fragment is converted to string (used as an object key), return a unique symbol
+        // and save a weak reference to map so we can retrieve it when compiling the query
+        if (hint === 'string') {
+            return this.key;
+        }
         throw new Error(`Trying to modify raw SQL fragment: '${this.sql}'`);
     }
-    toJSON() {
-        return this.#key;
-    }
-    toString() {
-        RawQueryFragment.#rawQueryCache.set(this.#key, this);
-        this.#used++;
-        return this.#key;
+    get [Symbol.toStringTag]() {
+        return this.toJSON();
     }
-    clone() {
-        RawQueryFragment.cloneRegistry?.add(this.#key);
-        return new RawQueryFragment(this.sql, this.params);
+    toJSON() {
+        return `raw('${this.sql}')`;
     }
-    static async run(cb) {
-        const removeStack = new Set();
-        const res = await this.#storage.run(removeStack, cb);
-        removeStack.forEach(key => RawQueryFragment.remove(key));
-        removeStack.clear();
-        return res;
+    static isKnownFragmentSymbol(key) {
+        return typeof key === 'symbol' && this.#rawQueryReferences.has(key);
     }
-    /**
-     * @internal allows testing we don't leak memory, as the raw fragments cache needs to be cleared automatically
-     */
-    static checkCacheSize() {
-        return this.#rawQueryCache.size;
+    static hasObjectFragments(object) {
+        return Utils.isPlainObject(object) && Object.getOwnPropertySymbols(object).some(symbol => this.isKnownFragmentSymbol(symbol));
     }
     static isKnownFragment(key) {
         if (key instanceof RawQueryFragment) {
             return true;
         }
-        return this.#rawQueryCache.has(key);
+        return this.isKnownFragmentSymbol(key);
     }
-    static getKnownFragment(key, cleanup = true) {
+    static getKnownFragment(key) {
         if (key instanceof RawQueryFragment) {
             return key;
         }
-        const raw = this.#rawQueryCache.get(key);
-        if (raw && cleanup) {
-            this.remove(key);
-        }
-        return raw;
-    }
-    static remove(key) {
-        const raw = this.#rawQueryCache.get(key);
-        if (!raw) {
+        if (typeof key !== 'symbol') {
             return;
         }
-        raw.#used--;
-        if (raw.#used <= 0) {
-            const removeStack = this.#storage.getStore();
-            if (removeStack) {
-                removeStack.add(key);
-            }
-            else {
-                this.#rawQueryCache.delete(key);
-            }
-        }
+        return this.#rawQueryReferences.get(key);
     }
     /** @ignore */
     /* v8 ignore next */
@@ -193,11 +170,7 @@ export function raw(sql, params) {
  * ```
  */
 export function sql(sql, ...values) {
-    return raw(sql.reduce((query, queryPart, i) => {
-        const valueExists = i < values.length;
-        const text = query + queryPart;
-        return valueExists ? text + '?' : text;
-    }, ''), values);
+    return raw(sql.join('?'), values);
 }
 export function createSqlFunction(func, key) {
     if (typeof key === 'string') {

package/utils/Utils.d.ts

@@ -2,6 +2,7 @@ import type { Dictionary, EntityData, EntityDictionary, EntityKey, EntityMetadat
 import type { Collection } from '../entity/Collection.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { ScalarReference } from '../entity/Reference.js';
+import { type RawQueryFragmentSymbol } from './RawQueryFragment.js';
 export declare function compareObjects(a: any, b: any): boolean;
 export declare function compareArrays(a: any[] | string, b: any[] | string): boolean;
 export declare function compareBooleans(a: unknown, b: unknown): boolean;
@@ -155,4 +156,5 @@ export declare class Utils {
     static values<T extends object>(obj: T): T[keyof T][];
     static entries<T extends object>(obj: T): [keyof T, T[keyof T]][];
     static primaryKeyToObject<T>(meta: EntityMetadata<T>, primaryKey: Primary<T> | T, visible?: (keyof T)[]): T;
+    static getObjectQueryKeys<T extends Dictionary, K extends string = Extract<keyof T, string>>(obj: T): (K | RawQueryFragmentSymbol)[];
 }

package/utils/Utils.js

@@ -1,6 +1,7 @@
 import { clone } from './clone.js';
 import { GroupOperator, PlainObject, QueryOperator, ReferenceKind } from '../enums.js';
 import { helper } from '../entity/wrap.js';
+import { Raw } from './RawQueryFragment.js';
 function compareConstructors(a, b) {
     if (a.constructor === b.constructor) {
         return true;
@@ -123,7 +124,7 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.0-dev.113';
+    static #ORM_VERSION = '7.0.0-dev.114';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */
@@ -824,4 +825,12 @@ export class Utils {
             return o;
         }, {});
     }
+    static getObjectQueryKeys(obj) {
+        return Reflect.ownKeys(obj).filter(key => {
+            if (!Object.prototype.propertyIsEnumerable.call(obj, key)) {
+                return false;
+            }
+            return typeof key === 'string' || Raw.isKnownFragmentSymbol(key);
+        });
+    }
 }

package/utils/clone.js

@@ -3,7 +3,6 @@
  * clone `EventEmitter`s to get around https://github.com/mikro-orm/mikro-orm/issues/2748
  * @internal
  */
-import { RawQueryFragment } from './RawQueryFragment.js';
 /**
  * Get the property descriptor of a property on an object or its prototype chain.
  *
@@ -29,10 +28,6 @@ export function clone(parent, respectCustomCloneMethod = true) {
         if (parent === null) {
             return null;
         }
-        const raw = RawQueryFragment.getKnownFragment(parent, false);
-        if (raw && respectCustomCloneMethod) {
-            return raw.clone();
-        }
         if (typeof parent !== 'object') {
             return parent;
         }
@@ -113,25 +108,16 @@ export function clone(parent, respectCustomCloneMethod = true) {
             if (attrs && typeof attrs.get === 'function' && attrs.set == null) {
                 continue;
             }
-            const raw = RawQueryFragment.getKnownFragment(i, false);
-            if (raw && respectCustomCloneMethod) {
-                const i2 = raw.clone().toString();
-                child[i2] = _clone(parent[i]);
-                continue;
-            }
             child[i] = _clone(parent[i]);
         }
-        if (Object.getOwnPropertySymbols) {
-            const symbols = Object.getOwnPropertySymbols(parent);
-            for (let i = 0; i < symbols.length; i++) {
-                const symbol = symbols[i];
-                const descriptor = Object.getOwnPropertyDescriptor(parent, symbol);
-                /* v8 ignore next */
-                if (descriptor && !descriptor.enumerable) {
-                    continue;
-                }
-                child[symbol] = _clone(parent[symbol]);
+        const symbols = Object.getOwnPropertySymbols(parent);
+        for (let i = 0; i < symbols.length; i++) {
+            const symbol = symbols[i];
+            const descriptor = Object.getOwnPropertyDescriptor(parent, symbol);
+            if (descriptor && !descriptor.enumerable) {
+                continue;
             }
+            child[symbol] = _clone(parent[symbol]);
         }
         return child;
     }

package/utils/upsert-utils.d.ts

@@ -1,12 +1,12 @@
 import type { EntityData, EntityMetadata, FilterQuery } from '../typings.js';
 import type { UpsertOptions } from '../drivers/IDatabaseDriver.js';
-import { type RawQueryFragment } from '../utils/RawQueryFragment.js';
+import { type Raw } from '../utils/RawQueryFragment.js';
 /** @internal */
-export declare function getOnConflictFields<T>(meta: EntityMetadata<T> | undefined, data: EntityData<T>, uniqueFields: (keyof T)[] | RawQueryFragment, options: UpsertOptions<T>): (keyof T)[];
+export declare function getOnConflictFields<T>(meta: EntityMetadata<T> | undefined, data: EntityData<T>, uniqueFields: (keyof T)[] | Raw, options: UpsertOptions<T>): (keyof T)[];
 /** @internal */
-export declare function getOnConflictReturningFields<T, P extends string>(meta: EntityMetadata<T> | undefined, data: EntityData<T>, uniqueFields: (keyof T)[] | RawQueryFragment, options: UpsertOptions<T, P>): (keyof T)[] | '*';
+export declare function getOnConflictReturningFields<T, P extends string>(meta: EntityMetadata<T> | undefined, data: EntityData<T>, uniqueFields: (keyof T)[] | Raw, options: UpsertOptions<T, P>): (keyof T)[] | '*';
 /** @internal */
-export declare function getWhereCondition<T extends object>(meta: EntityMetadata<T>, onConflictFields: (keyof T)[] | RawQueryFragment | undefined, data: EntityData<T>, where: FilterQuery<T>): {
+export declare function getWhereCondition<T extends object>(meta: EntityMetadata<T>, onConflictFields: (keyof T)[] | Raw | undefined, data: EntityData<T>, where: FilterQuery<T>): {
     where: FilterQuery<T>;
     propIndex: number | false;
 };