@mikro-orm/sql 7.0.0-dev.97 → 7.0.0-dev.99

package/query/QueryBuilderHelper.js

@@ -0,0 +1,756 @@
+import { ALIAS_REPLACEMENT, ALIAS_REPLACEMENT_RE, ArrayType, isRaw, LockMode, OptimisticLockError, QueryOperator, QueryOrderNumeric, raw, RawQueryFragment, ReferenceKind, Utils, ValidationError, } from '@mikro-orm/core';
+import { JoinType, QueryType } from './enums.js';
+import { NativeQueryBuilder } from './NativeQueryBuilder.js';
+/**
+ * @internal
+ */
+export class QueryBuilderHelper {
+    entityName;
+    alias;
+    aliasMap;
+    subQueries;
+    driver;
+    platform;
+    metadata;
+    constructor(entityName, alias, aliasMap, subQueries, driver) {
+        this.entityName = entityName;
+        this.alias = alias;
+        this.aliasMap = aliasMap;
+        this.subQueries = subQueries;
+        this.driver = driver;
+        this.platform = this.driver.getPlatform();
+        this.metadata = this.driver.getMetadata();
+    }
+    mapper(field, type = QueryType.SELECT, value, alias) {
+        if (isRaw(field)) {
+            return raw(field.sql, field.params);
+        }
+        /* v8 ignore next */
+        if (typeof field !== 'string') {
+            return field;
+        }
+        const isTableNameAliasRequired = this.isTableNameAliasRequired(type);
+        const fields = Utils.splitPrimaryKeys(field);
+        if (fields.length > 1) {
+            const parts = [];
+            for (const p of fields) {
+                const [a, f] = this.splitField(p);
+                const prop = this.getProperty(f, a);
+                const fkIdx2 = prop?.fieldNames.findIndex(name => name === f) ?? -1;
+                if (fkIdx2 !== -1) {
+                    parts.push(this.mapper(a !== this.alias ? `${a}.${prop.fieldNames[fkIdx2]}` : prop.fieldNames[fkIdx2], type, value, alias));
+                }
+                else if (prop) {
+                    parts.push(...prop.fieldNames.map(f => this.mapper(a !== this.alias ? `${a}.${f}` : f, type, value, alias)));
+                }
+                else {
+                    parts.push(this.mapper(a !== this.alias ? `${a}.${f}` : f, type, value, alias));
+                }
+            }
+            // flatten the value if we see we are expanding nested composite key
+            // hackish, but cleaner solution would require quite a lot of refactoring
+            if (fields.length !== parts.length && Array.isArray(value)) {
+                value.forEach(row => {
+                    if (Array.isArray(row)) {
+                        const tmp = Utils.flatten(row);
+                        row.length = 0;
+                        row.push(...tmp);
+                    }
+                });
+            }
+            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];
+        }
+        if (a === prop?.embedded?.[0]) {
+            return aliasPrefix + prop.fieldNames[fkIdx];
+        }
+        const noPrefix = prop?.persist === false;
+        if (prop?.fieldNameRaw) {
+            return raw(this.prefix(field, isTableNameAliasRequired));
+        }
+        if (prop?.formula) {
+            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 raw(`${value}${as}`);
+        }
+        if (prop?.hasConvertToJSValueSQL && type !== QueryType.UPSERT) {
+            let valueSQL;
+            if (prop.fieldNames.length > 1 && fkIdx !== -1) {
+                const fk = prop.targetMeta.getPrimaryProps()[fkIdx];
+                const prefixed = this.prefix(field, isTableNameAliasRequired, true, fkIdx);
+                valueSQL = fk.customType.convertToJSValueSQL(prefixed, this.platform);
+            }
+            else {
+                const prefixed = this.prefix(field, isTableNameAliasRequired, true);
+                valueSQL = prop.customType.convertToJSValueSQL(prefixed, this.platform);
+            }
+            if (alias === null) {
+                return raw(valueSQL);
+            }
+            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);
+        }
+        if (alias) {
+            ret += ' as ' + alias;
+        }
+        if (!isTableNameAliasRequired || this.isPrefixed(ret) || noPrefix) {
+            return ret;
+        }
+        return this.alias + '.' + ret;
+    }
+    processData(data, convertCustomTypes, multi = false) {
+        if (Array.isArray(data)) {
+            return data.map(d => this.processData(d, convertCustomTypes, true));
+        }
+        const meta = this.metadata.find(this.entityName);
+        data = this.driver.mapDataToFieldNames(data, true, meta?.properties, convertCustomTypes);
+        if (!Utils.hasObjectKeys(data) && meta && multi) {
+            /* v8 ignore next */
+            data[meta.getPrimaryProps()[0].fieldNames[0]] = this.platform.usesDefaultKeyword() ? raw('default') : undefined;
+        }
+        return data;
+    }
+    joinOneToReference(prop, ownerAlias, alias, type, cond = {}, schema) {
+        const prop2 = prop.targetMeta.properties[prop.mappedBy || prop.inversedBy];
+        const table = this.getTableName(prop.type);
+        const joinColumns = prop.owner ? prop.referencedColumnNames : prop2.joinColumns;
+        const inverseJoinColumns = prop.referencedColumnNames;
+        const primaryKeys = prop.owner ? prop.joinColumns : prop2.referencedColumnNames;
+        schema ??= prop.targetMeta?.schema === '*' ? '*' : this.driver.getSchemaName(prop.targetMeta);
+        cond = Utils.merge(cond, prop.where);
+        return {
+            prop, type, cond, ownerAlias, alias, table, schema,
+            joinColumns, inverseJoinColumns, primaryKeys,
+        };
+    }
+    joinManyToOneReference(prop, ownerAlias, alias, type, cond = {}, schema) {
+        return {
+            prop, type, cond, ownerAlias, alias,
+            table: this.getTableName(prop.type),
+            schema: prop.targetMeta?.schema === '*' ? '*' : this.driver.getSchemaName(prop.targetMeta, { schema }),
+            joinColumns: prop.referencedColumnNames,
+            primaryKeys: prop.fieldNames,
+        };
+    }
+    joinManyToManyReference(prop, ownerAlias, alias, pivotAlias, type, cond, path, schema) {
+        const pivotMeta = this.metadata.find(prop.pivotEntity);
+        const ret = {
+            [`${ownerAlias}.${prop.name}#${pivotAlias}`]: {
+                prop, type, ownerAlias,
+                alias: pivotAlias,
+                inverseAlias: alias,
+                joinColumns: prop.joinColumns,
+                inverseJoinColumns: prop.inverseJoinColumns,
+                primaryKeys: prop.referencedColumnNames,
+                cond: {},
+                table: pivotMeta.tableName,
+                schema: prop.targetMeta?.schema === '*' ? '*' : this.driver.getSchemaName(pivotMeta, { schema }),
+                path: path.endsWith('[pivot]') ? path : `${path}[pivot]`,
+            },
+        };
+        if (type === JoinType.pivotJoin) {
+            return ret;
+        }
+        const prop2 = prop.owner ? pivotMeta.relations[1] : pivotMeta.relations[0];
+        ret[`${pivotAlias}.${prop2.name}#${alias}`] = this.joinManyToOneReference(prop2, pivotAlias, alias, type, cond, schema);
+        ret[`${pivotAlias}.${prop2.name}#${alias}`].path = path;
+        const tmp = prop2.referencedTableName.split('.');
+        ret[`${pivotAlias}.${prop2.name}#${alias}`].schema ??= tmp.length > 1 ? tmp[0] : undefined;
+        return ret;
+    }
+    processJoins(qb, joins, schema) {
+        Object.values(joins).forEach(join => {
+            if ([JoinType.nestedInnerJoin, JoinType.nestedLeftJoin].includes(join.type)) {
+                return;
+            }
+            const { sql, params } = this.createJoinExpression(join, joins, schema);
+            qb.join(sql, params);
+        });
+    }
+    createJoinExpression(join, joins, schema) {
+        let table = join.table;
+        const method = {
+            [JoinType.nestedInnerJoin]: 'inner join',
+            [JoinType.nestedLeftJoin]: 'left join',
+            [JoinType.pivotJoin]: 'left join',
+        }[join.type] ?? join.type;
+        const conditions = [];
+        const params = [];
+        schema = join.schema && join.schema !== '*' ? join.schema : schema;
+        if (schema && schema !== this.platform.getDefaultSchemaName()) {
+            table = `${schema}.${table}`;
+        }
+        if (join.prop.name !== '__subquery__') {
+            join.primaryKeys.forEach((primaryKey, idx) => {
+                const right = `${join.alias}.${join.joinColumns[idx]}`;
+                if (join.prop.formula) {
+                    const alias = this.platform.quoteIdentifier(join.ownerAlias);
+                    const left = join.prop.formula(alias);
+                    conditions.push(`${left} = ${this.platform.quoteIdentifier(right)}`);
+                    return;
+                }
+                const left = join.prop.object && join.prop.fieldNameRaw
+                    ? join.prop.fieldNameRaw.replaceAll(ALIAS_REPLACEMENT, join.ownerAlias)
+                    : this.platform.quoteIdentifier(`${join.ownerAlias}.${primaryKey}`);
+                conditions.push(`${left} = ${this.platform.quoteIdentifier(right)}`);
+            });
+        }
+        if (join.prop.targetMeta?.discriminatorValue && !join.path?.endsWith('[pivot]')) {
+            const typeProperty = join.prop.targetMeta.root.discriminatorColumn;
+            const alias = join.inverseAlias ?? join.alias;
+            join.cond[`${alias}.${typeProperty}`] = join.prop.targetMeta.discriminatorValue;
+        }
+        let sql = method + ' ';
+        if (join.nested) {
+            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;
+                params.push(...nestedParams);
+            }
+            sql += `)`;
+        }
+        else if (join.subquery) {
+            sql += `(${join.subquery}) as ${this.platform.quoteIdentifier(join.alias)}`;
+        }
+        else {
+            sql += `${this.platform.quoteIdentifier(table)} as ${this.platform.quoteIdentifier(join.alias)}`;
+        }
+        const oldAlias = this.alias;
+        this.alias = join.alias;
+        const subquery = this._appendQueryCondition(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 };
+    }
+    mapJoinColumns(type, join) {
+        if (join.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(join.prop.kind)) {
+            return join.prop.fieldNames.map((_fieldName, idx) => {
+                const columns = join.prop.owner ? join.joinColumns : join.inverseJoinColumns;
+                return this.mapper(`${join.alias}.${columns[idx]}`, type, undefined, `${join.alias}__${columns[idx]}`);
+            });
+        }
+        return [
+            ...join.joinColumns.map(col => this.mapper(`${join.alias}.${col}`, type, undefined, `fk__${col}`)),
+            ...join.inverseJoinColumns.map(col => this.mapper(`${join.alias}.${col}`, type, undefined, `fk__${col}`)),
+        ];
+    }
+    isOneToOneInverse(field, meta) {
+        meta ??= this.metadata.find(this.entityName);
+        const prop = meta.properties[field.replace(/:ref$/, '')];
+        return prop && prop.kind === ReferenceKind.ONE_TO_ONE && !prop.owner;
+    }
+    getTableName(entityName) {
+        const meta = this.metadata.find(entityName);
+        return meta ? meta.collection : entityName;
+    }
+    /**
+     * Checks whether the RE can be rewritten to simple LIKE query
+     */
+    isSimpleRegExp(re) {
+        if (!(re instanceof RegExp)) {
+            return false;
+        }
+        if (re.flags.includes('i')) {
+            return false;
+        }
+        // when including the opening bracket/paren we consider it complex
+        return !re.source.match(/[{[(]/);
+    }
+    getRegExpParam(re) {
+        const value = re.source
+            .replace(/\.\*/g, '%') // .* -> %
+            .replace(/\./g, '_') // .  -> _
+            .replace(/\\_/g, '.') // \. -> .
+            .replace(/^\^/g, '') // remove ^ from start
+            .replace(/\$$/g, ''); // remove $ from end
+        if (re.source.startsWith('^') && re.source.endsWith('$')) {
+            return value;
+        }
+        if (re.source.startsWith('^')) {
+            return value + '%';
+        }
+        if (re.source.endsWith('$')) {
+            return '%' + value;
+        }
+        return `%${value}%`;
+    }
+    appendOnConflictClause(type, onConflict, qb) {
+        onConflict.forEach(item => {
+            const { fields, ignore } = item;
+            const sub = qb.onConflict({ fields, ignore });
+            Utils.runIfNotEmpty(() => {
+                let mergeParam = item.merge;
+                if (Utils.isObject(item.merge)) {
+                    mergeParam = {};
+                    Utils.keys(item.merge).forEach(key => {
+                        const k = this.mapper(key, type);
+                        mergeParam[k] = item.merge[key];
+                    });
+                }
+                if (Array.isArray(item.merge)) {
+                    mergeParam = item.merge.map(key => this.mapper(key, type));
+                }
+                sub.merge = mergeParam ?? [];
+                if (item.where) {
+                    sub.where = this._appendQueryCondition(type, item.where);
+                }
+            }, 'merge' in item);
+        });
+    }
+    appendQueryCondition(type, cond, qb, operator, method = 'where') {
+        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) {
+                    this.append(() => this.appendGroupCondition(type, k, cond[k]), parts, params, operator);
+                    continue;
+                }
+                this.append(() => this.appendGroupCondition(type, k, cond[k]), parts, params);
+                continue;
+            }
+            if (k === '$not') {
+                const res = this._appendQueryCondition(type, cond[k]);
+                parts.push(`not (${res.sql})`);
+                params.push(...res.params);
+                continue;
+            }
+            this.append(() => this.appendQuerySubCondition(type, cond, k), parts, params);
+        }
+        return { sql: parts.join(' and '), params };
+    }
+    append(cb, parts, params, operator) {
+        const res = cb();
+        if (['', '()'].includes(res.sql)) {
+            return;
+        }
+        parts.push(operator === '$or' ? `(${res.sql})` : res.sql);
+        res.params.forEach(p => params.push(p));
+    }
+    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]));
+            return { sql: parts.join(' and '), params };
+        }
+        if (Utils.isPlainObject(cond[key]) || cond[key] instanceof RegExp) {
+            return this.processObjectSubCondition(cond, key, type);
+        }
+        const op = cond[key] === null ? 'is' : '=';
+        const raw = RawQueryFragment.getKnownFragment(key);
+        if (raw) {
+            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);
+                parts.push(`${sql} ${op} ${val}`);
+                return { sql: parts.join(' and '), params };
+            }
+            parts.push(sql);
+            return { sql: parts.join(' and '), params };
+        }
+        if (this.subQueries[key]) {
+            const val = this.getValueReplacement(fields, cond[key], params, key);
+            parts.push(`(${this.subQueries[key]}) ${op} ${val}`);
+            return { sql: parts.join(' and '), params };
+        }
+        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, type) {
+        const parts = [];
+        const params = [];
+        let value = cond[key];
+        const size = Utils.getObjectKeysSize(value);
+        if (Utils.isPlainObject(value) && size === 0) {
+            return { sql: '', params };
+        }
+        // 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) {
+                this.append(() => this._appendQueryCondition(type, sub, '$and'), parts, params);
+            }
+            return { sql: parts.join(' and '), params };
+        }
+        if (value instanceof RegExp) {
+            value = this.platform.getRegExpValue(value);
+        }
+        // operators
+        const op = Object.keys(QueryOperator).find(op => op in value);
+        /* v8 ignore next */
+        if (!op) {
+            throw ValidationError.invalidQueryCondition(cond);
+        }
+        const replacement = this.getOperatorReplacement(op, value);
+        const fields = Utils.splitPrimaryKeys(key);
+        if (fields.length > 1 && Array.isArray(value[op])) {
+            const singleTuple = !value[op].every((v) => Array.isArray(v));
+            if (!this.platform.allowsComparingTuples()) {
+                const mapped = fields.map(f => this.mapper(f, type));
+                if (op === '$in') {
+                    const conds = value[op].map(() => {
+                        return `(${mapped.map(field => `${this.platform.quoteIdentifier(field)} = ?`).join(' and ')})`;
+                    });
+                    parts.push(`(${conds.join(' or ')})`);
+                    params.push(...Utils.flatten(value[op]));
+                    return { sql: parts.join(' and '), params };
+                }
+                parts.push(...mapped.map(field => `${this.platform.quoteIdentifier(field)} = ?`));
+                params.push(...Utils.flatten(value[op]));
+                return { sql: parts.join(' and '), params };
+            }
+            if (singleTuple) {
+                const tmp = value[op].length === 1 && Utils.isPlainObject(value[op][0]) ? fields.map(f => value[op][0][f]) : value[op];
+                const sql = `(${fields.map(() => '?').join(', ')})`;
+                value[op] = raw(sql, tmp);
+            }
+        }
+        if (this.subQueries[key]) {
+            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') {
+            /* v8 ignore next */
+            if (!prop) {
+                throw new Error(`Cannot use $fulltext operator on ${key}, property not found`);
+            }
+            const { sql, params: params2 } = raw(this.platform.getFullTextWhereClause(prop), {
+                column: this.mapper(key, type, undefined, null),
+                query: value[op],
+            });
+            parts.push(sql);
+            params.push(...params2);
+        }
+        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) {
+            const query = value[op] instanceof 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);
+            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 ArrayType) {
+                const item = prop.customType.convertToDatabaseValue(value, this.platform, { fromQuery: true, key, mode: 'query' });
+                params.push(item);
+            }
+            else {
+                value.forEach(v => params.push(v));
+            }
+            return `(${value.map(() => '?').join(', ')})`;
+        }
+        if (value === null) {
+            return 'null';
+        }
+        params.push(value);
+        return '?';
+    }
+    getOperatorReplacement(op, value) {
+        let replacement = QueryOperator[op];
+        if (op === '$exists') {
+            replacement = value[op] ? 'is not' : 'is';
+            value[op] = null;
+        }
+        if (value[op] === null && ['$eq', '$ne'].includes(op)) {
+            replacement = op === '$eq' ? 'is' : 'is not';
+        }
+        if (op === '$re') {
+            replacement = this.platform.getRegExpOperator(value[op], value.$flags);
+        }
+        if (replacement.includes('?')) {
+            replacement = replacement.replaceAll('?', '\\?');
+        }
+        return replacement;
+    }
+    getQueryOrder(type, orderBy, populate) {
+        if (Array.isArray(orderBy)) {
+            return orderBy.flatMap(o => this.getQueryOrder(type, o, populate));
+        }
+        return this.getQueryOrderFromObject(type, orderBy, populate);
+    }
+    getQueryOrderFromObject(type, orderBy, populate) {
+        const ret = [];
+        for (const key of Object.keys(orderBy)) {
+            const direction = orderBy[key];
+            const order = typeof direction === 'number' ? QueryOrderNumeric[direction] : direction;
+            const raw = RawQueryFragment.getKnownFragment(key);
+            if (raw) {
+                ret.push(...this.platform.getOrderByExpression(this.platform.formatQuery(raw.sql, raw.params), order));
+                continue;
+            }
+            for (const f of Utils.splitPrimaryKeys(key)) {
+                // eslint-disable-next-line prefer-const
+                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 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;
+                const customOrder = prop?.customOrder;
+                let colPart = customOrder
+                    ? this.platform.generateCustomOrder(rawColumn, customOrder)
+                    : rawColumn;
+                if (isRaw(colPart)) {
+                    colPart = this.platform.formatQuery(colPart.sql, colPart.params);
+                }
+                if (Array.isArray(order)) {
+                    order.forEach(part => ret.push(...this.getQueryOrderFromObject(type, part, populate)));
+                }
+                else {
+                    ret.push(...this.platform.getOrderByExpression(colPart, order));
+                }
+            }
+        }
+        return ret;
+    }
+    finalize(type, qb, meta, data, returning) {
+        const usesReturningStatement = this.platform.usesReturningStatement() || this.platform.usesOutputStatement();
+        if (!meta || !data || !usesReturningStatement) {
+            return;
+        }
+        // always respect explicit returning hint
+        if (returning && returning.length > 0) {
+            qb.returning(returning.map(field => this.mapper(field, type)));
+            return;
+        }
+        if (type === QueryType.INSERT) {
+            const returningProps = meta.hydrateProps
+                .filter(prop => prop.returning || (prop.persist !== false && ((prop.primary && prop.autoincrement) || prop.defaultRaw)))
+                .filter(prop => !(prop.name in data));
+            if (returningProps.length > 0) {
+                qb.returning(Utils.flatten(returningProps.map(prop => prop.fieldNames)));
+            }
+            return;
+        }
+        if (type === QueryType.UPDATE) {
+            const returningProps = meta.hydrateProps.filter(prop => prop.fieldNames && 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 [raw(sql)];
+                    }
+                    return prop.fieldNames;
+                }));
+            }
+        }
+    }
+    splitField(field, greedyAlias = false) {
+        const parts = field.split('.');
+        const ref = parts[parts.length - 1].split(':')[1];
+        if (ref) {
+            parts[parts.length - 1] = parts[parts.length - 1].substring(0, parts[parts.length - 1].indexOf(':'));
+        }
+        if (parts.length === 1) {
+            return [this.alias, parts[0], ref];
+        }
+        if (greedyAlias) {
+            const fromField = parts.pop();
+            const fromAlias = parts.join('.');
+            return [fromAlias, fromField, ref];
+        }
+        const fromAlias = parts.shift();
+        const fromField = parts.join('.');
+        return [fromAlias, fromField, ref];
+    }
+    getLockSQL(qb, lockMode, lockTables = [], joinsMap) {
+        const meta = this.metadata.find(this.entityName);
+        if (lockMode === LockMode.OPTIMISTIC && meta && !meta.versionProperty) {
+            throw OptimisticLockError.lockFailed(this.entityName);
+        }
+        if (lockMode !== LockMode.OPTIMISTIC && lockTables.length === 0 && joinsMap) {
+            const joins = Object.values(joinsMap);
+            const innerJoins = joins.filter(join => [JoinType.innerJoin, JoinType.innerJoinLateral, JoinType.nestedInnerJoin].includes(join.type));
+            if (joins.length > innerJoins.length) {
+                lockTables.push(this.alias, ...innerJoins.map(join => join.alias));
+            }
+        }
+        qb.lockMode(lockMode, lockTables);
+    }
+    updateVersionProperty(qb, data) {
+        const meta = this.metadata.find(this.entityName);
+        if (!meta?.versionProperty || meta.versionProperty in data) {
+            return;
+        }
+        const versionProperty = meta.properties[meta.versionProperty];
+        let sql = this.platform.quoteIdentifier(versionProperty.fieldNames[0]) + ' + 1';
+        if (versionProperty.runtimeType === 'Date') {
+            sql = this.platform.getCurrentTimestampSQL(versionProperty.length);
+        }
+        qb.update({ [versionProperty.fieldNames[0]]: raw(sql) });
+    }
+    prefix(field, always = false, quote = false, idx) {
+        let ret;
+        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) {
+                return fieldName.sql;
+            }
+            ret = alias + fieldName;
+        }
+        else {
+            const [a, ...rest] = field.split('.');
+            const f = rest.join('.');
+            const fieldName = this.fieldName(f, a, always, idx);
+            if (fieldName instanceof RawQueryFragment) {
+                return fieldName.sql;
+            }
+            ret = a + '.' + fieldName;
+        }
+        if (quote) {
+            return this.platform.quoteIdentifier(ret);
+        }
+        return ret;
+    }
+    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') {
+            for (const sub of subCondition) {
+                this.append(() => this._appendQueryCondition(type, sub), parts, params);
+            }
+            return { sql: parts.join(' and '), params };
+        }
+        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 = !Utils.isPlainObject(val) || Utils.getObjectKeysSize(val) === 1 || Object.keys(val).every(k => !Utils.isOperator(k));
+            if (keys.length === 1 && simple) {
+                this.append(() => this._appendQueryCondition(type, sub, operator), parts, params);
+                continue;
+            }
+            this.append(() => this._appendQueryCondition(type, sub), parts, params, operator);
+        }
+        return { sql: `(${parts.join(' or ')})`, params };
+    }
+    isPrefixed(field) {
+        return !!field.match(/[\w`"[\]]+\./);
+    }
+    fieldName(field, alias, always, idx = 0) {
+        const prop = this.getProperty(field, alias);
+        if (!prop) {
+            return field;
+        }
+        if (prop.fieldNameRaw) {
+            if (!always) {
+                return raw(prop.fieldNameRaw
+                    .replace(new RegExp(ALIAS_REPLACEMENT_RE + '\\.?', 'g'), '')
+                    .replace(this.platform.quoteIdentifier('') + '.', ''));
+            }
+            if (alias) {
+                return raw(prop.fieldNameRaw.replace(new RegExp(ALIAS_REPLACEMENT_RE, 'g'), alias));
+            }
+            /* v8 ignore next */
+            return raw(prop.fieldNameRaw);
+        }
+        /* v8 ignore next */
+        return prop.fieldNames?.[idx] ?? field;
+    }
+    getProperty(field, alias) {
+        const entityName = this.aliasMap[alias]?.entityName || this.entityName;
+        const meta = this.metadata.find(entityName);
+        // check if `alias` is not matching an embedded property name instead of alias, e.g. `address.city`
+        if (alias && meta) {
+            const prop = meta.properties[alias];
+            if (prop?.kind === ReferenceKind.EMBEDDED) {
+                // we want to select the full object property so hydration works as expected
+                if (prop.object) {
+                    return prop;
+                }
+                const parts = field.split('.');
+                const nest = (p) => parts.length > 0 ? nest(p.embeddedProps[parts.shift()]) : p;
+                return nest(prop);
+            }
+        }
+        if (meta) {
+            if (meta.properties[field]) {
+                return meta.properties[field];
+            }
+            return meta.relations.find(prop => prop.fieldNames?.some(name => field === name));
+        }
+        return undefined;
+    }
+    isTableNameAliasRequired(type) {
+        return [QueryType.SELECT, QueryType.COUNT].includes(type);
+    }
+    processOnConflictCondition(cond, schema) {
+        const meta = this.metadata.get(this.entityName);
+        const tableName = meta.tableName;
+        for (const key of Object.keys(cond)) {
+            const mapped = this.mapper(key, QueryType.UPSERT);
+            Utils.renameKey(cond, key, tableName + '.' + mapped);
+        }
+        return cond;
+    }
+}