@mikro-orm/knex 6.0.0-dev.4 → 6.0.0-dev.41

package/{dist/AbstractSqlDriver.js → AbstractSqlDriver.js}

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractSqlDriver = void 0;
 const core_1 = require("@mikro-orm/core");
-const QueryBuilder_1 = require("./query/QueryBuilder");
+const query_1 = require("./query");
 const SqlEntityManager_1 = require("./SqlEntityManager");
 class AbstractSqlDriver extends core_1.DatabaseDriver {
     constructor(config, platform, connection, connector) {
@@ -21,21 +21,33 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
     async find(entityName, where, options = {}) {
         options = { populate: [], orderBy: [], ...options };
         const meta = this.metadata.find(entityName);
+        if (meta?.virtual) {
+            return this.findVirtual(entityName, where, options);
+        }
         const populate = this.autoJoinOneToOneOwner(meta, options.populate, options.fields);
         const joinedProps = this.joinedProps(meta, populate);
-        const qb = this.createQueryBuilder(entityName, options.ctx, !!options.ctx, false);
+        const qb = this.createQueryBuilder(entityName, options.ctx, options.connectionType, false);
         const fields = this.buildFields(meta, populate, joinedProps, qb, options.fields);
         const joinedPropsOrderBy = this.buildJoinedPropsOrderBy(entityName, qb, meta, joinedProps);
+        const orderBy = [...core_1.Utils.asArray(options.orderBy), ...joinedPropsOrderBy];
         if (core_1.Utils.isPrimaryKey(where, meta.compositePK)) {
             where = { [core_1.Utils.getPrimaryKeyHash(meta.primaryKeys)]: where };
         }
+        const { first, last, before, after } = options;
+        const isCursorPagination = [first, last, before, after].some(v => v != null);
         qb.select(fields)
-            .populate(populate)
+            .populate(populate, joinedProps.length > 0 ? options.populateWhere : undefined)
             .where(where)
-            .orderBy([...core_1.Utils.asArray(options.orderBy), ...joinedPropsOrderBy])
             .groupBy(options.groupBy)
             .having(options.having)
             .withSchema(this.getSchemaName(meta, options));
+        if (isCursorPagination) {
+            const { orderBy: newOrderBy, where } = this.processCursorOptions(meta, options, orderBy);
+            qb.andWhere(where).orderBy(newOrderBy);
+        }
+        else {
+            qb.orderBy(orderBy);
+        }
         if (options.limit !== undefined) {
             qb.limit(options.limit, options.offset);
         }
@@ -44,6 +56,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         core_1.Utils.asArray(options.flags).forEach(flag => qb.setFlag(flag));
         const result = await this.rethrow(qb.execute('all'));
+        if (isCursorPagination && !first && !!last) {
+            result.reverse();
+        }
         if (joinedProps.length > 0) {
             return this.mergeJoinedResult(result, meta);
         }
@@ -57,9 +72,70 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (joinedProps.length === 0) {
             opts.limit = 1;
         }
+        if (opts.limit > 0 && !opts.flags?.includes(core_1.QueryFlag.DISABLE_PAGINATE)) {
+            opts.flags ??= [];
+            opts.flags.push(core_1.QueryFlag.DISABLE_PAGINATE);
+        }
         const res = await this.find(entityName, where, opts);
         return res[0] || null;
     }
+    async findVirtual(entityName, where, options) {
+        const meta = this.metadata.get(entityName);
+        /* istanbul ignore next */
+        if (!meta.expression) {
+            return [];
+        }
+        if (typeof meta.expression === 'string') {
+            return this.wrapVirtualExpressionInSubquery(meta, meta.expression, where, options);
+        }
+        const em = this.createEntityManager(false);
+        em.setTransactionContext(options.ctx);
+        const res = meta.expression(em, where, options);
+        if (res instanceof (query_1.QueryBuilder)) {
+            return this.wrapVirtualExpressionInSubquery(meta, res.getFormattedQuery(), where, options);
+        }
+        /* istanbul ignore next */
+        return res;
+    }
+    async countVirtual(entityName, where, options) {
+        const meta = this.metadata.get(entityName);
+        /* istanbul ignore next */
+        if (!meta.expression) {
+            return 0;
+        }
+        if (typeof meta.expression === 'string') {
+            return this.wrapVirtualExpressionInSubquery(meta, meta.expression, where, options, query_1.QueryType.COUNT);
+        }
+        const em = this.createEntityManager(false);
+        em.setTransactionContext(options.ctx);
+        const res = meta.expression(em, where, options);
+        if (res instanceof (query_1.QueryBuilder)) {
+            return this.wrapVirtualExpressionInSubquery(meta, res.getFormattedQuery(), where, options, query_1.QueryType.COUNT);
+        }
+        /* istanbul ignore next */
+        return res;
+    }
+    async wrapVirtualExpressionInSubquery(meta, expression, where, options, type = query_1.QueryType.SELECT) {
+        const qb = this.createQueryBuilder(meta.className, options?.ctx, options.connectionType, options.convertCustomTypes)
+            .limit(options?.limit, options?.offset);
+        if (options.orderBy) {
+            qb.orderBy(options.orderBy);
+        }
+        qb.where(where);
+        const kqb = qb.getKnexQuery().clear('select');
+        if (type === query_1.QueryType.COUNT) {
+            kqb.select(qb.raw('count(*) as count'));
+        }
+        else { // select
+            kqb.select('*');
+        }
+        kqb.fromRaw(`(${expression}) as ${this.platform.quoteIdentifier(qb.alias)}`);
+        const res = await this.execute(kqb);
+        if (type === query_1.QueryType.COUNT) {
+            return res[0].count;
+        }
+        return res.map(row => this.mapResult(row, meta));
+    }
     mapResult(result, meta, populate = [], qb, map = {}) {
         const ret = super.mapResult(result, meta);
         /* istanbul ignore if */
@@ -90,8 +166,8 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             }));
             if (!hasPK) {
                 // initialize empty collections
-                if ([core_1.ReferenceType.MANY_TO_MANY, core_1.ReferenceType.ONE_TO_MANY].includes(relation.reference)) {
-                    result[relation.name] = result[relation.name] || [];
+                if ([core_1.ReferenceKind.MANY_TO_MANY, core_1.ReferenceKind.ONE_TO_MANY].includes(relation.kind)) {
+                    result[relation.name] ??= [];
                 }
                 return;
             }
@@ -115,8 +191,8 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             else {
                 map[key] = result;
             }
-            if ([core_1.ReferenceType.MANY_TO_MANY, core_1.ReferenceType.ONE_TO_MANY].includes(relation.reference)) {
-                result[relation.name] = result[relation.name] || [];
+            if ([core_1.ReferenceKind.MANY_TO_MANY, core_1.ReferenceKind.ONE_TO_MANY].includes(relation.kind)) {
+                result[relation.name] ??= [];
                 this.appendToCollection(meta2, result[relation.name], relationPojo);
             }
             else {
@@ -137,23 +213,25 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             collection.push(relationPojo);
         }
     }
-    async count(entityName, where, options = {}, ctx) {
+    async count(entityName, where, options = {}) {
         const meta = this.metadata.find(entityName);
-        const pks = meta.primaryKeys;
-        const qb = this.createQueryBuilder(entityName, ctx, !!ctx, false)
+        if (meta?.virtual) {
+            return this.countVirtual(entityName, where, options);
+        }
+        const qb = this.createQueryBuilder(entityName, options.ctx, options.connectionType, false)
             .groupBy(options.groupBy)
             .having(options.having)
             .populate(options.populate ?? [])
             .withSchema(this.getSchemaName(meta, options))
             .where(where);
-        return this.rethrow(qb.getCount(pks, true));
+        return this.rethrow(qb.getCount());
     }
     async nativeInsert(entityName, data, options = {}) {
-        options.convertCustomTypes ?? (options.convertCustomTypes = true);
+        options.convertCustomTypes ??= true;
         const meta = this.metadata.find(entityName);
         const collections = this.extractManyToMany(entityName, data);
-        const pks = this.getPrimaryKeyFields(entityName);
-        const qb = this.createQueryBuilder(entityName, options.ctx, true, options.convertCustomTypes).withSchema(this.getSchemaName(meta, options));
+        const pks = meta?.primaryKeys ?? [this.config.getNamingStrategy().referenceColumnName()];
+        const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes).withSchema(this.getSchemaName(meta, options));
         const res = await this.rethrow(qb.insert(data).execute('run', false));
         res.row = res.row || {};
         let pk;
@@ -161,68 +239,77 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             pk = core_1.Utils.getPrimaryKeyCond(data, pks);
         }
         else {
-            res.insertId = data[pks[0]] || res.insertId || res.row[pks[0]];
+            /* istanbul ignore next */
+            res.insertId = data[pks[0]] ?? res.insertId ?? res.row[pks[0]];
             pk = [res.insertId];
         }
         await this.processManyToMany(meta, pk, collections, false, options);
         return res;
     }
     async nativeInsertMany(entityName, data, options = {}) {
-        options.processCollections ?? (options.processCollections = true);
-        options.convertCustomTypes ?? (options.convertCustomTypes = true);
-        const meta = this.metadata.get(entityName);
+        options.processCollections ??= true;
+        options.convertCustomTypes ??= true;
+        const meta = this.metadata.find(entityName);
         const collections = options.processCollections ? data.map(d => this.extractManyToMany(entityName, d)) : [];
         const pks = this.getPrimaryKeyFields(entityName);
         const set = new Set();
-        data.forEach(row => Object.keys(row).forEach(k => set.add(k)));
-        const props = [...set].map(name => meta.properties[name] ?? { name, fieldNames: [name] });
+        data.forEach(row => core_1.Utils.keys(row).forEach(k => set.add(k)));
+        const props = [...set].map(name => meta?.properties[name] ?? { name, fieldNames: [name] });
         const fields = core_1.Utils.flatten(props.map(prop => prop.fieldNames));
-        let res;
-        if (fields.length === 0) {
-            const qb = this.createQueryBuilder(entityName, options.ctx, true, options.convertCustomTypes).withSchema(this.getSchemaName(meta, options));
-            res = await this.rethrow(qb.insert(data).execute('run', false));
+        const params = [];
+        /* istanbul ignore next */
+        const tableName = meta ? this.getTableName(meta, options) : this.platform.quoteIdentifier(entityName);
+        let sql = `insert into ${tableName} `;
+        sql += fields.length > 0 ? '(' + fields.map(k => this.platform.quoteIdentifier(k)).join(', ') + ')' : `(${this.platform.quoteIdentifier(pks[0])})`;
+        if (fields.length > 0 || this.platform.usesDefaultKeyword()) {
+            sql += ' values ';
         }
         else {
-            let sql = `insert into ${this.getTableName(meta, options)} `;
-            /* istanbul ignore next */
-            sql += fields.length > 0 ? '(' + fields.map(k => this.platform.quoteIdentifier(k)).join(', ') + ')' : 'default';
-            sql += ` values `;
-            const params = [];
+            sql += ' ' + data.map(() => `select null as ${this.platform.quoteIdentifier(pks[0])}`).join(' union all ');
+        }
+        const addParams = (prop, row) => {
+            if (options.convertCustomTypes && prop.customType) {
+                params.push(prop.customType.convertToDatabaseValue(row[prop.name], this.platform, { key: prop.name, mode: 'query' }));
+                return;
+            }
+            params.push(row[prop.name]);
+        };
+        if (fields.length > 0 || this.platform.usesDefaultKeyword()) {
             sql += data.map(row => {
                 const keys = [];
                 props.forEach(prop => {
                     if (prop.fieldNames.length > 1) {
-                        params.push(...row[prop.name]);
-                        keys.push(...prop.fieldNames.map(_ => '?'));
+                        params.push(...(row[prop.name] ?? prop.fieldNames.map(() => null)));
+                        keys.push(...(row[prop.name] ?? prop.fieldNames).map(() => '?'));
                     }
                     else if (prop.customType && 'convertToDatabaseValueSQL' in prop.customType && !this.platform.isRaw(row[prop.name])) {
                         keys.push(prop.customType.convertToDatabaseValueSQL('?', this.platform));
-                        params.push(row[prop.name]);
+                        addParams(prop, row);
                     }
                     else {
-                        params.push(row[prop.name]);
+                        addParams(prop, row);
                         keys.push('?');
                     }
                 });
-                return '(' + keys.join(', ') + ')';
+                return '(' + (keys.join(', ') || 'default') + ')';
             }).join(', ');
-            if (this.platform.usesReturningStatement()) {
-                /* istanbul ignore next */
-                const returningProps = meta.props.filter(prop => prop.primary || prop.defaultRaw);
-                const returningFields = core_1.Utils.flatten(returningProps.map(prop => prop.fieldNames));
-                /* istanbul ignore next */
-                sql += returningFields.length > 0 ? ` returning ${returningFields.map(field => this.platform.quoteIdentifier(field)).join(', ')}` : '';
-            }
-            res = await this.execute(sql, params, 'run', options.ctx);
         }
+        if (this.platform.usesReturningStatement()) {
+            /* istanbul ignore next */
+            const returningProps = meta.hydrateProps.filter(prop => prop.persist !== false && (prop.primary || prop.defaultRaw));
+            const returningFields = core_1.Utils.flatten(returningProps.map(prop => prop.fieldNames));
+            /* istanbul ignore next */
+            sql += returningFields.length > 0 ? ` returning ${returningFields.map(field => this.platform.quoteIdentifier(field)).join(', ')}` : '';
+        }
+        const res = await this.execute(sql, params, 'run', options.ctx);
         let pk;
         /* istanbul ignore next */
         if (pks.length > 1) { // owner has composite pk
             pk = data.map(d => core_1.Utils.getPrimaryKeyCond(d, pks));
         }
         else {
-            res.row ?? (res.row = {});
-            res.rows ?? (res.rows = []);
+            res.row ??= {};
+            res.rows ??= [];
             pk = data.map((d, i) => d[pks[0]] ?? res.rows[i]?.[pks[0]]).map(d => [d]);
             res.insertId = res.insertId || res.row[pks[0]];
         }
@@ -232,19 +319,29 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         return res;
     }
     async nativeUpdate(entityName, where, data, options = {}) {
-        options.convertCustomTypes ?? (options.convertCustomTypes = true);
+        options.convertCustomTypes ??= true;
         const meta = this.metadata.find(entityName);
         const pks = this.getPrimaryKeyFields(entityName);
         const collections = this.extractManyToMany(entityName, data);
         let res = { affectedRows: 0, insertId: 0, row: {} };
         if (core_1.Utils.isPrimaryKey(where) && pks.length === 1) {
-            where = { [pks[0]]: where };
+            /* istanbul ignore next */
+            where = { [meta?.primaryKeys[0] ?? pks[0]]: where };
         }
         if (core_1.Utils.hasObjectKeys(data)) {
-            const qb = this.createQueryBuilder(entityName, options.ctx, true, options.convertCustomTypes)
-                .update(data)
-                .withSchema(this.getSchemaName(meta, options))
-                .where(where);
+            const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes)
+                .withSchema(this.getSchemaName(meta, options));
+            if (options.upsert) {
+                /* istanbul ignore next */
+                const uniqueFields = core_1.Utils.isPlainObject(where) ? core_1.Utils.keys(where) : meta.primaryKeys;
+                /* istanbul ignore next */
+                qb.insert(data)
+                    .onConflict(uniqueFields.map(p => meta?.properties[p]?.fieldNames[0] ?? p))
+                    .merge(core_1.Utils.keys(data).filter(f => !uniqueFields.includes(f)));
+            }
+            else {
+                qb.update(data).where(where);
+            }
             res = await this.rethrow(qb.execute('run', false));
         }
         /* istanbul ignore next */
@@ -253,12 +350,20 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         return res;
     }
     async nativeUpdateMany(entityName, where, data, options = {}) {
-        options.processCollections ?? (options.processCollections = true);
-        options.convertCustomTypes ?? (options.convertCustomTypes = true);
+        options.processCollections ??= true;
+        options.convertCustomTypes ??= true;
         const meta = this.metadata.get(entityName);
+        if (options.upsert) {
+            const uniqueFields = core_1.Utils.isPlainObject(where[0]) ? Object.keys(where[0]) : meta.primaryKeys;
+            const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes).withSchema(this.getSchemaName(meta, options));
+            qb.insert(data)
+                .onConflict(uniqueFields.map(p => meta?.properties[p]?.fieldNames[0] ?? p))
+                .merge(Object.keys(data[0]).filter(f => !uniqueFields.includes(f)));
+            return qb.execute('run', false);
+        }
         const collections = options.processCollections ? data.map(d => this.extractManyToMany(entityName, d)) : [];
         const keys = new Set();
