@mikro-orm/knex 6.4.6-dev.9 → 7.0.0-dev.1

package/query/QueryBuilderHelper.js

@@ -4,6 +4,7 @@ exports.QueryBuilderHelper = void 0;
 const node_util_1 = require("node:util");
 const core_1 = require("@mikro-orm/core");
 const enums_1 = require("./enums");
+const NativeQueryBuilder_1 = require("./NativeQueryBuilder");
 /**
  * @internal
  */
@@ -12,23 +13,21 @@ class QueryBuilderHelper {
     alias;
     aliasMap;
     subQueries;
-    knex;
     driver;
     platform;
     metadata;
-    constructor(entityName, alias, aliasMap, subQueries, knex, driver) {
+    constructor(entityName, alias, aliasMap, subQueries, driver) {
         this.entityName = entityName;
         this.alias = alias;
         this.aliasMap = aliasMap;
         this.subQueries = subQueries;
-        this.knex = knex;
         this.driver = driver;
         this.platform = this.driver.getPlatform();
         this.metadata = this.driver.getMetadata();
     }
     mapper(field, type = enums_1.QueryType.SELECT, value, alias) {
-        if (core_1.Utils.isRawSql(field)) {
-            return this.knex.raw(field.sql, field.params);
+        if ((0, core_1.isRaw)(field)) {
+            return (0, core_1.raw)(field.sql, field.params);
         }
         /* istanbul ignore next */
         if (typeof field !== 'string') {
@@ -69,13 +68,13 @@ class QueryBuilderHelper {
             if (parts.length === 1) {
                 return parts[0];
             }
-            return this.knex.raw('(' + parts.map(part => this.knex.ref(part)).join(', ') + ')');
+            return (0, core_1.raw)('(' + parts.map(part => this.platform.quoteIdentifier(part)).join(', ') + ')');
         }
         const rawField = core_1.RawQueryFragment.getKnownFragment(field);
         if (rawField) {
-            // sometimes knex is confusing the binding positions, we need to interpolate early
-            return this.knex.raw(this.platform.formatQuery(rawField.sql, rawField.params));
+            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;
@@ -83,21 +82,24 @@ class QueryBuilderHelper {
         let ret = field;
         // embeddable nested path instead of a regular property with table alias, reset alias
         if (prop?.name === a && prop.embeddedProps[f]) {
-            return this.alias + '.' + prop.fieldNames[fkIdx];
+            return aliasPrefix + prop.fieldNames[fkIdx];
+        }
+        if (prop?.embedded && a === prop.embedded[0]) {
+            return aliasPrefix + prop.fieldNames[fkIdx];
         }
         const noPrefix = prop && prop.persist === false;
         if (prop?.fieldNameRaw) {
-            return this.knex.raw(this.prefix(field, isTableNameAliasRequired));
+            return (0, core_1.raw)(this.prefix(field, isTableNameAliasRequired));
         }
         if (prop?.formula) {
-            const alias2 = this.knex.ref(a).toString();
-            const aliased = this.knex.ref(prop.fieldNames[0]).toString();
+            const alias2 = this.platform.quoteIdentifier(a).toString();
+            const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]).toString();
             const as = alias === null ? '' : ` as ${aliased}`;
             let value = prop.formula(alias2);
             if (!this.isTableNameAliasRequired(type)) {
                 value = value.replaceAll(alias2 + '.', '');
             }
-            return this.knex.raw(`${value}${as}`);
+            return (0, core_1.raw)(`${value}${as}`);
         }
         if (prop?.hasConvertToJSValueSQL && type !== enums_1.QueryType.UPSERT) {
             let valueSQL;
@@ -111,9 +113,9 @@ class QueryBuilderHelper {
                 valueSQL = prop.customType.convertToJSValueSQL(prefixed, this.platform);
             }
             if (alias === null) {
-                return this.knex.raw(valueSQL);
+                return (0, core_1.raw)(valueSQL);
             }
-            return this.knex.raw(`${valueSQL} as ${this.platform.quoteIdentifier(alias ?? prop.fieldNames[fkIdx])}`);
+            return (0, core_1.raw)(`${valueSQL} as ${this.platform.quoteIdentifier(alias ?? prop.fieldNames[fkIdx])}`);
         }
         // do not wrap custom expressions
         if (!rawField) {
@@ -135,7 +137,7 @@ class QueryBuilderHelper {
         data = this.driver.mapDataToFieldNames(data, true, meta?.properties, convertCustomTypes);
         if (!core_1.Utils.hasObjectKeys(data) && meta && multi) {
             /* istanbul ignore next */
-            data[meta.getPrimaryProps()[0].fieldNames[0]] = this.platform.usesDefaultKeyword() ? this.knex.raw('default') : undefined;
+            data[meta.getPrimaryProps()[0].fieldNames[0]] = this.platform.usesDefaultKeyword() ? (0, core_1.raw)('default') : undefined;
         }
         return data;
     }
@@ -193,7 +195,7 @@ class QueryBuilderHelper {
                 return;
             }
             const { sql, params } = this.createJoinExpression(join, joins, schema);
-            qb.joinRaw(sql, params);
+            qb.join(sql, params);
         });
     }
     createJoinExpression(join, joins, schema) {
@@ -215,13 +217,13 @@ class QueryBuilderHelper {
                 if (join.prop.formula) {
                     const alias = this.platform.quoteIdentifier(join.ownerAlias);
                     const left = join.prop.formula(alias);
-                    conditions.push(`${left} = ${this.knex.ref(right)}`);
+                    conditions.push(`${left} = ${this.platform.quoteIdentifier(right)}`);
                     return;
                 }
                 const left = join.prop.object && join.prop.fieldNameRaw
                     ? join.prop.fieldNameRaw.replaceAll(core_1.ALIAS_REPLACEMENT, join.ownerAlias)
-                    : this.knex.ref(`${join.ownerAlias}.${primaryKey}`);
-                conditions.push(`${left} = ${this.knex.ref(right)}`);
+                    : this.platform.quoteIdentifier(`${join.ownerAlias}.${primaryKey}`);
+                conditions.push(`${left} = ${this.platform.quoteIdentifier(right)}`);
             });
         }
         if (join.prop.targetMeta?.discriminatorValue && !join.path?.endsWith('[pivot]')) {
@@ -231,7 +233,7 @@ class QueryBuilderHelper {
         }
         let sql = method + ' ';
         if (join.nested) {
-            sql += `(${this.knex.ref(table)} as ${this.knex.ref(join.alias)}`;
+            sql += `(${this.platform.quoteIdentifier(table)} as ${this.platform.quoteIdentifier(join.alias)}`;
             for (const nested of join.nested) {
                 const { sql: nestedSql, params: nestedParams } = this.createJoinExpression(nested, joins, schema);
                 sql += ' ' + nestedSql;
@@ -240,94 +242,24 @@ class QueryBuilderHelper {
             sql += `)`;
         }
         else if (join.subquery) {
-            sql += `(${join.subquery}) as ${this.knex.ref(join.alias)}`;
+            sql += `(${join.subquery}) as ${this.platform.quoteIdentifier(join.alias)}`;
         }
         else {
-            sql += `${this.knex.ref(table)} as ${this.knex.ref(join.alias)}`;
+            sql += `${this.platform.quoteIdentifier(table)} as ${this.platform.quoteIdentifier(join.alias)}`;
         }
-        for (const key of Object.keys(join.cond)) {
-            const hasPrefix = key.includes('.') || core_1.Utils.isOperator(key) || core_1.RawQueryFragment.isKnownFragment(key);
-            const newKey = hasPrefix ? key : `${join.alias}.${key}`;
-            const clause = this.processJoinClause(newKey, join.cond[key], join.alias, params);
-            /* istanbul ignore else */
-            if (clause !== '()') {
-                conditions.push(clause);
-            }
+        const oldAlias = this.alias;
+        this.alias = join.alias;
+        const subquery = this._appendQueryCondition(enums_1.QueryType.SELECT, join.cond);
+        this.alias = oldAlias;
+        if (subquery.sql) {
+            conditions.push(subquery.sql);
+            params.push(...subquery.params);
         }
         if (conditions.length > 0) {
             sql += ` on ${conditions.join(' and ')}`;
         }
         return { sql, params };
     }
-    processJoinClause(key, value, alias, params, operator = '$eq') {
-        if (core_1.Utils.isGroupOperator(key) && Array.isArray(value)) {
-            const parts = value.map(sub => {
-                return this.wrapQueryGroup(Object.keys(sub).map(k => this.processJoinClause(k, sub[k], alias, params)));
-            });
-            return this.wrapQueryGroup(parts, key);
-        }
-        if (this.isSimpleRegExp(value)) {
-            params.push(this.getRegExpParam(value));
-            return `${this.knex.ref(this.mapper(key))} like ?`;
-        }
-        if (value instanceof RegExp) {
-            value = this.platform.getRegExpValue(value);
-        }
-        if (core_1.Utils.isOperator(key, false) && core_1.Utils.isPlainObject(value)) {
-            const parts = Object.keys(value).map(k => this.processJoinClause(k, value[k], alias, params, key));
-            return key === '$not' ? `not ${this.wrapQueryGroup(parts)}` : this.wrapQueryGroup(parts);
-        }
-        if (core_1.Utils.isPlainObject(value) && Object.keys(value).every(k => core_1.Utils.isOperator(k, false))) {
-            const parts = Object.keys(value).map(op => this.processJoinClause(key, value[op], alias, params, op));
-            return this.wrapQueryGroup(parts);
-        }
-        const [fromAlias, fromField] = this.splitField(key);
-        const prop = this.getProperty(fromField, fromAlias);
-        operator = operator === '$not' ? '$eq' : operator;
-        if (value === null) {
-            return `${this.knex.ref(this.mapper(key))} is ${operator === '$ne' ? 'not ' : ''}null`;
-        }
-        if (operator === '$fulltext' && prop) {
-            const query = this.knex.raw(this.platform.getFullTextWhereClause(prop), {
-                column: this.mapper(key),
-                query: this.knex.raw('?'),
-            }).toSQL().toNative();
-            params.push(value);
-            return query.sql;
-        }
-        const replacement = this.getOperatorReplacement(operator, { [operator]: value });
-        if (['$in', '$nin'].includes(operator) && Array.isArray(value)) {
-            params.push(...value);
-            return `${this.knex.ref(this.mapper(key))} ${replacement} (${value.map(() => '?').join(', ')})`;
-        }
-        if (operator === '$exists') {
-            value = null;
-        }
-        const rawField = core_1.RawQueryFragment.getKnownFragment(key);
-        if (rawField) {
-            let sql = rawField.sql.replaceAll(core_1.ALIAS_REPLACEMENT, alias);
-            params.push(...rawField.params);
-            params.push(...core_1.Utils.asArray(value));
-            if (core_1.Utils.asArray(value).length > 0) {
-                sql += ' = ?';
-            }
-            return sql;
-        }
-        const sql = this.mapper(key);
-        if (value !== null) {
-            if (prop?.customType) {
-                value = prop.customType.convertToDatabaseValue(value, this.platform, { fromQuery: true, key, mode: 'query' });
-            }
-            params.push(value);
-        }
-        return `${this.knex.ref(sql)} ${replacement} ${value === null ? 'null' : '?'}`;
-    }
-    wrapQueryGroup(parts, operator = '$and') {
-        if (parts.length === 1) {
-            return parts[0];
-        }
-        return `(${parts.join(` ${core_1.GroupOperator[operator]} `)})`;
-    }
     mapJoinColumns(type, join) {
         if (join.prop && [core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(join.prop.kind)) {
             return join.prop.fieldNames.map((_fieldName, idx) => {
@@ -382,17 +314,8 @@ class QueryBuilderHelper {
     }
     appendOnConflictClause(type, onConflict, qb) {
         onConflict.forEach(item => {
-            let sub;
-            if (core_1.Utils.isRawSql(item.fields)) {
-                sub = qb.onConflict(this.knex.raw(item.fields.sql, item.fields.params));
-            }
-            else if (item.fields.length > 0) {
-                sub = qb.onConflict(item.fields);
-            }
-            else {
-                sub = qb.onConflict();
-            }
-            core_1.Utils.runIfNotEmpty(() => sub.ignore(), item.ignore);
+            const { fields, ignore } = item;
+            const sub = qb.onConflict({ fields, ignore });
             core_1.Utils.runIfNotEmpty(() => {
                 let mergeParam = item.merge;
                 if (core_1.Utils.isObject(item.merge)) {
@@ -405,57 +328,89 @@ class QueryBuilderHelper {
                 if (Array.isArray(item.merge)) {
                     mergeParam = item.merge.map(key => this.mapper(key, type));
                 }
-                const sub2 = sub.merge(mergeParam);
-                core_1.Utils.runIfNotEmpty(() => this.appendQueryCondition(type, item.where, sub2), item.where);
+                sub.merge = mergeParam ?? [];
+                if (item.where) {
+                    sub.where = this._appendQueryCondition(type, item.where);
+                }
             }, 'merge' in item);
         });
     }
     appendQueryCondition(type, cond, qb, operator, method = 'where') {
-        const m = operator === '$or' ? 'orWhere' : 'andWhere';
-        Object.keys(cond).forEach(k => {
+        const { sql, params } = this._appendQueryCondition(type, cond, operator);
+        qb[method](sql, params);
+    }
+    _appendQueryCondition(type, cond, operator) {
+        const parts = [];
+        const params = [];
+        for (const k of Object.keys(cond)) {
             if (k === '$and' || k === '$or') {
                 if (operator) {
-                    return qb[m](inner => this.appendGroupCondition(type, inner, k, method, cond[k]));
+                    this.append(() => this.appendGroupCondition(type, k, cond[k]), parts, params, operator);
+                    continue;
                 }
-                return this.appendGroupCondition(type, qb, k, method, cond[k]);
+                this.append(() => this.appendGroupCondition(type, k, cond[k]), parts, params);
+                continue;
             }
             if (k === '$not') {
-                const m = operator === '$or' ? 'orWhereNot' : 'whereNot';
-                return qb[m](inner => this.appendQueryCondition(type, cond[k], inner));
+                const res = this._appendQueryCondition(type, cond[k]);
+                parts.push(`not (${res.sql})`);
+                params.push(...res.params);
+                continue;
             }
-            this.appendQuerySubCondition(qb, type, method, cond, k, operator);
-        });
+            this.append(() => this.appendQuerySubCondition(type, cond, k), parts, params);
+        }
+        return { sql: parts.join(' and '), params };
     }
-    appendQuerySubCondition(qb, type, method, cond, key, operator) {
-        const m = operator === '$or' ? 'orWhere' : method;
-        if (cond[key] instanceof core_1.RawQueryFragment) {
-            cond[key] = this.knex.raw(cond[key].sql, cond[key].params);
+    append(cb, parts, params, operator) {
+        const res = cb();
+        if (['', '()'].includes(res.sql)) {
+            return;
         }
+        parts.push(operator === '$or' ? `(${res.sql})` : res.sql);
+        params.push(...res.params);
+    }
+    appendQuerySubCondition(type, cond, key) {
+        const parts = [];
+        const params = [];
+        const fields = core_1.Utils.splitPrimaryKeys(key);
         if (this.isSimpleRegExp(cond[key])) {
-            return void qb[m](this.mapper(key, type), 'like', this.getRegExpParam(cond[key]));
+            parts.push(`${this.platform.quoteIdentifier(this.mapper(key, type))} like ?`);
+            params.push(this.getRegExpParam(cond[key]));
+            return { sql: parts.join(' and '), params };
         }
         if (core_1.Utils.isPlainObject(cond[key]) || cond[key] instanceof RegExp) {
-            return this.processObjectSubCondition(cond, key, qb, method, m, type);
+            return this.processObjectSubCondition(cond, key, type);
         }
         const op = cond[key] === null ? 'is' : '=';
         const raw = core_1.RawQueryFragment.getKnownFragment(key);
         if (raw) {
+            const sql = raw.sql.replaceAll(core_1.ALIAS_REPLACEMENT, this.alias);
             const value = core_1.Utils.asArray(cond[key]);
+            params.push(...raw.params);
             if (value.length > 0) {
-                return void qb[m](this.knex.raw(raw.sql, raw.params), op, value[0]);
+                const val = this.getValueReplacement(fields, value[0], params, key);
+                parts.push(`${sql} ${op} ${val}`);
+                return { sql: parts.join(' and '), params };
             }
-            return void qb[m](this.knex.raw(raw.sql, raw.params));
+            parts.push(sql);
+            return { sql: parts.join(' and '), params };
         }
         if (this.subQueries[key]) {
-            return void qb[m](this.knex.raw(`(${this.subQueries[key]})`), op, cond[key]);
+            const val = this.getValueReplacement(fields, cond[key], params, key);
+            parts.push(`(${this.subQueries[key]}) ${op} ${val}`);
+            return { sql: parts.join(' and '), params };
         }
-        qb[m](this.mapper(key, type, cond[key], null), op, cond[key]);
+        const val = this.getValueReplacement(fields, cond[key], params, key);
+        parts.push(`${this.platform.quoteIdentifier(this.mapper(key, type, cond[key], null))} ${op} ${val}`);
+        return { sql: parts.join(' and '), params };
     }
-    processObjectSubCondition(cond, key, qb, method, m, type) {
+    processObjectSubCondition(cond, key, type) {
+        const parts = [];
+        const params = [];
         let value = cond[key];
         const size = core_1.Utils.getObjectKeysSize(value);
         if (core_1.Utils.isPlainObject(value) && size === 0) {
-            return;
+            return { sql: '', params };
         }
         // grouped condition for one field, e.g. `{ age: { $gte: 10, $lt: 50 } }`
         if (size > 1) {
@@ -464,7 +419,10 @@ class QueryBuilderHelper {
                 key = rawField?.clone().toString() ?? key;
                 return ({ [key]: { [subKey]: subValue } });
             });
-            return subCondition.forEach(sub => this.appendQueryCondition(type, sub, qb, '$and', method));
+            for (const sub of subCondition) {
+                this.append(() => this._appendQueryCondition(type, sub, '$and'), parts, params);
+            }
+            return { sql: parts.join(' and '), params };
         }
         if (value instanceof RegExp) {
             value = this.platform.getRegExpValue(value);
@@ -485,37 +443,83 @@ class QueryBuilderHelper {
                     const conds = value[op].map(() => {
                         return `(${mapped.map(field => `${this.platform.quoteIdentifier(field)} = ?`).join(' and ')})`;
                     });
-                    return void qb[m](this.knex.raw(`(${conds.join(' or ')})`, core_1.Utils.flatten(value[op])));
+                    parts.push(`(${conds.join(' or ')})`);
+                    params.push(...core_1.Utils.flatten(value[op]));
+                    return { sql: parts.join(' and '), params };
                 }
-                return void qb[m](this.knex.raw(`${mapped.map(field => `${this.platform.quoteIdentifier(field)} = ?`).join(' and ')}`, core_1.Utils.flatten(value[op])));
+                parts.push(...mapped.map(field => `${this.platform.quoteIdentifier(field)} = ?`));
+                params.push(...core_1.Utils.flatten(value[op]));
+                return { sql: parts.join(' and '), params };
             }
             if (singleTuple) {
                 const tmp = value[op].length === 1 && core_1.Utils.isPlainObject(value[op][0]) ? fields.map(f => value[op][0][f]) : value[op];
-                value[op] = this.knex.raw(`(${fields.map(() => '?').join(', ')})`, tmp);
+                const sql = `(${fields.map(() => '?').join(', ')})`;
+                value[op] = (0, core_1.raw)(sql, tmp);
             }
         }
-        if (value[op] instanceof core_1.RawQueryFragment) {
-            value[op] = this.knex.raw(value[op].sql, value[op].params);
-        }
         if (this.subQueries[key]) {
-            return void qb[m](this.knex.raw(`(${this.subQueries[key]})`), replacement, value[op]);
+            const val = this.getValueReplacement(fields, value[op], params, op);
+            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);
         if (op === '$fulltext') {
-            const [a, f] = this.splitField(key);
-            const prop = this.getProperty(f, a);
             /* istanbul ignore next */
             if (!prop) {
                 throw new Error(`Cannot use $fulltext operator on ${key}, property not found`);
             }
-            qb[m](this.knex.raw(this.platform.getFullTextWhereClause(prop), {
+            const { sql, params: params2 } = (0, core_1.raw)(this.platform.getFullTextWhereClause(prop), {
                 column: this.mapper(key, type, undefined, null),
                 query: value[op],
-            }));
+            });
+            parts.push(sql);
+            params.push(...params2);
+        }
+        else if (op === '$in' && Array.isArray(value[op]) && value[op].length === 0) {
+            parts.push(`1 = 0`);
+        }
+        else if (value[op] instanceof core_1.RawQueryFragment || value[op] instanceof NativeQueryBuilder_1.NativeQueryBuilder) {
+            const query = value[op] instanceof NativeQueryBuilder_1.NativeQueryBuilder ? value[op].toRaw() : value[op];
+            const mappedKey = this.mapper(key, type, query, null);
+            let sql = query.sql;
+            if (['$in', '$nin'].includes(op)) {
+                sql = `(${sql})`;
+            }
+            parts.push(`${this.platform.quoteIdentifier(mappedKey)} ${replacement} ${sql}`);
+            params.push(...query.params);
         }
         else {
             const mappedKey = this.mapper(key, type, value[op], null);
-            qb[m](mappedKey, replacement, value[op]);
+            const val = this.getValueReplacement(fields, value[op], params, op, prop);
+            parts.push(`${this.platform.quoteIdentifier(mappedKey)} ${replacement} ${val}`);
+        }
+        return { sql: parts.join(' and '), params };
+    }
+    getValueReplacement(fields, value, params, key, prop) {
+        if (Array.isArray(value)) {
+            if (fields.length > 1) {
+                const tmp = [];
+                for (const field of value) {
+                    tmp.push(`(${field.map(() => '?').join(', ')})`);
+                    params.push(...field);
+                }
+                return `(${tmp.join(', ')})`;
+            }
+            if (prop?.customType instanceof core_1.ArrayType) {
+                const item = prop.customType.convertToDatabaseValue(value, this.platform, { fromQuery: true, key, mode: 'query' });
+                params.push(item);
+            }
+            else {
+                params.push(...value);
+            }
+            return `(${value.map(() => '?').join(', ')})`;
         }
+        if (value === null) {
+            return 'null';
+        }
+        params.push(value);
+        return '?';
     }
     getOperatorReplacement(op, value) {
         let replacement = core_1.QueryOperator[op];
@@ -529,6 +533,9 @@ class QueryBuilderHelper {
         if (op === '$re') {
             replacement = this.platform.getRegExpOperator(value[op], value.$flags);
         }
+        if (replacement.includes('?')) {
+            replacement = replacement.replaceAll('?', '\\?');
+        }
         return replacement;
     }
     getQueryOrder(type, orderBy, populate) {
@@ -555,12 +562,12 @@ class QueryBuilderHelper {
                 const noPrefix = (prop && prop.persist === false && !prop.formula && !prop.embedded) || core_1.RawQueryFragment.isKnownFragment(f);
                 const column = this.mapper(noPrefix ? field : `${alias}.${field}`, type, undefined, null);
                 /* istanbul ignore next */
-                const rawColumn = core_1.Utils.isString(column) ? column.split('.').map(e => this.knex.ref(e)).join('.') : column;
+                const rawColumn = core_1.Utils.isString(column) ? column.split('.').map(e => this.platform.quoteIdentifier(e)).join('.') : column;
                 const customOrder = prop?.customOrder;
                 let colPart = customOrder
                     ? this.platform.generateCustomOrder(rawColumn, customOrder)
                     : rawColumn;
-                if (core_1.Utils.isRawSql(colPart)) {
+                if ((0, core_1.isRaw)(colPart)) {
                     colPart = this.platform.formatQuery(colPart.sql, colPart.params);
                 }
                 if (Array.isArray(order)) {
@@ -593,13 +600,13 @@ class QueryBuilderHelper {
             return;
         }
         if (type === enums_1.QueryType.UPDATE) {
-            const returningProps = meta.hydrateProps.filter(prop => prop.fieldNames && core_1.Utils.isRawSql(data[prop.fieldNames[0]]));
+            const returningProps = meta.hydrateProps.filter(prop => prop.fieldNames && (0, core_1.isRaw)(data[prop.fieldNames[0]]));
             if (returningProps.length > 0) {
                 qb.returning(returningProps.flatMap(prop => {
                     if (prop.hasConvertToJSValueSQL) {
                         const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]);
                         const sql = prop.customType.convertToJSValueSQL(aliased, this.platform) + ' as ' + this.platform.quoteIdentifier(prop.fieldNames[0]);
-                        return [this.knex.raw(sql)];
+                        return [(0, core_1.raw)(sql)];
                     }
                     return prop.fieldNames;
                 }));
@@ -629,14 +636,7 @@ class QueryBuilderHelper {
         if (lockMode === core_1.LockMode.OPTIMISTIC && meta && !meta.versionProperty) {
             throw core_1.OptimisticLockError.lockFailed(this.entityName);
         }
-        switch (lockMode) {
-            case core_1.LockMode.PESSIMISTIC_READ: return void qb.forShare(...lockTables);
-            case core_1.LockMode.PESSIMISTIC_WRITE: return void qb.forUpdate(...lockTables);
-            case core_1.LockMode.PESSIMISTIC_PARTIAL_WRITE: return void qb.forUpdate(...lockTables).skipLocked();
-            case core_1.LockMode.PESSIMISTIC_WRITE_OR_FAIL: return void qb.forUpdate(...lockTables).noWait();
-            case core_1.LockMode.PESSIMISTIC_PARTIAL_READ: return void qb.forShare(...lockTables).skipLocked();
-            case core_1.LockMode.PESSIMISTIC_READ_OR_FAIL: return void qb.forShare(...lockTables).noWait();
-        }
+        qb.lockMode(lockMode, lockTables);
     }
     updateVersionProperty(qb, data) {
         const meta = this.metadata.find(this.entityName);
@@ -648,7 +648,7 @@ class QueryBuilderHelper {
         if (versionProperty.runtimeType === 'Date') {
             sql = this.platform.getCurrentTimestampSQL(versionProperty.length);
         }
-        qb.update(versionProperty.fieldNames[0], this.knex.raw(sql));
+        qb.update({ [versionProperty.fieldNames[0]]: (0, core_1.raw)(sql) });
     }
     prefix(field, always = false, quote = false, idx) {
         let ret;
@@ -674,21 +674,28 @@ class QueryBuilderHelper {
         }
         return ret;
     }
-    appendGroupCondition(type, qb, operator, method, subCondition) {
+    appendGroupCondition(type, operator, subCondition) {
+        const parts = [];
+        const params = [];
         // single sub-condition can be ignored to reduce nesting of parens
         if (subCondition.length === 1 || operator === '$and') {
-            return subCondition.forEach(sub => this.appendQueryCondition(type, sub, qb, undefined, method));
+            for (const sub of subCondition) {
+                this.append(() => this._appendQueryCondition(type, sub), parts, params);
+            }
+            return { sql: parts.join(' and '), params };
         }
-        qb[method](outer => subCondition.forEach(sub => {
+        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 val = sub[keys[0]];
             const simple = !core_1.Utils.isPlainObject(val) || core_1.Utils.getObjectKeysSize(val) === 1 || Object.keys(val).every(k => !core_1.Utils.isOperator(k));
             if (keys.length === 1 && simple) {
-                return this.appendQueryCondition(type, sub, outer, operator);
+                this.append(() => this._appendQueryCondition(type, sub, operator), parts, params);
+                continue;
             }
-            outer.orWhere(inner => this.appendQueryCondition(type, sub, inner));
-        }));
+            this.append(() => this._appendQueryCondition(type, sub), parts, params, operator);
+        }
+        return { sql: `(${parts.join(' or ')})`, params };
     }
     isPrefixed(field) {
         return !!field.match(/[\w`"[\]]+\./);
@@ -738,12 +745,11 @@ class QueryBuilderHelper {
         return undefined;
     }
     isTableNameAliasRequired(type) {
-        return [enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(type ?? enums_1.QueryType.SELECT);
+        return [enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(type);
     }
-    // workaround for https://github.com/knex/knex/issues/5257
     processOnConflictCondition(cond, schema) {
         const meta = this.metadata.get(this.entityName);
-        const tableName = this.driver.getTableName(meta, { schema }, false);
+        const tableName = meta.tableName;
         for (const key of Object.keys(cond)) {
             const mapped = this.mapper(key, enums_1.QueryType.UPSERT);
             core_1.Utils.renameKey(cond, key, tableName + '.' + mapped);

package/query/ScalarCriteriaNode.js

@@ -4,6 +4,7 @@ exports.ScalarCriteriaNode = void 0;
 const core_1 = require("@mikro-orm/core");
 const CriteriaNode_1 = require("./CriteriaNode");
 const enums_1 = require("./enums");
+const QueryBuilder_1 = require("./QueryBuilder");
 /**
  * @internal
  */
@@ -21,6 +22,9 @@ class ScalarCriteriaNode extends CriteriaNode_1.CriteriaNode {
                 qb.addSelect(field);
             }
         }
+        if (this.payload instanceof QueryBuilder_1.QueryBuilder) {
+            return this.payload.getNativeQuery().toRaw();
+        }
         if (this.payload && typeof this.payload === 'object') {
             const keys = Object.keys(this.payload).filter(key => core_1.Utils.isArrayOperator(key) && Array.isArray(this.payload[key]));
             for (const key of keys) {

package/query/index.d.ts

@@ -6,3 +6,4 @@ export * from './ArrayCriteriaNode';
 export * from './ObjectCriteriaNode';
 export * from './ScalarCriteriaNode';
 export * from './CriteriaNodeFactory';
+export * from './NativeQueryBuilder';

package/query/index.js

@@ -22,3 +22,4 @@ __exportStar(require("./ArrayCriteriaNode"), exports);
 __exportStar(require("./ObjectCriteriaNode"), exports);
 __exportStar(require("./ScalarCriteriaNode"), exports);
 __exportStar(require("./CriteriaNodeFactory"), exports);
+__exportStar(require("./NativeQueryBuilder"), exports);

package/schema/DatabaseSchema.js

@@ -99,21 +99,24 @@ class DatabaseSchema {
         for (const meta of metadata) {
             const table = schema.addTable(meta.collection, this.getSchemaName(meta, config, schemaName));
             table.comment = meta.comment;
-            meta.props
-                .filter(prop => this.shouldHaveColumn(meta, prop))
-                .forEach(prop => table.addColumnFromProperty(prop, meta, config));
+            for (const prop of meta.props) {
+                if (!this.shouldHaveColumn(meta, prop)) {
+                    continue;
+                }
+                table.addColumnFromProperty(prop, meta, config);
+            }
             meta.indexes.forEach(index => table.addIndex(meta, index, 'index'));
             meta.uniques.forEach(index => table.addIndex(meta, index, 'unique'));
             table.addIndex(meta, { properties: meta.props.filter(prop => prop.primary).map(prop => prop.name) }, 'primary');
-            meta.checks.forEach(check => {
+            for (const check of meta.checks) {
                 const columnName = check.property ? meta.properties[check.property].fieldNames[0] : undefined;
                 table.addCheck({
                     name: check.name,
                     expression: check.expression,
-                    definition: `check ((${check.expression}))`,
+                    definition: `check (${check.expression})`,
                     columnName,
                 });
-            });
+            }
         }
         return schema;
     }