@mikro-orm/knex 6.0.0-dev.50 → 6.0.0-dev.52

package/AbstractSqlDriver.js

@@ -638,11 +638,11 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const aliased = qb.ref(tableAlias ? `${tableAlias}__${prop.fieldNames[0]}` : prop.fieldNames[0]).toString();
         if (prop.customType?.convertToJSValueSQL && tableAlias) {
             const prefixed = qb.ref(prop.fieldNames[0]).withSchema(tableAlias).toString();
-            return [prop.customType.convertToJSValueSQL(prefixed, this.platform) + ' as ' + aliased];
+            return [(0, core_1.raw)(`${prop.customType.convertToJSValueSQL(prefixed, this.platform)} as ${aliased}`)];
         }
         if (prop.formula) {
             const alias = qb.ref(tableAlias ?? qb.alias).toString();
-            return [`${prop.formula(alias)} as ${aliased}`];
+            return [(0, core_1.raw)(`${prop.formula(alias)} as ${aliased}`)];
         }
         if (tableAlias) {
             return prop.fieldNames.map(fieldName => qb.ref(fieldName).withSchema(tableAlias).as(`${tableAlias}__${fieldName}`));
@@ -739,7 +739,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const meta = (0, core_1.helper)(entity).__meta;
         const qb = this.createQueryBuilder(entity.constructor.name, options.ctx).unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES).withSchema(options.schema ?? meta.schema);
         const cond = core_1.Utils.getPrimaryKeyCond(entity, meta.primaryKeys);