-        data.forEach(row => Object.keys(row).forEach(k => keys.add(k)));
+        data.forEach(row => core_1.Utils.keys(row).forEach(k => keys.add(k)));
         const pkCond = core_1.Utils.flatten(meta.primaryKeys.map(pk => meta.properties[pk].fieldNames)).map(pk => `${this.platform.quoteIdentifier(pk)} = ?`).join(' and ');
         const params = [];
         let sql = `update ${this.getTableName(meta, options)} set `;
@@ -276,7 +381,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                         else {
                             sql += '?';
                         }
-                        params.push(...pks, prop.fieldNames.length > 1 ? data[idx][key][fieldNameIdx] : data[idx][key]);
+                        params.push(...pks, prop.fieldNames.length > 1 ? data[idx][key]?.[fieldNameIdx] : data[idx][key]);
                     }
                 });
                 sql += ` else ${this.platform.quoteIdentifier(fieldName)} end, `;
@@ -300,15 +405,24 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const pks = core_1.Utils.flatten(pkProps.map(pk => meta.properties[pk].fieldNames));
         sql += pks.length > 1 ? `(${pks.map(pk => `${this.platform.quoteIdentifier(pk)}`).join(', ')})` : this.platform.quoteIdentifier(pks[0]);
         const conds = where.map(cond => {
+            if (core_1.Utils.isPlainObject(cond) && core_1.Utils.getObjectKeysSize(cond) === 1) {
+                cond = Object.values(cond)[0];
+            }
             if (pks.length > 1) {
-                pkProps.forEach(pk => params.push(cond[pk]));
+                pkProps.forEach(pk => {
+                    if (Array.isArray(cond[pk])) {
+                        params.push(...core_1.Utils.flatten(cond[pk]));
+                    }
+                    else {
+                        params.push(cond[pk]);
+                    }
+                });
                 return `(${new Array(pks.length).fill('?').join(', ')})`;
             }
             params.push(cond);
             return '?';
         });
