@mikro-orm/knex 6.4.6-dev.8 → 7.0.0-dev.0

package/query/QueryBuilder.js

@@ -6,6 +6,7 @@ const core_1 = require("@mikro-orm/core");
 const enums_1 = require("./enums");
 const QueryBuilderHelper_1 = require("./QueryBuilderHelper");
 const CriteriaNodeFactory_1 = require("./CriteriaNodeFactory");
+const NativeQueryBuilder_1 = require("./NativeQueryBuilder");
 /**
  * SQL query builder with fluent interface.
  *
@@ -43,19 +44,12 @@ class QueryBuilder {
         this.ensureFromClause();
         return this._helper;
     }
-    /** @internal */
-    type;
-    /** @internal */
-    _fields;
+    get type() {
+        return this._type ?? enums_1.QueryType.SELECT;
+    }
     /** @internal */
     _populate = [];
     /** @internal */
-    _populateWhere;
-    /** @internal */
-    _populateFilter;
-    /** @internal */
-    __populateWhere;
-    /** @internal */
     _populateMap = {};
     /** @internal */
     rawFragments = new Set();
@@ -90,7 +84,6 @@ class QueryBuilder {
     _helper;
     _query;
     platform;
-    knex;
     /**
      * @internal
      */
@@ -102,7 +95,6 @@ class QueryBuilder {
         this.em = em;
         this.loggerContext = loggerContext;
         this.platform = this.driver.getPlatform();
-        this.knex = this.driver.getConnection(this.connectionType).getKnex();
         if (alias) {
             this.aliasCounter++;
             this._explicitAlias = true;
@@ -120,7 +112,7 @@ class QueryBuilder {
     }
     addSelect(fields) {
         this.ensureNotFinalized();
-        if (this.type && this.type !== enums_1.QueryType.SELECT) {
+        if (this._type && this._type !== enums_1.QueryType.SELECT) {
             return this;
         }
         return this.select([...core_1.Utils.asArray(this._fields), ...core_1.Utils.asArray(fields)]);
@@ -170,23 +162,24 @@ class QueryBuilder {
         this.join(field, alias, cond, enums_1.JoinType.innerJoin, undefined, schema);
         return this;
     }
-    innerJoinLateral(field, alias, cond = {}, schema) {
+    innerJoinLateral(field, alias, cond, schema) {
         this.join(field, alias, cond, enums_1.JoinType.innerJoinLateral, undefined, schema);
         return this;
     }
     leftJoin(field, alias, cond = {}, schema) {
         return this.join(field, alias, cond, enums_1.JoinType.leftJoin, undefined, schema);
     }
-    leftJoinLateral(field, alias, cond = {}, schema) {
+    leftJoinLateral(field, alias, cond, schema) {
         return this.join(field, alias, cond, enums_1.JoinType.leftJoinLateral, undefined, schema);
     }
     joinAndSelect(field, alias, cond = {}, type = enums_1.JoinType.innerJoin, path, fields, schema) {
-        if (!this.type) {
+        if (!this._type) {
             this.select('*');
         }
         let subquery;
         if (Array.isArray(field)) {
-            subquery = field[1] instanceof QueryBuilder ? field[1].getFormattedQuery() : field[1].toString();
+            const rawFragment = field[1] instanceof QueryBuilder ? field[1].toRaw() : field[1];
+            subquery = this.platform.formatQuery(rawFragment.sql, rawFragment.params);
             field = field[0];
         }
         const prop = this.joinReference(field, alias, cond, type, path, schema, subquery);
@@ -269,7 +262,12 @@ class QueryBuilder {
     }
     withSubQuery(subQuery, alias) {
         this.ensureNotFinalized();
-        this.subQueries[alias] = subQuery.toString();
+        if (subQuery instanceof core_1.RawQueryFragment) {
+            this.subQueries[alias] = this.platform.formatQuery(subQuery.sql, subQuery.params);
+        }
+        else {
+            this.subQueries[alias] = subQuery.toString();
+        }
         return this;
     }
     where(cond, params, operator) {
@@ -291,7 +289,7 @@ class QueryBuilder {
                 metadata: this.metadata,
                 platform: this.platform,
                 aliasMap: this.getAliasMap(),
-                aliased: !this.type || [enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(this.type),
+                aliased: [enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(this.type),
                 convertCustomTypes: this.flags.has(core_1.QueryFlag.CONVERT_CUSTOM_TYPES),
             });
         }
@@ -336,7 +334,7 @@ class QueryBuilder {
                 metadata: this.metadata,
                 platform: this.platform,
                 aliasMap: this.getAliasMap(),
-                aliased: !this.type || [enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(this.type),
+                aliased: [enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(this.type),
                 convertCustomTypes: false,
                 type: 'orderBy',
             });
@@ -375,7 +373,7 @@ class QueryBuilder {
         this.ensureNotFinalized();
         this._onConflict ??= [];
         this._onConflict.push({
-            fields: core_1.Utils.isRawSql(fields)
+            fields: (0, core_1.isRaw)(fields)
                 ? fields
                 : core_1.Utils.asArray(fields).flatMap(f => {
                     const key = f.toString();
@@ -506,38 +504,33 @@ class QueryBuilder {
         }
         return this;
     }
-    getKnexQuery(processVirtualEntity = true) {
+    getNativeQuery(processVirtualEntity = true) {
         if (this._query?.qb) {
             return this._query.qb;
         }
         this._query = {};
         this.finalize();
         const qb = this.getQueryBase(processVirtualEntity);
-        const type = this.type ?? enums_1.QueryType.SELECT;
-        qb.__raw = true; // tag it as there is now way to check via `instanceof`
-        core_1.Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(type, this._cond, qb), this._cond && !this._onConflict);
+        core_1.Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(this.type, this._cond, qb), this._cond && !this._onConflict);
         core_1.Utils.runIfNotEmpty(() => qb.groupBy(this.prepareFields(this._groupBy, 'groupBy')), this._groupBy);
-        core_1.Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(type, this._having, qb, undefined, 'having'), this._having);
+        core_1.Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(this.type, this._having, qb, undefined, 'having'), this._having);
         core_1.Utils.runIfNotEmpty(() => {
-            const queryOrder = this.helper.getQueryOrder(type, this._orderBy, this._populateMap);
+            const queryOrder = this.helper.getQueryOrder(this.type, this._orderBy, this._populateMap);
             if (queryOrder.length > 0) {
                 const sql = core_1.Utils.unique(queryOrder).join(', ');
-                qb.orderByRaw(sql);
+                qb.orderBy(sql);
                 return;
             }
         }, this._orderBy);
         core_1.Utils.runIfNotEmpty(() => qb.limit(this._limit), this._limit != null);
         core_1.Utils.runIfNotEmpty(() => qb.offset(this._offset), this._offset);
-        core_1.Utils.runIfNotEmpty(() => this._comments.forEach(comment => qb.comment(comment)), this._comments);
-        core_1.Utils.runIfNotEmpty(() => this._hintComments.forEach(comment => qb.hintComment(comment)), this._hintComments);
+        core_1.Utils.runIfNotEmpty(() => qb.comment(this._comments), this._comments);
+        core_1.Utils.runIfNotEmpty(() => qb.hintComment(this._hintComments), this._hintComments);
         core_1.Utils.runIfNotEmpty(() => this.helper.appendOnConflictClause(enums_1.QueryType.UPSERT, this._onConflict, qb), this._onConflict);
-        if (this.type === enums_1.QueryType.TRUNCATE && this.platform.usesCascadeStatement()) {
-            return this._query.qb = this.knex.raw(qb.toSQL().toNative().sql + ' cascade');
-        }
         if (this.lockMode) {
             this.helper.getLockSQL(qb, this.lockMode, this.lockTables);
         }
-        this.helper.finalize(type, qb, this.mainAlias.metadata, this._data, this._returning);
+        this.helper.finalize(this.type, qb, this.mainAlias.metadata, this._data, this._returning);
         this.clearRawFragmentsCache();
         return this._query.qb = qb;
     }
@@ -554,16 +547,21 @@ class QueryBuilder {
     getQuery() {
         return this.toQuery().sql;
     }
+    /**
+     * Returns raw fragment representation of this QueryBuilder.
+     */
+    toRaw() {
+        const { sql, params } = this.toQuery();
+        return (0, core_1.raw)(sql, params);
+    }
     toQuery() {
         if (this._query?.sql) {
-            return { sql: this._query.sql, _sql: this._query._sql, params: this._query.params };
+            return { sql: this._query.sql, params: this._query.params };
         }
-        const sql = this.getKnexQuery().toSQL();
-        const query = sql.toNative();
+        const query = this.getNativeQuery().compile();
         this._query.sql = query.sql;
-        this._query._sql = sql;
-        this._query.params = query.bindings ?? [];
-        return { sql: this._query.sql, _sql: this._query._sql, params: this._query.params };
+        this._query.params = query.params;
+        return { sql: this._query.sql, params: this._query.params };
     }
     /**
      * Returns the list of all parameters for this query.
@@ -575,8 +573,8 @@ class QueryBuilder {
      * Returns raw interpolated query string with all the parameters inlined.
      */
     getFormattedQuery() {
-        const query = this.toQuery()._sql;
-        return this.platform.formatQuery(query.sql, query.bindings);
+        const query = this.toQuery();
+        return this.platform.formatQuery(query.sql, query.params);
     }
     /**
      * @internal
@@ -642,7 +640,7 @@ class QueryBuilder {
         options = typeof options === 'boolean' ? { mapResults: options } : (options ?? {});
         options.mergeResults ??= true;
         options.mapResults ??= true;
-        const isRunType = [enums_1.QueryType.INSERT, enums_1.QueryType.UPDATE, enums_1.QueryType.DELETE, enums_1.QueryType.TRUNCATE].includes(this.type ?? enums_1.QueryType.SELECT);
+        const isRunType = [enums_1.QueryType.INSERT, enums_1.QueryType.UPDATE, enums_1.QueryType.DELETE, enums_1.QueryType.TRUNCATE].includes(this.type);
         method ??= isRunType ? 'run' : 'all';
         if (!this.connectionType && isRunType) {
             this.connectionType = 'write';
@@ -650,15 +648,15 @@ class QueryBuilder {
         if (!this.finalized && method === 'get' && this.type === enums_1.QueryType.SELECT) {
             this.limit(1);
         }
-        const query = this.toQuery()._sql;
-        const cached = await this.em?.tryCache(this.mainAlias.entityName, this._cache, ['qb.execute', query.sql, query.bindings, method]);
+        const query = this.toQuery();
+        const cached = await this.em?.tryCache(this.mainAlias.entityName, this._cache, ['qb.execute', query.sql, query.params, method]);
         if (cached?.data) {
             return cached.data;
         }
         const write = method === 'run' || !this.platform.getConfig().get('preferReadReplicas');
         const type = this.connectionType || (write ? 'write' : 'read');
         const loggerContext = { id: this.em?.id, ...this.loggerContext };
-        const res = await this.driver.getConnection(type).execute(query.sql, query.bindings, method, this.context, loggerContext);
+        const res = await this.driver.getConnection(type).execute(query.sql, query.params, method, this.context, loggerContext);
         const meta = this.mainAlias.metadata;
         if (!options.mapResults || !meta) {
             await this.em?.storeCache(this._cache, cached, res);
@@ -742,7 +740,7 @@ class QueryBuilder {
             res = await this.execute('get', false);
         }
         else {
-            const qb = this.type === undefined ? this : this.clone();
+            const qb = this._type === undefined ? this : this.clone();
             qb.processPopulateHint(); // needs to happen sooner so `qb.hasToManyJoins()` reports correctly
             qb.count(field, distinct ?? qb.hasToManyJoins()).limit(undefined).offset(undefined).orderBy([]);
             res = await qb.execute('get', false);
@@ -762,7 +760,7 @@ class QueryBuilder {
      * Provides promise-like interface so we can await the QB instance.
      */
     then(onfulfilled, onrejected) {
-        let type = this.type ?? enums_1.QueryType.SELECT;
+        let type = this.type;
         if (this.flags.has(core_1.QueryFlag.UPDATE_SUB_QUERY) || this.flags.has(core_1.QueryFlag.DELETE_SUB_QUERY)) {
             type = enums_1.QueryType.UPDATE;
         }
@@ -779,21 +777,21 @@ class QueryBuilder {
         }
     }
     /**
-     * Returns knex instance with sub-query aliased with given alias.
+     * Returns native query builder instance with sub-query aliased with given alias.
      * You can provide `EntityName.propName` as alias, then the field name will be used based on the metadata
      */
     as(alias) {
-        const qb = this.getKnexQuery();
+        const qb = this.getNativeQuery();
         if (alias.includes('.')) {
             const [a, f] = alias.split('.');
             const meta = this.metadata.find(a);
             /* istanbul ignore next */
             alias = meta?.properties[f]?.fieldNames[0] ?? alias;
         }
-        const ret = qb.as(alias);
+        qb.as(alias);
         // tag the instance, so it is possible to detect it easily
-        Object.defineProperty(ret, '__as', { enumerable: false, value: alias });
-        return ret;
+        Object.defineProperty(qb, '__as', { enumerable: false, value: alias });
+        return qb;
     }
     clone(reset) {
         const qb = new QueryBuilder(this.mainAlias.entityName, this.metadata, this.driver, this.context, this.mainAlias.aliasName, this.connectionType, this.em);
@@ -809,7 +807,7 @@ class QueryBuilder {
         ];
         core_1.RawQueryFragment.cloneRegistry = this.rawFragments;
         for (const prop of Object.keys(this)) {
-            if (reset.includes(prop) || prop === '_helper') {
+            if (reset.includes(prop) || ['_helper', '_query'].includes(prop)) {
                 continue;
             }
             qb[prop] = properties.includes(prop) ? core_1.Utils.copy(this[prop]) : this[prop];
@@ -824,28 +822,6 @@ class QueryBuilder {
         qb.finalized = false;
         return qb;
     }
-    getKnex(processVirtualEntity = true) {
-        const qb = this.knex.queryBuilder();
-        const { subQuery, aliasName, entityName, metadata } = this.mainAlias;
-        const ref = subQuery ? subQuery : this.knex.ref(this.helper.getTableName(entityName));
-        if (this.finalized && (this._explicitAlias || this.helper.isTableNameAliasRequired(this.type))) {
-            ref.as(aliasName);
-        }
-        const schema = this.getSchema(this.mainAlias);
-        if (schema && schema !== this.platform.getDefaultSchemaName()) {
-            ref.withSchema(schema);
-        }
-        if (metadata?.virtual && processVirtualEntity) {
-            qb.fromRaw(this.fromVirtual(metadata));
-        }
-        else {
-            qb.from(ref);
-        }
-        if (this.context) {
-            qb.transacting(this.context);
-        }
-        return qb;
-    }
     /**
      * Sets logger context for this query builder.
      */
@@ -870,9 +846,8 @@ class QueryBuilder {
         if (res instanceof QueryBuilder) {
             return `(${res.getFormattedQuery()}) as ${this.platform.quoteIdentifier(this.alias)}`;
         }
-        if (core_1.Utils.isObject(res)) {
-            const { sql, bindings } = res.toSQL();
-            const query = this.platform.formatQuery(sql, bindings);
+        if (res instanceof core_1.RawQueryFragment) {
+            const query = this.platform.formatQuery(res.sql, res.params);
             return `(${query}) as ${this.platform.quoteIdentifier(this.alias)}`;
         }
         /* istanbul ignore next */
@@ -888,7 +863,10 @@ class QueryBuilder {
             if (field instanceof QueryBuilder) {
                 prop.type = field.mainAlias.entityName;
                 prop.targetMeta = field.mainAlias.metadata;
-                field = field.getKnexQuery();
+                field = field.getNativeQuery();
+            }
+            if (field instanceof core_1.RawQueryFragment) {
+                field = this.platform.formatQuery(field.sql, field.params);
             }
             this._joins[`${this.alias}.${prop.name}#${alias}`] = {
                 prop,
@@ -922,7 +900,7 @@ class QueryBuilder {
             metadata: this.metadata,
             platform: this.platform,
             aliasMap: this.getAliasMap(),
-            aliased: !this.type || [enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(this.type),
+            aliased: [enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(this.type),
         });
         let aliasedName = `${fromAlias}.${prop.name}#${alias}`;
         path ??= `${(Object.values(this._joins).find(j => j.alias === fromAlias)?.path ?? entityName)}.${prop.name}`;
@@ -954,16 +932,12 @@ class QueryBuilder {
     prepareFields(fields, type = 'where') {
         const ret = [];
         const getFieldName = (name) => {
-            if (type === 'groupBy') {
-                return this.helper.mapper(name, this.type, undefined, null);
-            }
-            return this.helper.mapper(name, this.type);
+            return this.helper.mapper(name, this.type, undefined, type === 'groupBy' ? null : undefined);
         };
         fields.forEach(field => {
-            const rawField = core_1.RawQueryFragment.getKnownFragment(field);
+            const rawField = core_1.RawQueryFragment.getKnownFragment(field, false);
             if (rawField) {
-                const sql = this.platform.formatQuery(rawField.sql, rawField.params);
-                ret.push(this.knex.raw(sql));
+                ret.push(rawField);
                 return;
             }
             if (!core_1.Utils.isString(field)) {
@@ -972,7 +946,7 @@ class QueryBuilder {
             }
             const join = Object.keys(this._joins).find(k => field === k.substring(0, k.indexOf('#')));
             if (join && type === 'where') {
-                ret.push(...this.helper.mapJoinColumns(this.type ?? enums_1.QueryType.SELECT, this._joins[join]));
+                ret.push(...this.helper.mapJoinColumns(this.type, this._joins[join]));
                 return;
             }
             const [a, f] = this.helper.splitField(field);
@@ -1020,7 +994,7 @@ class QueryBuilder {
         }
         for (const f of Object.keys(this._populateMap)) {
             if (type === 'where' && this._joins[f]) {
-                const cols = this.helper.mapJoinColumns(this.type ?? enums_1.QueryType.SELECT, this._joins[f]);
+                const cols = this.helper.mapJoinColumns(this.type, this._joins[f]);
                 for (const col of cols) {
                     ret.push(col);
                 }
@@ -1030,7 +1004,7 @@ class QueryBuilder {
     }
     init(type, data, cond) {
         this.ensureNotFinalized();
-        this.type = type;
+        this._type = type;
         if ([enums_1.QueryType.UPDATE, enums_1.QueryType.DELETE].includes(type) && core_1.Utils.hasObjectKeys(this._cond)) {
             throw new Error(`You are trying to call \`qb.where().${type.toLowerCase()}()\`. Calling \`qb.${type.toLowerCase()}()\` before \`qb.where()\` is required.`);
         }
@@ -1049,18 +1023,22 @@ class QueryBuilder {
         return this;
     }
     getQueryBase(processVirtualEntity) {
-        const qb = this.getKnex(processVirtualEntity);
+        const qb = this.platform.createNativeQueryBuilder().setFlags(this.flags);
+        const { subQuery, aliasName, entityName, metadata } = this.mainAlias;
+        const requiresAlias = this.finalized && (this._explicitAlias || this.helper.isTableNameAliasRequired(this.type));
+        const alias = requiresAlias ? aliasName : undefined;
         const schema = this.getSchema(this.mainAlias);
-        // Joined tables doesn't need to belong to the same schema as the main table
+        const tableName = subQuery ? subQuery.as(aliasName) : this.helper.getTableName(entityName);
         const joinSchema = this._schema ?? this.em?.schema ?? schema;
-        if (schema && schema !== this.platform.getDefaultSchemaName()) {
-            qb.withSchema(schema);
+        if (metadata?.virtual && processVirtualEntity) {
+            qb.from((0, core_1.raw)(this.fromVirtual(metadata)), { indexHint: this._indexHint });
         }
-        if (this._indexHint) {
-            const alias = this.helper.isTableNameAliasRequired(this.type) ? ` as ${this.platform.quoteIdentifier(this.mainAlias.aliasName)}` : '';
-            const schemaQuoted = schema ? this.platform.quoteIdentifier(schema) + '.' : '';
-            const tableName = schemaQuoted + this.platform.quoteIdentifier(this.helper.getTableName(this.mainAlias.entityName)) + alias;
-            qb.from(this.knex.raw(`${tableName} ${this._indexHint}`));
+        else {
+            qb.from(tableName, {
+                schema,
+                alias,
+                indexHint: this._indexHint,
+            });
         }
         switch (this.type) {
             case enums_1.QueryType.SELECT:
@@ -1074,8 +1052,8 @@ class QueryBuilder {
                 this.helper.processJoins(qb, this._joins, joinSchema);
                 break;
             case enums_1.QueryType.COUNT: {
-                const m = this.flags.has(core_1.QueryFlag.DISTINCT) ? 'countDistinct' : 'count';
-                qb[m]({ count: this._fields.map(f => this.helper.mapper(f, this.type)) });
+                const fields = this._fields.map(f => this.helper.mapper(f, this.type));
+                qb.count(fields, this.flags.has(core_1.QueryFlag.DISTINCT));
                 this.helper.processJoins(qb, this._joins, joinSchema);
                 break;
             }
@@ -1118,7 +1096,7 @@ class QueryBuilder {
         if (this.finalized) {
             return;
         }
-        if (!this.type) {
+        if (!this._type) {
             this.select('*');
         }
         const meta = this.mainAlias.metadata;
@@ -1128,8 +1106,8 @@ class QueryBuilder {
             meta.props
                 .filter(prop => prop.formula && (!prop.lazy || this.flags.has(core_1.QueryFlag.INCLUDE_LAZY_FORMULAS)))
                 .map(prop => {
-                const alias = this.knex.ref(this.mainAlias.aliasName).toString();
-                const aliased = this.knex.ref(prop.fieldNames[0]).toString();
+                const alias = this.platform.quoteIdentifier(this.mainAlias.aliasName);
+                const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]);
                 return `${prop.formula(alias)} as ${aliased}`;
             })
                 .filter(field => !this._fields.some(f => {
@@ -1280,14 +1258,15 @@ class QueryBuilder {
                     if (!prop?.persist && !prop?.formula && !prop?.hasConvertToJSValueSQL && !pks.includes(fieldName)) {
                         addToSelect.push(fieldName);
                     }
-                    const key = (0, core_1.raw)(`min(${this.knex.ref(fieldName)}${type})`);
+                    const quoted = this.platform.quoteIdentifier(fieldName);
+                    const key = (0, core_1.raw)(`min(${quoted}${type})`);
                     orderBy.push({ [key]: direction });
                 }
             }
             subQuery.orderBy(orderBy);
         }
         subQuery.finalized = true;
-        const knexQuery = subQuery.as(this.mainAlias.aliasName).clearSelect().select(pks);
+        const innerQuery = subQuery.as(this.mainAlias.aliasName).clear('select').select(pks);
         if (addToSelect.length > 0) {
             addToSelect.forEach(prop => {
                 const field = this._fields.find(field => {
@@ -1302,24 +1281,29 @@ class QueryBuilder {
                 });
                 /* istanbul ignore next */
                 if (field instanceof core_1.RawQueryFragment) {
-                    const sql = this.platform.formatQuery(field.sql, field.params);
-                    knexQuery.select(this.knex.raw(sql));
+                    innerQuery.select(field);
+                }
+                else if (field instanceof NativeQueryBuilder_1.NativeQueryBuilder) {
+                    innerQuery.select(field.toRaw());
                 }
                 else if (field) {
-                    knexQuery.select(field);
+                    innerQuery.select(field);
                 }
             });
         }
         // multiple sub-queries are needed to get around mysql limitations with order by + limit + where in + group by (o.O)
         // https://stackoverflow.com/questions/17892762/mysql-this-version-of-mysql-doesnt-yet-support-limit-in-all-any-some-subqu
-        const subSubQuery = this.getKnex().select(pks).from(knexQuery);
-        subSubQuery.__raw = true; // tag it as there is now way to check via `instanceof`
+        const subSubQuery = this.platform.createNativeQueryBuilder();
+        subSubQuery.select(pks).from(innerQuery);
         this._limit = undefined;
         this._offset = undefined;
-        if (this._fields.some(f => core_1.RawQueryFragment.isKnownFragment(f))) {
-            this.select(this._fields).where({ [core_1.Utils.getPrimaryKeyHash(meta.primaryKeys)]: { $in: subSubQuery } });
-            return;
+        if (!this._fields.some(f => core_1.RawQueryFragment.isKnownFragment(f))) {
+            this.pruneExtraJoins(meta);
         }
+        const { sql, params } = subSubQuery.compile();
+        this.select(this._fields).where({ [core_1.Utils.getPrimaryKeyHash(meta.primaryKeys)]: { $in: (0, core_1.raw)(sql, params) } });
+    }
+    pruneExtraJoins(meta) {
         // remove joins that are not used for population or ordering to improve performance
         const populate = new Set();
         const orderByAliases = this._orderBy
@@ -1353,26 +1337,31 @@ class QueryBuilder {
                 delete this._joins[key];
             }
         }
-        this.select(this._fields).where({ [core_1.Utils.getPrimaryKeyHash(meta.primaryKeys)]: { $in: subSubQuery } });
     }
     wrapModifySubQuery(meta) {
         const subQuery = this.clone();
         subQuery.finalized = true;
         // wrap one more time to get around MySQL limitations
         // https://stackoverflow.com/questions/45494/mysql-error-1093-cant-specify-target-table-for-update-in-from-clause
-        const subSubQuery = this.getKnex().select(this.prepareFields(meta.primaryKeys)).from(subQuery.as(this.mainAlias.aliasName));
-        subSubQuery.__raw = true; // tag it as there is now way to check via `instanceof`
+        const subSubQuery = this.platform.createNativeQueryBuilder();
         const method = this.flags.has(core_1.QueryFlag.UPDATE_SUB_QUERY) ? 'update' : 'delete';
+        const pks = this.prepareFields(meta.primaryKeys, 'sub-query');
         this._cond = {}; // otherwise we would trigger validation error
         this._joins = {}; // included in the subquery
+        subSubQuery.select(pks).from(subQuery.as(this.mainAlias.aliasName));
+        const { sql, params } = subSubQuery.compile();
         this[method](this._data).where({
-            [core_1.Utils.getPrimaryKeyHash(meta.primaryKeys)]: { $in: subSubQuery },
+            [core_1.Utils.getPrimaryKeyHash(meta.primaryKeys)]: { $in: (0, core_1.raw)(sql, params) },
         });
     }
     getSchema(alias) {
         const { metadata } = alias;
         const metaSchema = metadata?.schema && metadata.schema !== '*' ? metadata.schema : undefined;
-        return this._schema ?? metaSchema ?? this.em?.schema ?? this.em?.config.getSchema(true);
+        const schema = this._schema ?? metaSchema ?? this.em?.schema ?? this.em?.config.getSchema(true);
+        if (schema === this.platform.getDefaultSchemaName()) {
+            return undefined;
+        }
+        return schema;
     }
     createAlias(entityName, aliasName, subQuery) {
         const metadata = this.metadata.find(entityName);
@@ -1386,7 +1375,7 @@ class QueryBuilder {
         return this._mainAlias;
     }
     fromSubQuery(target, aliasName) {
-        const subQuery = target.getKnexQuery();
+        const subQuery = target.getNativeQuery();
         const { entityName } = target.mainAlias;
         aliasName ??= this.getNextAlias(entityName);
         this.createMainAlias(entityName, aliasName, subQuery);
@@ -1396,7 +1385,7 @@ class QueryBuilder {
         this.createMainAlias(entityName, aliasName);
     }
     createQueryBuilderHelper() {
-        return new QueryBuilderHelper_1.QueryBuilderHelper(this.mainAlias.entityName, this.mainAlias.aliasName, this._aliases, this.subQueries, this.knex, this.driver);
+        return new QueryBuilderHelper_1.QueryBuilderHelper(this.mainAlias.entityName, this.mainAlias.aliasName, this._aliases, this.subQueries, this.driver);
     }
     ensureFromClause() {
         /* istanbul ignore next */
@@ -1413,7 +1402,7 @@ class QueryBuilder {
     /** @ignore */
     [node_util_1.inspect.custom](depth = 2) {
         const object = { ...this };
-        const hidden = ['metadata', 'driver', 'context', 'platform', 'knex', 'type'];
+        const hidden = ['metadata', 'driver', 'context', 'platform', 'type'];
         Object.keys(object).filter(k => k.startsWith('_')).forEach(k => delete object[k]);
         Object.keys(object).filter(k => object[k] == null).forEach(k => delete object[k]);
         hidden.forEach(k => delete object[k]);