-        qb.select('1').where(cond).setLockMode(options.lockMode, options.lockTableAliases);
+        qb.select((0, core_1.raw)('1')).where(cond).setLockMode(options.lockMode, options.lockTableAliases);
         await this.rethrow(qb.execute());
     }
     buildJoinedPropsOrderBy(entityName, qb, meta, populate, parentPath) {
@@ -805,6 +805,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const requiresSQLConversion = meta.props.some(p => p.customType?.convertToJSValueSQL);
         const hasExplicitFields = !!fields;
         const ret = [];
+        let addFormulas = false;
         if (joinedProps.length > 0) {
             ret.push(...this.getFieldsForJoinedLoad(qb, meta, fields, populate));
         }
@@ -830,17 +831,19 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         else if (lazyProps.filter(p => !p.formula).length > 0) {
             const props = meta.props.filter(prop => this.platform.shouldHaveColumn(prop, populate, false));
             ret.push(...core_1.Utils.flatten(props.filter(p => !lazyProps.includes(p)).map(p => p.fieldNames)));
+            addFormulas = true;
         }
         else if (hasLazyFormulas || requiresSQLConversion) {
             ret.push('*');
+            addFormulas = true;
         }
-        if (ret.length > 0 && !hasExplicitFields) {
+        if (ret.length > 0 && !hasExplicitFields && addFormulas) {
             meta.props
                 .filter(prop => prop.formula && !lazyProps.includes(prop))
                 .forEach(prop => {
                 const alias = qb.ref(qb.alias).toString();
                 const aliased = qb.ref(prop.fieldNames[0]).toString();
-                ret.push(`${prop.formula(alias)} as ${aliased}`);
+                ret.push((0, core_1.raw)(`${prop.formula(alias)} as ${aliased}`));
             });
             meta.props
                 .filter(prop => prop.customType?.convertToDatabaseValueSQL || prop.customType?.convertToJSValueSQL)

package/AbstractSqlPlatform.js

@@ -48,22 +48,26 @@ class AbstractSqlPlatform extends core_1.Platform {
         let j = 0;
         let pos = 0;
         let ret = '';
+        if (sql[0] === '?' && sql[1] !== '?') {
+            ret += this.quoteValue(params[j++]);
+            pos = 1;
+        }
         while (pos < sql.length) {
             const idx = sql.indexOf('?', pos + 1);
             if (idx === -1) {
                 ret += sql.substring(pos, sql.length);
                 break;
             }
-            if (sql.substr(idx - 1, 2) === '\\?') {
-                ret += sql.substr(pos, idx - pos - 1) + '?';
+            if (sql.substring(idx - 1, idx + 1) === '\\?') {
+                ret += sql.substring(pos, idx - 1) + '?';
                 pos = idx + 1;
             }
-            else if (sql.substr(idx, 2) === '??') {
-                ret += sql.substr(pos, idx - pos) + this.quoteIdentifier(params[j++]);
+            else if (sql.substring(idx, idx + 2) === '??') {
+                ret += sql.substring(pos, idx) + this.quoteIdentifier(params[j++]);
                 pos = idx + 2;
             }
             else {
-                ret += sql.substr(pos, idx - pos) + this.quoteValue(params[j++]);
+                ret += sql.substring(pos, idx) + this.quoteValue(params[j++]);
                 pos = idx + 1;
             }
         }

package/MonkeyPatchable.d.ts

@@ -3,6 +3,7 @@ export declare const MonkeyPatchable: {
     QueryExecutioner: any;
     MySqlDialect: any;
     MySqlColumnCompiler: any;
+    MySqlQueryCompiler: any;
     PostgresDialectTableCompiler: any;
     Sqlite3Dialect: any;
     Sqlite3DialectTableCompiler: any;

package/MonkeyPatchable.js

@@ -13,6 +13,8 @@ const mysql_1 = __importDefault(require("knex/lib/dialects/mysql"));
 // @ts-ignore
 const mysql_columncompiler_1 = __importDefault(require("knex/lib/dialects/mysql/schema/mysql-columncompiler"));
 // @ts-ignore
+const mysql_querycompiler_1 = __importDefault(require("knex/lib/dialects/mysql/query/mysql-querycompiler"));
+// @ts-ignore
 const pg_tablecompiler_1 = __importDefault(require("knex/lib/dialects/postgres/schema/pg-tablecompiler"));
 // @ts-ignore
 const sqlite3_1 = __importDefault(require("knex/lib/dialects/sqlite3"));
@@ -29,6 +31,7 @@ exports.MonkeyPatchable = {
     QueryExecutioner: query_executioner_1.default,
     MySqlDialect: mysql_1.default,
     MySqlColumnCompiler: mysql_columncompiler_1.default,
+    MySqlQueryCompiler: mysql_querycompiler_1.default,
     PostgresDialectTableCompiler: pg_tablecompiler_1.default,
     Sqlite3Dialect: sqlite3_1.default,
     Sqlite3DialectTableCompiler: sqlite_tablecompiler_1.default,

package/index.mjs

@@ -1,6 +1,8 @@
 import mod from "./index.js";
 
 export default mod;
+export const ALIAS_REPLACEMENT = mod.ALIAS_REPLACEMENT;
+export const ALIAS_REPLACEMENT_RE = mod.ALIAS_REPLACEMENT_RE;
 export const ARRAY_OPERATORS = mod.ARRAY_OPERATORS;
 export const AbstractNamingStrategy = mod.AbstractNamingStrategy;
 export const AbstractSchemaGenerator = mod.AbstractSchemaGenerator;
@@ -186,7 +188,6 @@ export const compareBuffers = mod.compareBuffers;
 export const compareObjects = mod.compareObjects;
 export const defineConfig = mod.defineConfig;
 export const equals = mod.equals;
-export const expr = mod.expr;
 export const helper = mod.helper;
 export const knex = mod.knex;
 export const parseJsonSafe = mod.parseJsonSafe;
@@ -194,6 +195,7 @@ export const raw = mod.raw;
 export const ref = mod.ref;
 export const rel = mod.rel;
 export const serialize = mod.serialize;
+export const sql = mod.sql;
 export const t = mod.t;
 export const types = mod.types;
 export const wrap = mod.wrap;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.0.0-dev.50",
+  "version": "6.0.0-dev.52",
   "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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -66,6 +66,6 @@
     "@mikro-orm/core": "^5.6.16"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "~6.0.0-dev.50"
+    "@mikro-orm/core": "~6.0.0-dev.52"
   }
 }

package/query/ObjectCriteriaNode.js

@@ -21,7 +21,7 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
             const childNode = this.payload[field];
             const payload = childNode.process(qb, this.prop ? alias : ownerAlias);
             const operator = core_1.Utils.isOperator(field);
-            const customExpression = ObjectCriteriaNode.isCustomExpression(field);
+            const isRawField = core_1.RawQueryFragment.isKnownFragment(field);
             // we need to keep the prefixing for formulas otherwise we would lose aliasing context when nesting inside group operators
             const virtual = childNode.prop?.persist === false && !childNode.prop?.formula;
             // if key is missing, we are inside group operator and we need to prefix with alias
@@ -33,8 +33,12 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
             else if (childNode.shouldRename(payload)) {
                 o[childNode.renameFieldToPK(qb)] = payload;
             }
-            else if (primaryKey || virtual || operator || customExpression || field.includes('.') || ![enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(qb.type ?? enums_1.QueryType.SELECT)) {
-                o[field.replace(/\[::alias::]/g, alias)] = payload;
+            else if (isRawField) {
+                const rawField = core_1.RawQueryFragment.getKnownFragment(field);
+                o[(0, core_1.raw)(rawField.sql.replaceAll(core_1.ALIAS_REPLACEMENT, alias), rawField.params)] = payload;
+            }
+            else if (primaryKey || virtual || operator || field.includes('.') || ![enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(qb.type ?? enums_1.QueryType.SELECT)) {
+                o[field.replaceAll(core_1.ALIAS_REPLACEMENT, alias)] = payload;
             }
             else {
                 o[`${alias}.${field}`] = payload;

package/query/QueryBuilder.d.ts

@@ -29,6 +29,7 @@ import type { Field } from '../typings';
  * ```
  */
 export declare class QueryBuilder<T extends object = AnyEntity> {
+    #private;
     private readonly metadata;
     private readonly driver;
     private readonly context?;
@@ -139,6 +140,11 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
      * Returns the query with parameters as wildcards.
      */
     getQuery(): string;
+    toQuery(): {
+        sql: string;
+        _sql: Knex.Sql;
+        params: readonly unknown[];
+    };
     /**
      * Returns the list of all parameters for this query.
      */

package/query/QueryBuilder.js

@@ -1,4 +1,16 @@
 "use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _QueryBuilder_query;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryBuilder = void 0;
 const util_1 = require("util");
@@ -64,6 +76,7 @@ class QueryBuilder {
         this._aliases = {};
         this.platform = this.driver.getPlatform();
         this.knex = this.driver.getConnection(this.connectionType).getKnex();
+        _QueryBuilder_query.set(this, void 0);
         if (alias) {
             this.aliasCounter++;
             this._explicitAlias = true;
@@ -165,9 +178,15 @@ class QueryBuilder {
     }
     where(cond, params, operator) {
         this.ensureNotFinalized();
-        if (core_1.Utils.isString(cond)) {
-            cond = { [`(${cond})`]: core_1.Utils.asArray(params) };
-            operator = operator || '$and';
+        const rawField = core_1.RawQueryFragment.getKnownFragment(cond);
+        if (rawField) {
+            const sql = this.platform.formatQuery(rawField.sql, rawField.params);
+            cond = { [(0, core_1.raw)(`(${sql})`)]: core_1.Utils.asArray(params) };
+            operator ??= '$and';
+        }
+        else if (core_1.Utils.isString(cond)) {
+            cond = { [(0, core_1.raw)(`(${cond})`, core_1.Utils.asArray(params))]: [] };
+            operator ??= '$and';
         }
         else {
             cond = core_1.QueryHelper.processWhere({
@@ -235,7 +254,7 @@ class QueryBuilder {
     having(cond = {}, params) {
         this.ensureNotFinalized();
         if (core_1.Utils.isString(cond)) {
-            cond = { [`(${cond})`]: core_1.Utils.asArray(params) };
+            cond = { [(0, core_1.raw)(`(${cond})`, params)]: [] };
         }
         this._having = CriteriaNodeFactory_1.CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, cond).process(this);
         return this;
@@ -376,19 +395,27 @@ class QueryBuilder {
      * Returns the query with parameters as wildcards.
      */
     getQuery() {
-        return this.getKnexQuery().toSQL().toNative().sql;
+        return this.toQuery().sql;
+    }
+    toQuery() {
+        if (__classPrivateFieldGet(this, _QueryBuilder_query, "f")) {
+            return __classPrivateFieldGet(this, _QueryBuilder_query, "f");
+        }
+        const sql = this.getKnexQuery().toSQL();
+        const query = sql.toNative();
+        return __classPrivateFieldSet(this, _QueryBuilder_query, { sql: query.sql, params: query.bindings ?? [], _sql: sql }, "f");
     }
     /**
      * Returns the list of all parameters for this query.
      */
     getParams() {
-        return this.getKnexQuery().toSQL().toNative().bindings;
+        return this.toQuery().params;
     }
     /**
      * Returns raw interpolated query string with all the parameters inlined.
      */
     getFormattedQuery() {
-        const query = this.getKnexQuery().toSQL();
+        const query = this.toQuery()._sql;
         return this.platform.formatQuery(query.sql, query.bindings);
     }
     /**
@@ -632,6 +659,12 @@ class QueryBuilder {
     prepareFields(fields, type = 'where') {
         const ret = [];
         fields.forEach(field => {
+            const rawField = core_1.RawQueryFragment.getKnownFragment(field);
+            if (rawField) {
+                const sql = this.platform.formatQuery(rawField.sql, rawField.params);
+                ret.push(this.knex.raw(sql));
+                return;
+            }
             if (!core_1.Utils.isString(field)) {
                 ret.push(field);
                 return;
@@ -799,8 +832,13 @@ class QueryBuilder {
                 const aliased = this.knex.ref(prop.fieldNames[0]).toString();
                 return `${prop.formula(alias)} as ${aliased}`;
             })
-                .filter(field => !this._fields.includes(field))
-                .forEach(field => this.addSelect(field));
+                .filter(field => !this._fields.some(f => {
+                if (f instanceof core_1.RawQueryFragment) {
+                    return f.sql === field && f.params.length === 0;
+                }
+                return f === field;
+            }))
+                .forEach(field => this._fields.push((0, core_1.raw)(field)));
         }
         this.processPopulateWhere();
         core_1.QueryHelper.processObjectParams(this._data);
@@ -877,7 +915,7 @@ class QueryBuilder {
                     if (!prop?.persist && !prop?.formula) {
                         addToSelect.push(fieldName);
                     }
-                    orderBy.push({ [`min(${this.ref(fieldName)}${type})`]: direction });
+                    orderBy.push({ [(0, core_1.raw)(`min(${this.ref(fieldName)}${type})`)]: direction });
                 }
             }
             subQuery.orderBy(orderBy);
@@ -969,7 +1007,7 @@ class QueryBuilder {
         }
     }
     /* istanbul ignore next */
-    [util_1.inspect.custom](depth) {
+    [(_QueryBuilder_query = new WeakMap(), util_1.inspect.custom)](depth) {
         const object = { ...this };
         const hidden = ['metadata', 'driver', 'context', 'platform', 'knex', 'type'];
         Object.keys(object).filter(k => k.startsWith('_')).forEach(k => delete object[k]);

package/query/QueryBuilderHelper.d.ts

@@ -43,7 +43,6 @@ export declare class QueryBuilderHelper {
     }[], qb: Knex.QueryBuilder): void;
     appendQueryCondition(type: QueryType, cond: any, qb: Knex.QueryBuilder, operator?: '$and' | '$or', method?: 'where' | 'having'): void;
     private appendQuerySubCondition;
-    private processCustomExpression;
     private processObjectSubCondition;
     private getOperatorReplacement;
     getQueryOrder(type: QueryType, orderBy: FlatQueryOrderMap | FlatQueryOrderMap[], populate: Dictionary<string>): string;
@@ -52,7 +51,6 @@ export declare class QueryBuilderHelper {
     splitField<T>(field: EntityKey<T>, greedyAlias?: boolean): [string, EntityKey<T>];
     getLockSQL(qb: Knex.QueryBuilder, lockMode: LockMode, lockTables?: string[]): void;
     updateVersionProperty(qb: Knex.QueryBuilder, data: Dictionary): void;
-    static isCustomExpression(field: string, hasAlias?: boolean): boolean;
     private prefix;
     private appendGroupCondition;
     private isPrefixed;

package/query/QueryBuilderHelper.js

@@ -20,7 +20,7 @@ class QueryBuilderHelper {
     }
     mapper(field, type = enums_1.QueryType.SELECT, value, alias) {
         if (core_1.Utils.isRawSql(field)) {
-            return this.platform.formatQuery(field.sql, field.params ?? []);
+            return this.knex.raw(field.sql, field.params);
         }
         if (typeof field !== 'string') {
             return field;
@@ -52,10 +52,13 @@ class QueryBuilderHelper {
             }
             return this.knex.raw('(' + parts.map(part => this.knex.ref(part)).join(', ') + ')');
         }
-        let ret = field;
-        const customExpression = QueryBuilderHelper.isCustomExpression(field, !!alias);
+        const rawField = core_1.RawQueryFragment.getKnownFragment(field);
+        if (rawField) {
+            return this.knex.raw(rawField.sql, rawField.params);
+        }
         const [a, f] = this.splitField(field);
         const prop = this.getProperty(f, a);
+        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[0];
@@ -79,16 +82,12 @@ class QueryBuilderHelper {
             return this.knex.raw(`${valueSQL} as ${this.platform.quoteIdentifier(alias ?? prop.fieldNames[0])}`);
         }
         // do not wrap custom expressions
-        if (!customExpression) {
+        if (!rawField) {
             ret = this.prefix(field);
         }
         if (alias) {
             ret += ' as ' + alias;
         }
-        if (customExpression) {
-            const bindings = core_1.Utils.asArray(value).slice(0, ret.match(/\?/g)?.length ?? 0);
-            return this.knex.raw(ret, bindings);
-        }
         if (!isTableNameAliasRequired || this.isPrefixed(ret) || noPrefix) {
             return ret;
         }
@@ -227,20 +226,14 @@ class QueryBuilderHelper {
         if (operator === '$exists') {
             value = null;
         }
-        if (QueryBuilderHelper.isCustomExpression(key)) {
-            // unwind parameters when ? found in field name
-            const count = key.concat('?').match(/\?/g).length - 1;
-            const values = core_1.Utils.asArray(value);
-            const params1 = values.slice(0, count).map((c) => core_1.Utils.isObject(c) ? JSON.stringify(c) : c);
-            const params2 = values.slice(count);
-            const k = this.mapper(key, enums_1.QueryType.SELECT, params1);
-            const { sql, bindings } = k.toSQL().toNative();
-            if (params2.length > 0) {
-                params.push(...bindings);
-                params.push(...params2);
-                return sql + ' = ?';
+        const rawField = core_1.RawQueryFragment.getKnownFragment(key);
+        if (rawField) {
+            let sql = rawField.sql;
+            params.push(...rawField.params);
+            params.push(...core_1.Utils.asArray(value));
+            if (core_1.Utils.asArray(value).length > 0) {
+                sql += ' = ?';
             }
-            params.push(...bindings);
             return sql;
         }
         const sql = this.mapper(key);
@@ -351,28 +344,20 @@ class QueryBuilderHelper {
         if (core_1.Utils.isPlainObject(cond[key]) || cond[key] instanceof RegExp) {
             return this.processObjectSubCondition(cond, key, qb, method, m, type);
         }
-        if (QueryBuilderHelper.isCustomExpression(key)) {
-            return this.processCustomExpression(qb, m, key, cond, type);
-        }
         const op = cond[key] === null ? 'is' : '=';
+        const raw = core_1.RawQueryFragment.getKnownFragment(key);
+        if (raw) {
+            const value = core_1.Utils.asArray(cond[key]);
+            if (value.length > 0) {
+                return void qb[m](this.knex.raw(raw.sql, raw.params), op, value[0]);
+            }
+            return void qb[m](this.knex.raw(raw.sql, raw.params));
+        }
         if (this.subQueries[key]) {
             return void qb[m](this.knex.raw(`(${this.subQueries[key]})`), op, cond[key]);
         }
         qb[m](this.mapper(key, type, cond[key], null), op, cond[key]);
     }
-    processCustomExpression(clause, m, key, cond, type) {
-        // unwind parameters when ? found in field name
-        const count = key.concat('?').match(/\?/g).length - 1;
-        const value = core_1.Utils.asArray(cond[key]);
-        const params1 = value.slice(0, count).map((c) => core_1.Utils.isObject(c) ? JSON.stringify(c) : c);
-        const params2 = value.slice(count);
-        const k = this.mapper(key, type, params1);
-        if (params2.length > 0) {
-            const val = params2.length === 1 && params2[0] === null ? null : this.knex.raw('?', params2);
-            return void clause[m](k, val);
-        }
-        clause[m](k);
-    }
     processObjectSubCondition(cond, key, qb, method, m, type) {
         // grouped condition for one field
         let value = cond[key];
@@ -438,19 +423,20 @@ class QueryBuilderHelper {
     }
     getQueryOrderFromObject(type, orderBy, populate) {
         const ret = [];
-        Object.keys(orderBy).forEach(k => {
-            const direction = orderBy[k];
+        Object.keys(orderBy).forEach(key => {
+            const direction = orderBy[key];
             const order = core_1.Utils.isNumber(direction) ? core_1.QueryOrderNumeric[direction] : direction;
-            if (QueryBuilderHelper.isCustomExpression(k)) {
-                ret.push(`${k} ${order.toLowerCase()}`);
+            const raw = core_1.RawQueryFragment.getKnownFragment(key);
+            if (raw) {
+                ret.push(`${this.platform.formatQuery(raw.sql, raw.params)} ${order.toLowerCase()}`);
                 return;
             }
-            core_1.Utils.splitPrimaryKeys(k).forEach(f => {
+            core_1.Utils.splitPrimaryKeys(key).forEach(f => {
                 // 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 && prop.persist === false && !prop.formula) || QueryBuilderHelper.isCustomExpression(f);
+                const noPrefix = (prop && prop.persist === false && !prop.formula) || 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;
@@ -522,20 +508,20 @@ class QueryBuilderHelper {
         }
         qb.update(versionProperty.fieldNames[0], this.knex.raw(sql));
     }
-    static isCustomExpression(field, hasAlias = false) {
-        // if we do not have alias, we don't consider spaces as custom expressions
-        const re = hasAlias ? /[ ?<>=()'"`:]|^\d/ : /[?<>=()'"`:]|^\d/;
-        return !!field.match(re);
-    }
     prefix(field, always = false, quote = false) {
         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);
-            if (QueryBuilderHelper.isCustomExpression(fieldName)) {
-                return fieldName;
+            if (fieldName instanceof core_1.RawQueryFragment) {
+                return fieldName.sql;
+            }
+            if (this.isPrefixed(fieldName)) {
+                ret = fieldName;
+            }
+            else {
+                ret = alias + fieldName;
             }
-            ret = alias + fieldName;
         }
         else {
             const [a, ...rest] = field.split('.');
@@ -573,15 +559,15 @@ class QueryBuilderHelper {
         }
         if (prop.fieldNameRaw) {
             if (!always) {
-                return prop.fieldNameRaw
-                    .replace(/\[::alias::]\.?/g, '')
-                    .replace(this.platform.quoteIdentifier('') + '.', '');
+                return (0, core_1.raw)(prop.fieldNameRaw
+                    .replace(new RegExp(core_1.ALIAS_REPLACEMENT_RE + '\\.?', 'g'), '')
+                    .replace(this.platform.quoteIdentifier('') + '.', ''));
             }
             if (alias) {
-                return prop.fieldNameRaw.replace(/\[::alias::]/g, alias);
+                return (0, core_1.raw)(prop.fieldNameRaw.replace(new RegExp(core_1.ALIAS_REPLACEMENT_RE, 'g'), alias));
             }
             /* istanbul ignore next */
-            return prop.fieldNameRaw;
+            return (0, core_1.raw)(prop.fieldNameRaw);
         }
         /* istanbul ignore next */
         return prop.fieldNames?.[0] ?? field;