-        const values = pks.length > 1 && this.platform.requiresValuesKeyword() ? 'values ' : '';
-        sql += ` in (${values}${conds.join(', ')})`;
+        sql += ` in (${conds.join(', ')})`;
         const res = await this.rethrow(this.execute(sql, params, 'run', options.ctx));
         for (let i = 0; i < collections.length; i++) {
             await this.processManyToMany(meta, where[i], collections[i], false, options);
@@ -321,17 +435,17 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (core_1.Utils.isPrimaryKey(where) && pks.length === 1) {
             where = { [pks[0]]: where };
         }
-        const qb = this.createQueryBuilder(entityName, options.ctx, true, false).delete(where).withSchema(this.getSchemaName(meta, options));
+        const qb = this.createQueryBuilder(entityName, options.ctx, 'write', false).delete(where).withSchema(this.getSchemaName(meta, options));
         return this.rethrow(qb.execute('run', false));
     }
     async syncCollection(coll, options) {
-        const wrapped = coll.owner.__helper;
+        const wrapped = (0, core_1.helper)(coll.owner);
         const meta = wrapped.__meta;
         const pks = wrapped.getPrimaryKeys(true);
         const snap = coll.getSnapshot();
         const includes = (arr, item) => !!arr.find(i => core_1.Utils.equals(i, item));
-        const snapshot = snap ? snap.map(item => item.__helper.getPrimaryKeys(true)) : [];
-        const current = coll.getItems(false).map(item => item.__helper.getPrimaryKeys(true));
+        const snapshot = snap ? snap.map(item => (0, core_1.helper)(item).getPrimaryKeys(true)) : [];
+        const current = coll.getItems(false).map(item => (0, core_1.helper)(item).getPrimaryKeys(true));
         const deleteDiff = snap ? snapshot.filter(item => !includes(current, item)) : true;
         const insertDiff = current.filter(item => !includes(snapshot, item));
         const target = snapshot.filter(item => includes(current, item)).concat(...insertDiff);
@@ -343,9 +457,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             deleteDiff.push(...snapshot);
             insertDiff.push(...current);
         }
-        if (coll.property.reference === core_1.ReferenceType.ONE_TO_MANY) {
+        if (coll.property.kind === core_1.ReferenceKind.ONE_TO_MANY) {
             const cols = coll.property.referencedColumnNames;
-            const qb = this.createQueryBuilder(coll.property.type, ctx, true)
+            const qb = this.createQueryBuilder(coll.property.type, ctx, 'write')
                 .withSchema(this.getSchemaName(meta, options))
                 .update({ [coll.property.mappedBy]: pks })
                 .getKnexQuery()
@@ -354,10 +468,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         /* istanbul ignore next */
         const ownerSchema = wrapped.getSchema() === '*' ? this.config.get('schema') : wrapped.getSchema();
-        const pivotMeta = this.metadata.find(coll.property.pivotTable);
+        const pivotMeta = this.metadata.find(coll.property.pivotEntity);
         if (pivotMeta.schema === '*') {
             /* istanbul ignore next */
-            options ?? (options = {});
+            options ??= {};
             options.schema = ownerSchema;
         }
         return this.rethrow(this.updateCollectionDiff(meta, coll.property, pks, deleteDiff, insertDiff, options));
@@ -365,7 +479,8 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
     async loadFromPivotTable(prop, owners, where = {}, orderBy, ctx, options) {
         const pivotProp2 = this.getPivotInverseProperty(prop);
         const ownerMeta = this.metadata.find(pivotProp2.type);
-        const cond = { [`${prop.pivotTable}.${pivotProp2.name}`]: { $in: ownerMeta.compositePK ? owners : owners.map(o => o[0]) } };
+        const pivotMeta = this.metadata.find(prop.pivotEntity);
+        const cond = { [`${prop.pivotEntity}.${pivotProp2.name}`]: { $in: ownerMeta.compositePK ? owners : owners.map(o => o[0]) } };
         /* istanbul ignore if */
         if (!core_1.Utils.isEmpty(where) && Object.keys(where).every(k => core_1.Utils.isOperator(k, false))) {
             where = cond;
@@ -374,15 +489,23 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             where = { ...where, ...cond };
         }
         orderBy = this.getPivotOrderBy(prop, orderBy);
-        const qb = this.createQueryBuilder(prop.type, ctx, !!ctx)
+        const qb = this.createQueryBuilder(prop.type, ctx, options?.connectionType)
             .unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES)
             .withSchema(this.getSchemaName(prop.targetMeta, options));
-        const populate = this.autoJoinOneToOneOwner(prop.targetMeta, [{ field: prop.pivotTable }]);
+        const populate = this.autoJoinOneToOneOwner(prop.targetMeta, [{ field: prop.pivotEntity }]);
         const fields = this.buildFields(prop.targetMeta, (options?.populate ?? []), [], qb, options?.fields);
         qb.select(fields).populate(populate).where(where).orderBy(orderBy).setLockMode(options?.lockMode, options?.lockTableAliases);
         if (owners.length === 1 && (options?.offset != null || options?.limit != null)) {
             qb.limit(options.limit, options.offset);
         }
+        if (prop.targetMeta.schema !== '*' && pivotMeta.schema === '*' && options?.schema) {
+            // eslint-disable-next-line dot-notation
+            qb['finalize']();
+            // eslint-disable-next-line dot-notation
+            Object.values(qb['_joins']).forEach(join => {
+                join.schema = options.schema;
+            });
+        }
         const items = owners.length ? await this.rethrow(qb.execute('all')) : [];
         const map = {};
         const pkProps = ownerMeta.getPrimaryProps();
@@ -407,33 +530,24 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
     async execute(queryOrKnex, params = [], method = 'all', ctx) {
         return this.rethrow(this.connection.execute(queryOrKnex, params, method, ctx));
     }
-    getTableName(meta, options) {
-        let tableName = this.platform.quoteIdentifier(meta.collection);
-        if (options.schema === '*') {
-            return this.platform.quoteIdentifier(this.config.get('schema')) + '.' + tableName;
-        }
-        if (meta.schema || options.schema) {
-            tableName = this.platform.quoteIdentifier(options.schema ?? meta.schema) + '.' + tableName;
-        }
-        return tableName;
-    }
     /**
      * 1:1 owner side needs to be marked for population so QB auto-joins the owner id
      */
     autoJoinOneToOneOwner(meta, populate, fields = []) {
-        if (!this.config.get('autoJoinOneToOneOwner') || fields.length > 0) {
+        if (!this.config.get('autoJoinOneToOneOwner')) {
             return populate;
         }
         const relationsToPopulate = populate.map(({ field }) => field);
         const toPopulate = meta.relations
-            .filter(prop => prop.reference === core_1.ReferenceType.ONE_TO_ONE && !prop.owner && !relationsToPopulate.includes(prop.name))
+            .filter(prop => prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner && !relationsToPopulate.includes(prop.name))
+            .filter(prop => fields.length === 0 || fields.some(f => prop.name === f || prop.name.startsWith(`${String(f)}.`)))
             .map(prop => ({ field: prop.name, strategy: prop.strategy }));
         return [...populate, ...toPopulate];
     }
     joinedProps(meta, populate) {
         return populate.filter(p => {
             const prop = meta.properties[p.field] || {};
-            return (p.strategy || prop.strategy || this.config.get('loadStrategy')) === core_1.LoadStrategy.JOINED && prop.reference !== core_1.ReferenceType.SCALAR;
+            return (p.strategy || prop.strategy || this.config.get('loadStrategy')) === core_1.LoadStrategy.JOINED && prop.kind !== core_1.ReferenceKind.SCALAR;
         });
     }
     /**
@@ -458,12 +572,15 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
     getFieldsForJoinedLoad(qb, meta, explicitFields, populate = [], parentTableAlias, parentJoinPath) {
         const fields = [];
         const joinedProps = this.joinedProps(meta, populate);
+        if (explicitFields?.includes('*')) {
+            fields.push('*');
+        }
         const shouldHaveColumn = (prop, populate, fields) => {
             if (!this.platform.shouldHaveColumn(prop, populate)) {
                 return false;
             }
             if (!fields || prop.primary) {
-                return true;
+                return !fields?.includes('*');
             }
             return fields.includes(prop.name);
         };
@@ -506,20 +623,34 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         return prop.fieldNames;
     }
-    createQueryBuilder(entityName, ctx, write, convertCustomTypes) {
-        const qb = new QueryBuilder_1.QueryBuilder(entityName, this.metadata, this, ctx, undefined, write ? 'write' : 'read');
+    /** @internal */
+    createQueryBuilder(entityName, ctx, preferredConnectionType, convertCustomTypes) {
+        const connectionType = this.resolveConnectionType({ ctx, connectionType: preferredConnectionType });
+        const qb = new query_1.QueryBuilder(entityName, this.metadata, this, ctx, undefined, connectionType);
         if (!convertCustomTypes) {
             qb.unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES);
         }
         return qb;
     }
+    resolveConnectionType(args) {
+        if (args.ctx) {
+            return 'write';
+        }
+        else if (args.connectionType) {
+            return args.connectionType;
+        }
+        else if (this.config.get('preferReadReplicas') === true) {
+            return 'read';
+        }
+        return 'write';
+    }
     extractManyToMany(entityName, data) {
         if (!this.metadata.has(entityName)) {
             return {};
         }
         const ret = {};
         this.metadata.find(entityName).relations.forEach(prop => {
-            if (prop.reference === core_1.ReferenceType.MANY_TO_MANY && data[prop.name]) {
+            if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY && data[prop.name]) {
                 ret[prop.name] = data[prop.name].map((item) => core_1.Utils.asArray(item));
                 delete data[prop.name];
             }
@@ -541,7 +672,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             deleteDiff = [];
         }
         if (deleteDiff === true || deleteDiff.length > 0) {
-            const qb1 = this.createQueryBuilder(prop.pivotTable, options?.ctx, true)
+            const qb1 = this.createQueryBuilder(prop.pivotEntity, options?.ctx, 'write')
                 .withSchema(this.getSchemaName(meta, options))
                 .unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES);
             const knex = qb1.getKnex();
@@ -562,11 +693,15 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         });
         /* istanbul ignore else */
         if (this.platform.allowsMultiInsert()) {
-            await this.nativeInsertMany(prop.pivotTable, items, { ...options, convertCustomTypes: false, processCollections: false });
+            await this.nativeInsertMany(prop.pivotEntity, items, {
+                ...options,
+                convertCustomTypes: false,
+                processCollections: false,
+            });
         }
         else {
             await core_1.Utils.runSerial(items, item => {
-                return this.createQueryBuilder(prop.pivotTable, options?.ctx, true)
+                return this.createQueryBuilder(prop.pivotEntity, options?.ctx, 'write')
                     .unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES)
                     .withSchema(this.getSchemaName(meta, options))
                     .insert(item)
@@ -575,7 +710,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
     }
     async lockPessimistic(entity, options) {
-        const meta = entity.__helper.__meta;
+        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);
@@ -590,7 +725,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             const path = `${parentPath ? parentPath : entityName}.${relation.field}`;
             const propAlias = qb.getAliasForJoinPath(path);
             if (propOrderBy) {
-                Object.keys(propOrderBy).forEach(field => {
+                core_1.Utils.keys(propOrderBy).forEach(field => {
                     orderBy.push({ [`${propAlias}.${field}`]: propOrderBy[field] });
                 });
             }
@@ -601,6 +736,43 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         });
         return orderBy;
     }
+    normalizeFields(fields, prefix = '') {
+        const ret = [];
+        for (const field of fields) {
+            if (typeof field === 'string') {
+                ret.push(prefix + field);
+                continue;
+            }
+            if (core_1.Utils.isPlainObject(field)) {
+                for (const key of Object.keys(field)) {
+                    ret.push(...this.normalizeFields(field[key], key + '.'));
+                }
+            }
+        }
+        return ret;
+    }
+    processField(meta, prop, field, ret, populate, joinedProps, qb) {
+        if (!prop || (prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner)) {
+            return;
+        }
+        if (prop.kind === core_1.ReferenceKind.EMBEDDED) {
+            if (prop.object) {
+                ret.push(prop.fieldNames[0]);
+                return;
+            }
+            const parts = field.split('.');
+            const top = parts.shift();
+            for (const key of Object.keys(prop.embeddedProps)) {
+                if (!top || key === top) {
+                    this.processField(meta, prop.embeddedProps[key], parts.join('.'), ret, populate, joinedProps, qb);
+                }
+            }
+            return;
+        }
+        if (prop.fieldNames) {
+            ret.push(...prop.fieldNames);
+        }
+    }
     buildFields(meta, populate, joinedProps, qb, fields) {
         const lazyProps = meta.props.filter(prop => prop.lazy && !populate.some(p => p.field === prop.name || p.all));
         const hasLazyFormulas = meta.props.some(p => p.lazy && p.formula);
@@ -611,11 +783,21 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             ret.push(...this.getFieldsForJoinedLoad(qb, meta, fields, populate));
         }
         else if (fields) {
-            for (const field of [...fields]) {
-                if (core_1.Utils.isPlainObject(field) || field.toString().includes('.')) {
+            for (const field of this.normalizeFields(fields)) {
+                if (field === '*') {
+                    ret.push('*');
                     continue;
                 }
-                ret.push(field);
+                const parts = field.split('.');
+                const rootPropName = parts.shift(); // first one is the `prop`
+                const prop = core_1.QueryHelper.findProperty(rootPropName, {
+                    metadata: this.metadata,
+                    platform: this.platform,
+                    entityName: meta.className,
+                    where: {},
+                    aliasMap: qb.getAliasMap(),
+                });
+                this.processField(meta, prop, parts.join('.'), ret, populate, joinedProps, qb);
             }
             ret.unshift(...meta.primaryKeys.filter(pk => !fields.includes(pk)));
         }
@@ -638,7 +820,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 .filter(prop => prop.customType?.convertToDatabaseValueSQL || prop.customType?.convertToJSValueSQL)
                 .forEach(prop => ret.push(prop.name));
         }
-        return ret.length > 0 ? ret : ['*'];
+        return ret.length > 0 ? core_1.Utils.unique(ret) : ['*'];
     }
 }
 exports.AbstractSqlDriver = AbstractSqlDriver;