@mikro-orm/knex 7.0.0-dev.1 → 7.0.0-dev.10

package/AbstractSqlDriver.js

@@ -1,12 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractSqlDriver = void 0;
-const core_1 = require("@mikro-orm/core");
-const query_1 = require("./query");
-const SqlEntityManager_1 = require("./SqlEntityManager");
-const PivotCollectionPersister_1 = require("./PivotCollectionPersister");
-class AbstractSqlDriver extends core_1.DatabaseDriver {
-    [core_1.EntityManagerType];
+import { ALIAS_REPLACEMENT_RE, DatabaseDriver, EntityManagerType, getOnConflictFields, getOnConflictReturningFields, helper, isRaw, LoadStrategy, parseJsonSafe, QueryFlag, QueryHelper, QueryOrder, raw, RawQueryFragment, ReferenceKind, Utils, } from '@mikro-orm/core';
+import { QueryBuilder } from './query/QueryBuilder.js';
+import { JoinType, QueryType } from './query/enums.js';
+import { SqlEntityManager } from './SqlEntityManager.js';
+import { PivotCollectionPersister } from './PivotCollectionPersister.js';
+export class AbstractSqlDriver extends DatabaseDriver {
+    [EntityManagerType];
     connection;
     replicas = [];
     platform;
@@ -20,7 +18,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         return this.platform;
     }
     createEntityManager(useContext) {
-        const EntityManagerClass = this.config.get('entityManager', SqlEntityManager_1.SqlEntityManager);
+        const EntityManagerClass = this.config.get('entityManager', SqlEntityManager);
         return new EntityManagerClass(this.config, this, this.metadata, useContext);
     }
     async find(entityName, where, options = {}) {
@@ -35,9 +33,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const fields = this.buildFields(meta, populate, joinedProps, qb, qb.alias, options);
         const orderBy = this.buildOrderBy(qb, meta, populate, options);
         const populateWhere = this.buildPopulateWhere(meta, joinedProps, options);
-        core_1.Utils.asArray(options.flags).forEach(flag => qb.setFlag(flag));
-        if (core_1.Utils.isPrimaryKey(where, meta.compositePK)) {
-            where = { [core_1.Utils.getPrimaryKeyHash(meta.primaryKeys)]: where };
+        Utils.asArray(options.flags).forEach(flag => qb.setFlag(flag));
+        if (Utils.isPrimaryKey(where, meta.compositePK)) {
+            where = { [Utils.getPrimaryKeyHash(meta.primaryKeys)]: where };
         }
         const { first, last, before, after } = options;
         const isCursorPagination = [first, last, before, after].some(v => v != null);
@@ -65,6 +63,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (options.lockMode) {
             qb.setLockMode(options.lockMode, options.lockTableAliases);
         }
+        if (options.em) {
+            await qb.applyJoinedFilters(options.em, options.filters);
+        }
         const result = await this.rethrow(qb.execute('all'));
         if (isCursorPagination && !first && !!last) {
             result.reverse();
@@ -80,9 +81,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (joinedProps.length === 0 || !hasToManyJoins) {
             opts.limit = 1;
         }
-        if (opts.limit > 0 && !opts.flags?.includes(core_1.QueryFlag.DISABLE_PAGINATE)) {
+        if (opts.limit > 0 && !opts.flags?.includes(QueryFlag.DISABLE_PAGINATE)) {
             opts.flags ??= [];
-            opts.flags.push(core_1.QueryFlag.DISABLE_PAGINATE);
+            opts.flags.push(QueryFlag.DISABLE_PAGINATE);
         }
         const res = await this.find(entityName, where, opts);
         return res[0] || null;
@@ -90,7 +91,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
     hasToManyJoins(hint, meta) {
         const [propName] = hint.field.split(':', 2);
         const prop = meta.properties[propName];
-        if (prop && [core_1.ReferenceKind.ONE_TO_MANY, core_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
+        if (prop && [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
             return true;
         }
         if (hint.children && prop.targetMeta) {
@@ -99,16 +100,16 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         return false;
     }
     async findVirtual(entityName, where, options) {
-        return this.findFromVirtual(entityName, where, options, query_1.QueryType.SELECT);
+        return this.findFromVirtual(entityName, where, options, QueryType.SELECT);
     }
     async countVirtual(entityName, where, options) {
-        return this.findFromVirtual(entityName, where, options, query_1.QueryType.COUNT);
+        return this.findFromVirtual(entityName, where, options, QueryType.COUNT);
     }
     async findFromVirtual(entityName, where, options, type) {
         const meta = this.metadata.get(entityName);
-        /* istanbul ignore next */
+        /* v8 ignore next 3 */
         if (!meta.expression) {
-            return type === query_1.QueryType.SELECT ? [] : 0;
+            return type === QueryType.SELECT ? [] : 0;
         }
         if (typeof meta.expression === 'string') {
             return this.wrapVirtualExpressionInSubquery(meta, meta.expression, where, options, type);
@@ -119,14 +120,14 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (typeof res === 'string') {
             return this.wrapVirtualExpressionInSubquery(meta, res, where, options, type);
         }
-        if (res instanceof query_1.QueryBuilder) {
+        if (res instanceof QueryBuilder) {
             return this.wrapVirtualExpressionInSubquery(meta, res.getFormattedQuery(), where, options, type);
         }
-        if (res instanceof core_1.RawQueryFragment) {
+        if (res instanceof RawQueryFragment) {
             const expr = this.platform.formatQuery(res.sql, res.params);
             return this.wrapVirtualExpressionInSubquery(meta, expr, where, options, type);
         }
-        /* istanbul ignore next */
+        /* v8 ignore next */
         return res;
     }
     async wrapVirtualExpressionInSubquery(meta, expression, where, options, type) {
@@ -137,7 +138,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         qb.where(where);
         const { first, last, before, after } = options;
         const isCursorPagination = [first, last, before, after].some(v => v != null);
-        if (type !== query_1.QueryType.COUNT) {
+        if (type !== QueryType.COUNT) {
             if (options.orderBy) {
                 if (isCursorPagination) {
                     const { orderBy: newOrderBy, where } = this.processCursorOptions(meta, options, options.orderBy);
@@ -150,16 +151,16 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             qb.limit(options?.limit, options?.offset);
         }
         const native = qb.getNativeQuery(false).clear('select');
-        if (type === query_1.QueryType.COUNT) {
+        if (type === QueryType.COUNT) {
             native.count();
         }
         else { // select
             native.select('*');
         }
-        native.from((0, core_1.raw)(`(${expression}) as ${this.platform.quoteIdentifier(qb.alias)}`));
+        native.from(raw(`(${expression}) as ${this.platform.quoteIdentifier(qb.alias)}`));
         const query = native.compile();
         const res = await this.execute(query.sql, query.params, 'all', options.ctx);
-        if (type === query_1.QueryType.COUNT) {
+        if (type === QueryType.COUNT) {
             return res[0].count;
         }
         if (isCursorPagination && !first && !!last) {
@@ -169,7 +170,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
     }
     mapResult(result, meta, populate = [], qb, map = {}) {
         const ret = super.mapResult(result, meta);
-        /* istanbul ignore if */
+        /* v8 ignore next 3 */
         if (!ret) {
             return null;
         }
@@ -184,11 +185,11 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         joinedProps.forEach(hint => {
             const [propName, ref] = hint.field.split(':', 2);
             const prop = meta.properties[propName];
-            /* istanbul ignore next */
+            /* v8 ignore next 3 */
             if (!prop) {
                 return;
             }
-            const pivotRefJoin = prop.kind === core_1.ReferenceKind.MANY_TO_MANY && ref;
+            const pivotRefJoin = prop.kind === ReferenceKind.MANY_TO_MANY && ref;
             const meta2 = this.metadata.find(prop.type);
             let path = parentJoinPath ? `${parentJoinPath}.${prop.name}` : `${meta.name}.${prop.name}`;
             if (!parentJoinPath) {
@@ -198,7 +199,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 path += '[pivot]';
             }
             const relationAlias = qb.getAliasForJoinPath(path, { matchPopulateJoins: true });
-            /* istanbul ignore next */
+            /* v8 ignore next 3 */
             if (!relationAlias) {
                 return;
             }
@@ -226,10 +227,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 return root[`${relationAlias}__${name}`] != null;
             }));
             if (!hasPK) {
-                if ([core_1.ReferenceKind.MANY_TO_MANY, core_1.ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
+                if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
                     result[prop.name] = [];
                 }
-                if ([core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+                if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
                     result[prop.name] = null;
                 }
                 return;
@@ -239,7 +240,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 .filter(prop => !ref && prop.persist === false && prop.fieldNames)
                 .filter(prop => !prop.lazy || populate.some(p => p.field === prop.name || p.all))
                 .forEach(prop => {
-                /* istanbul ignore if */
+                /* v8 ignore next 3 */
                 if (prop.fieldNames.length > 1) { // composite keys
                     relationPojo[prop.name] = prop.fieldNames.map(name => root[`${relationAlias}__${name}`]);
                 }
@@ -254,9 +255,12 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 : meta2.props.filter(prop => this.platform.shouldHaveColumn(prop, hint.children || []));
             const tz = this.platform.getTimezone();
             for (const prop of targetProps) {
+                if (prop.fieldNames.every(name => typeof root[`${relationAlias}__${name}`] === 'undefined')) {
+                    continue;
+                }
                 if (prop.fieldNames.length > 1) { // composite keys
                     const fk = prop.fieldNames.map(name => root[`${relationAlias}__${name}`]);
-                    const pk = core_1.Utils.mapFlatCompositePrimaryKey(fk, prop);
+                    const pk = Utils.mapFlatCompositePrimaryKey(fk, prop);
                     relationPojo[prop.name] = pk.every(val => val != null) ? pk : null;
                 }
                 else if (prop.runtimeType === 'Date') {
@@ -275,8 +279,8 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 else {
                     const alias = `${relationAlias}__${prop.fieldNames[0]}`;
                     relationPojo[prop.name] = root[alias];
-                    if (prop.kind === core_1.ReferenceKind.EMBEDDED && (prop.object || meta.embeddable)) {
-                        const item = (0, core_1.parseJsonSafe)(relationPojo[prop.name]);
+                    if (prop.kind === ReferenceKind.EMBEDDED && (prop.object || meta.embeddable)) {
+                        const item = parseJsonSafe(relationPojo[prop.name]);
                         if (Array.isArray(item)) {
                             relationPojo[prop.name] = item.map(row => row == null ? row : this.comparator.mapResult(prop.type, row));
                         }
@@ -293,10 +297,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             }
             if (mapToPk) {
                 const tmp = Object.values(relationPojo);
-                /* istanbul ignore next */
+                /* v8 ignore next */
                 relationPojo = (meta2.compositePK ? tmp : tmp[0]);
             }
-            if ([core_1.ReferenceKind.MANY_TO_MANY, core_1.ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
+            if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
                 result[prop.name] ??= [];
                 result[prop.name].push(relationPojo);
             }
@@ -324,7 +328,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             .populate(populate, joinedProps.length > 0 ? populateWhere : undefined, joinedProps.length > 0 ? options.populateFilter : undefined)
             .withSchema(this.getSchemaName(meta, options))
             .where(where);
-        if (meta && !core_1.Utils.isEmpty(populate)) {
+        if (meta && !Utils.isEmpty(populate)) {
             this.buildFields(meta, populate, joinedProps, qb, qb.alias, options, true);
         }
         return this.rethrow(qb.getCount());
@@ -339,10 +343,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         res.row = res.row || {};
         let pk;
         if (pks.length > 1) { // owner has composite pk
-            pk = core_1.Utils.getPrimaryKeyCond(data, pks);
+            pk = Utils.getPrimaryKeyCond(data, pks);
         }
         else {
-            /* istanbul ignore next */
+            /* v8 ignore next */
             res.insertId = data[pks[0]] ?? res.insertId ?? res.row[pks[0]];
             pk = [res.insertId];
         }
@@ -356,23 +360,23 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const collections = options.processCollections ? data.map(d => this.extractManyToMany(entityName, d)) : [];
         const pks = this.getPrimaryKeyFields(entityName);
         const set = new Set();
-        data.forEach(row => core_1.Utils.keys(row).forEach(k => set.add(k)));
+        data.forEach(row => Utils.keys(row).forEach(k => set.add(k)));
         const props = [...set].map(name => meta?.properties[name] ?? { name, fieldNames: [name] });
-        let fields = core_1.Utils.flatten(props.map(prop => prop.fieldNames));
-        const duplicates = core_1.Utils.findDuplicates(fields);
+        let fields = Utils.flatten(props.map(prop => prop.fieldNames));
+        const duplicates = Utils.findDuplicates(fields);
         const params = [];
         if (duplicates.length) {
-            fields = core_1.Utils.unique(fields);
+            fields = Utils.unique(fields);
         }
-        /* istanbul ignore next */
+        /* v8 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 (meta && this.platform.usesOutputStatement()) {
             const returningProps = meta.props
                 .filter(prop => prop.persist !== false && prop.defaultRaw || prop.autoincrement || prop.generated)
-                .filter(prop => !(prop.name in data[0]) || (0, core_1.isRaw)(data[0][prop.name]));
-            const returningFields = core_1.Utils.flatten(returningProps.map(prop => prop.fieldNames));
+                .filter(prop => !(prop.name in data[0]) || isRaw(data[0][prop.name]));
+            const returningFields = Utils.flatten(returningProps.map(prop => prop.fieldNames));
             sql += returningFields.length > 0 ? ` output ${returningFields.map(field => 'inserted.' + this.platform.quoteIdentifier(field)).join(', ')}` : '';
         }
         if (fields.length > 0 || this.platform.usesDefaultKeyword()) {
@@ -383,7 +387,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         const addParams = (prop, row) => {
             let value = row[prop.name] ?? prop.default;
-            if (prop.kind === core_1.ReferenceKind.EMBEDDED && prop.object) {
+            if (prop.kind === ReferenceKind.EMBEDDED && prop.object) {
                 if (prop.array && value) {
                     value = this.platform.cloneEmbeddable(value);
                     for (let i = 0; i < value.length; i++) {
@@ -400,7 +404,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 return;
             }
             if (typeof value === 'undefined' && this.platform.usesDefaultKeyword()) {
-                params.push((0, core_1.raw)('default'));
+                params.push(raw('default'));
                 return;
             }
             params.push(value);
@@ -412,7 +416,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 props.forEach(prop => {
                     if (prop.fieldNames.length > 1) {
                         const newFields = [];
-                        const allParam = [...core_1.Utils.asArray(row[prop.name]) ?? prop.fieldNames.map(() => null)];
+                        const allParam = [...(Utils.asArray(row[prop.name]) ?? prop.fieldNames.map(() => null))];
                         // TODO(v7): instead of making this conditional here, the entity snapshot should respect `ownColumns`,
                         //  but that means changing the compiled PK getters, which might be seen as breaking
                         const columns = allParam.length > 1 ? prop.fieldNames : prop.ownColumns;
@@ -424,7 +428,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                             newFields.push(field);
                             newParam.push(allParam[idx]);
                         });
-                        const param = core_1.Utils.flatten(newParam);
+                        const param = Utils.flatten(newParam);
                         newFields.forEach((field, idx) => {
                             if (!duplicates.includes(field) || !usedDups.includes(field)) {
                                 params.push(param[idx]);
@@ -436,7 +440,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                     else {
                         const field = prop.fieldNames[0];
                         if (!duplicates.includes(field) || !usedDups.includes(field)) {
-                            if (prop.customType && !prop.object && 'convertToDatabaseValueSQL' in prop.customType && !(0, core_1.isRaw)(row[prop.name])) {
+                            if (prop.customType && !prop.object && 'convertToDatabaseValueSQL' in prop.customType && row[prop.name] != null && !isRaw(row[prop.name])) {
                                 keys.push(prop.customType.convertToDatabaseValueSQL('?', this.platform));
                             }
                             else {
@@ -453,9 +457,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (meta && this.platform.usesReturningStatement()) {
             const returningProps = meta.props
                 .filter(prop => prop.persist !== false && prop.defaultRaw || prop.autoincrement || prop.generated)
-                .filter(prop => !(prop.name in data[0]) || (0, core_1.isRaw)(data[0][prop.name]));
-            const returningFields = core_1.Utils.flatten(returningProps.map(prop => prop.fieldNames));
-            /* istanbul ignore next */
+                .filter(prop => !(prop.name in data[0]) || isRaw(data[0][prop.name]));
+            const returningFields = Utils.flatten(returningProps.map(prop => prop.fieldNames));
+            /* v8 ignore next */
             sql += returningFields.length > 0 ? ` returning ${returningFields.map(field => this.platform.quoteIdentifier(field)).join(', ')}` : '';
         }
         if (transform) {
@@ -463,9 +467,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         const res = await this.execute(sql, params, 'run', options.ctx);
         let pk;
-        /* istanbul ignore next */
+        /* v8 ignore next 3 */
         if (pks.length > 1) { // owner has composite pk
-            pk = data.map(d => core_1.Utils.getPrimaryKeyCond(d, pks));
+            pk = data.map(d => Utils.getPrimaryKeyCond(d, pks));
         }
         else {
             res.row ??= {};
@@ -484,22 +488,22 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         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) {
-            /* istanbul ignore next */
+        if (Utils.isPrimaryKey(where) && pks.length === 1) {
+            /* v8 ignore next */
             where = { [meta?.primaryKeys[0] ?? pks[0]]: where };
         }
-        if (core_1.Utils.hasObjectKeys(data)) {
+        if (Utils.hasObjectKeys(data)) {
             const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes)
                 .withSchema(this.getSchemaName(meta, options));
             if (options.upsert) {
-                /* istanbul ignore next */
-                const uniqueFields = options.onConflictFields ?? (core_1.Utils.isPlainObject(where) ? core_1.Utils.keys(where) : meta.primaryKeys);
-                const returning = (0, core_1.getOnConflictReturningFields)(meta, data, uniqueFields, options);
+                /* v8 ignore next */
+                const uniqueFields = options.onConflictFields ?? (Utils.isPlainObject(where) ? Utils.keys(where) : meta.primaryKeys);
+                const returning = getOnConflictReturningFields(meta, data, uniqueFields, options);
                 qb.insert(data)
                     .onConflict(uniqueFields)
                     .returning(returning);
                 if (!options.onConflictAction || options.onConflictAction === 'merge') {
-                    const fields = (0, core_1.getOnConflictFields)(meta, data, uniqueFields, options);
+                    const fields = getOnConflictFields(meta, data, uniqueFields, options);
                     qb.merge(fields);
                 }
                 if (options.onConflictAction === 'ignore') {
@@ -517,8 +521,8 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             }
             res = await this.rethrow(qb.execute('run', false));
         }
-        /* istanbul ignore next */
-        const pk = pks.map(pk => core_1.Utils.extractPK(data[pk] || where, meta));
+        /* v8 ignore next */
+        const pk = pks.map(pk => Utils.extractPK(data[pk] || where, meta));
         await this.processManyToMany(meta, pk, collections, true, options);
         return res;
     }
@@ -527,14 +531,14 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         options.convertCustomTypes ??= true;
         const meta = this.metadata.get(entityName);
         if (options.upsert) {
-            const uniqueFields = options.onConflictFields ?? (core_1.Utils.isPlainObject(where[0]) ? Object.keys(where[0]).flatMap(key => core_1.Utils.splitPrimaryKeys(key)) : meta.primaryKeys);
+            const uniqueFields = options.onConflictFields ?? (Utils.isPlainObject(where[0]) ? Object.keys(where[0]).flatMap(key => Utils.splitPrimaryKeys(key)) : meta.primaryKeys);
             const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes).withSchema(this.getSchemaName(meta, options));
-            const returning = (0, core_1.getOnConflictReturningFields)(meta, data[0], uniqueFields, options);
+            const returning = getOnConflictReturningFields(meta, data[0], uniqueFields, options);
             qb.insert(data)
                 .onConflict(uniqueFields)
                 .returning(returning);
             if (!options.onConflictAction || options.onConflictAction === 'merge') {
-                const fields = (0, core_1.getOnConflictFields)(meta, data[0], uniqueFields, options);
+                const fields = getOnConflictFields(meta, data[0], uniqueFields, options);
                 qb.merge(fields);
             }
             if (options.onConflictAction === 'ignore') {
@@ -547,9 +551,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const fields = new Set();
         const returning = new Set();
         for (const row of data) {
-            for (const k of core_1.Utils.keys(row)) {
+            for (const k of Utils.keys(row)) {
                 keys.add(k);
-                if ((0, core_1.isRaw)(row[k])) {
+                if (isRaw(row[k])) {
                     returning.add(k);
                 }
             }
@@ -558,11 +562,11 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         meta?.props
             .filter(prop => prop.generated || prop.version || prop.primary)
             .forEach(prop => returning.add(prop.name));
-        const pkCond = core_1.Utils.flatten(meta.primaryKeys.map(pk => meta.properties[pk].fieldNames)).map(pk => `${this.platform.quoteIdentifier(pk)} = ?`).join(' and ');
+        const pkCond = 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 `;
         const addParams = (prop, value) => {
-            if (prop.kind === core_1.ReferenceKind.EMBEDDED && prop.object) {
+            if (prop.kind === ReferenceKind.EMBEDDED && prop.object) {
                 if (prop.array && value) {
                     for (let i = 0; i < value.length; i++) {
                         const item = value[i];
@@ -585,9 +589,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 sql += `${this.platform.quoteIdentifier(fieldName)} = case`;
                 where.forEach((cond, idx) => {
                     if (key in data[idx]) {
-                        const pks = core_1.Utils.getOrderedPrimaryKeys(cond, meta);
+                        const pks = Utils.getOrderedPrimaryKeys(cond, meta);
                         sql += ` when (${pkCond}) then `;
-                        if (prop.customType && !prop.object && 'convertToDatabaseValueSQL' in prop.customType && !(0, core_1.isRaw)(data[idx][key])) {
+                        if (prop.customType && !prop.object && 'convertToDatabaseValueSQL' in prop.customType && data[idx][prop.name] != null && !isRaw(data[idx][key])) {
                             sql += prop.customType.convertToDatabaseValueSQL('?', this.platform);
                         }
                         else {
@@ -615,16 +619,16 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         sql = sql.substring(0, sql.length - 2) + ' where ';
         const pkProps = meta.primaryKeys.concat(...meta.concurrencyCheckKeys);
-        const pks = core_1.Utils.flatten(pkProps.map(pk => meta.properties[pk].fieldNames));
+        const pks = 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) {
+            if (Utils.isPlainObject(cond) && Utils.getObjectKeysSize(cond) === 1) {
                 cond = Object.values(cond)[0];
             }
             if (pks.length > 1) {
                 pkProps.forEach(pk => {
                     if (Array.isArray(cond[pk])) {
-                        params.push(...core_1.Utils.flatten(cond[pk]));
+                        params.push(...Utils.flatten(cond[pk]));
                     }
                     else {
                         params.push(cond[pk]);
@@ -637,8 +641,8 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         });
         sql += ` in (${conds.join(', ')})`;
         if (this.platform.usesReturningStatement() && returning.size > 0) {
-            const returningFields = core_1.Utils.flatten([...returning].map(prop => meta.properties[prop].fieldNames));
-            /* istanbul ignore next */
+            const returningFields = Utils.flatten([...returning].map(prop => meta.properties[prop].fieldNames));
+            /* v8 ignore next */
             sql += returningFields.length > 0 ? ` returning ${returningFields.map(field => this.platform.quoteIdentifier(field)).join(', ')}` : '';
         }
         const res = await this.rethrow(this.execute(sql, params, 'run', options.ctx));
@@ -650,7 +654,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
     async nativeDelete(entityName, where, options = {}) {
         const meta = this.metadata.find(entityName);
         const pks = this.getPrimaryKeyFields(entityName);
-        if (core_1.Utils.isPrimaryKey(where) && pks.length === 1) {
+        if (Utils.isPrimaryKey(where) && pks.length === 1) {
             where = { [pks[0]]: where };
         }
         const qb = this.createQueryBuilder(entityName, options.ctx, 'write', false).delete(where).withSchema(this.getSchemaName(meta, options));
@@ -669,7 +673,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 }
             }
             else {
-                if (!core_1.Utils.equals(a[i], b[i])) {
+                if (!Utils.equals(a[i], b[i])) {
                     return false;
                 }
             }
@@ -679,17 +683,17 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
     async syncCollections(collections, options) {
         const groups = {};
         for (const coll of collections) {
-            const wrapped = (0, core_1.helper)(coll.owner);
+            const wrapped = helper(coll.owner);
             const meta = wrapped.__meta;
             const pks = wrapped.getPrimaryKeys(true);
             const snap = coll.getSnapshot();
             const includes = (arr, item) => !!arr.find(i => this.comparePrimaryKeyArrays(i, item));
-            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 snapshot = snap ? snap.map(item => helper(item).getPrimaryKeys(true)) : [];
+            const current = coll.getItems(false).map(item => 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);
-            const equals = core_1.Utils.equals(current, target);
+            const equals = Utils.equals(current, target);
             // wrong order if we just delete and insert to the end (only owning sides can have fixed order)
             if (coll.property.owner && coll.property.fixedOrder && !equals && Array.isArray(deleteDiff)) {
                 deleteDiff.length = insertDiff.length = 0;
@@ -700,46 +704,50 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                     insertDiff.push(item);
                 }
             }
-            if (coll.property.kind === core_1.ReferenceKind.ONE_TO_MANY) {
+            if (coll.property.kind === ReferenceKind.ONE_TO_MANY) {
                 const cols = coll.property.referencedColumnNames;
                 const qb = this.createQueryBuilder(coll.property.type, options?.ctx, 'write')
                     .withSchema(this.getSchemaName(meta, options));
                 if (coll.getSnapshot() === undefined) {
                     if (coll.property.orphanRemoval) {
                         const query = qb.delete({ [coll.property.mappedBy]: pks })
-                            .andWhere({ [cols.join(core_1.Utils.PK_SEPARATOR)]: { $nin: insertDiff } });
+                            .andWhere({ [cols.join(Utils.PK_SEPARATOR)]: { $nin: insertDiff } });
                         await this.rethrow(query.execute());
                         continue;
                     }
                     const query = qb.update({ [coll.property.mappedBy]: null })
                         .where({ [coll.property.mappedBy]: pks })
-                        .andWhere({ [cols.join(core_1.Utils.PK_SEPARATOR)]: { $nin: insertDiff } });
-                    await this.rethrow(query.execute());
-                    continue;
-                }
-                /* istanbul ignore next */
-                {
-                    const query = qb.update({ [coll.property.mappedBy]: pks })
-                        .where({ [cols.join(core_1.Utils.PK_SEPARATOR)]: { $in: insertDiff } });
+                        .andWhere({ [cols.join(Utils.PK_SEPARATOR)]: { $nin: insertDiff } });
                     await this.rethrow(query.execute());
                     continue;
                 }
+                /* v8 ignore next 5 */
+                const query = qb.update({ [coll.property.mappedBy]: pks })
+                    .where({ [cols.join(Utils.PK_SEPARATOR)]: { $in: insertDiff } });
+                await this.rethrow(query.execute());
+                continue;
             }
-            /* istanbul ignore next */
+            /* v8 ignore next */
             const pivotMeta = this.metadata.find(coll.property.pivotEntity);
             let schema = pivotMeta.schema;
             if (schema === '*') {
-                const ownerSchema = wrapped.getSchema() === '*' ? this.config.get('schema') : wrapped.getSchema();
-                schema = coll.property.owner ? ownerSchema : this.config.get('schema');
+                if (coll.property.owner) {
+                    schema = wrapped.getSchema() === '*' ? options?.schema ?? this.config.get('schema') : wrapped.getSchema();
+                }
+                else {
+                    const targetMeta = coll.property.targetMeta;
+                    const targetSchema = (coll[0] ?? snap?.[0]) && helper(coll[0] ?? snap?.[0]).getSchema();
+                    schema = targetMeta.schema === '*' ? options?.schema ?? targetSchema ?? this.config.get('schema') : targetMeta.schema;
+                }
             }
             else if (schema == null) {
                 schema = this.config.get('schema');
             }
             const tableName = `${schema ?? '_'}.${pivotMeta.tableName}`;
-            const persister = groups[tableName] ??= new PivotCollectionPersister_1.PivotCollectionPersister(pivotMeta, this, options?.ctx, schema);
+            const persister = groups[tableName] ??= new PivotCollectionPersister(pivotMeta, this, options?.ctx, schema);
             persister.enqueueUpdate(coll.property, insertDiff, deleteDiff, pks);
         }
-        for (const persister of core_1.Utils.values(groups)) {
+        for (const persister of Utils.values(groups)) {
             await this.rethrow(persister.execute());
         }
     }
@@ -755,12 +763,12 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             .comment(options.comments)
             .hintComment(options.hintComments);
         const pivotAlias = qb.alias;
-        const pivotKey = pivotProp2.joinColumns.map(column => `${pivotAlias}.${column}`).join(core_1.Utils.PK_SEPARATOR);
+        const pivotKey = pivotProp2.joinColumns.map(column => `${pivotAlias}.${column}`).join(Utils.PK_SEPARATOR);
         const cond = {
             [pivotKey]: { $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))) {
+        /* v8 ignore next 3 */
+        if (!Utils.isEmpty(where) && Object.keys(where).every(k => Utils.isOperator(k, false))) {
             where = cond;
         }
         else {
@@ -781,13 +789,15 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             const targetSchema = this.getSchemaName(prop.targetMeta, options) ?? this.platform.getDefaultSchemaName();
             qb.innerJoin(pivotProp1.name, targetAlias, {}, targetSchema);
             const targetFields = this.buildFields(prop.targetMeta, (options.populate ?? []), [], qb, targetAlias, options);
+            const additionalFields = [];
             for (const field of targetFields) {
                 const f = field.toString();
-                fields.unshift(f.includes('.') ? field : `${targetAlias}.${f}`);
-                if (core_1.RawQueryFragment.isKnownFragment(field)) {
+                additionalFields.push(f.includes('.') ? field : `${targetAlias}.${f}`);
+                if (RawQueryFragment.isKnownFragment(field)) {
                     qb.rawFragments.add(f);
                 }
             }
+            fields.unshift(...additionalFields);
             // we need to handle 1:1 owner auto-joins explicitly, as the QB type is the pivot table, not the target
             populate.forEach(hint => {
                 const alias = qb.getNextAlias(prop.targetMeta.tableName);
@@ -819,35 +829,35 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const map = {};
         const pkProps = ownerMeta.getPrimaryProps();
         for (const owner of owners) {
-            const key = core_1.Utils.getPrimaryKeyHash(prop.joinColumns.map((_col, idx) => {
+            const key = Utils.getPrimaryKeyHash(prop.joinColumns.map((_col, idx) => {
                 const pkProp = pkProps[idx];
                 return pkProp.customType ? pkProp.customType.convertToJSValue(owner[idx], this.platform) : owner[idx];
             }));
             map[key] = [];
         }
         for (const item of items) {
-            const key = core_1.Utils.getPrimaryKeyHash(prop.joinColumns.map((col, idx) => {
+            const key = Utils.getPrimaryKeyHash(prop.joinColumns.map((col, idx) => {
                 const pkProp = pkProps[idx];
                 return pkProp.customType ? pkProp.customType.convertToJSValue(item[`fk__${col}`], this.platform) : item[`fk__${col}`];
             }));
             map[key].push(item);
             prop.joinColumns.forEach(col => delete item[`fk__${col}`]);
             prop.inverseJoinColumns.forEach((col, idx) => {
-                core_1.Utils.renameKey(item, `fk__${col}`, prop.targetMeta.primaryKeys[idx]);
+                Utils.renameKey(item, `fk__${col}`, prop.targetMeta.primaryKeys[idx]);
             });
         }
         return map;
     }
     getPivotOrderBy(prop, pivotProp, pivotAlias, orderBy) {
         // FIXME this is ignoring the rest of the array items
-        if (!core_1.Utils.isEmpty(orderBy)) {
-            return [{ [pivotProp.name]: core_1.Utils.asArray(orderBy)[0] }];
+        if (!Utils.isEmpty(orderBy)) {
+            return [{ [pivotProp.name]: Utils.asArray(orderBy)[0] }];
         }
-        if (!core_1.Utils.isEmpty(prop.orderBy)) {
-            return [{ [pivotProp.name]: core_1.Utils.asArray(prop.orderBy)[0] }];
+        if (!Utils.isEmpty(prop.orderBy)) {
+            return [{ [pivotProp.name]: Utils.asArray(prop.orderBy)[0] }];
         }
         if (prop.fixedOrder) {
-            return [{ [`${pivotAlias}.${prop.fixedOrderColumn}`]: core_1.QueryOrder.ASC }];
+            return [{ [`${pivotAlias}.${prop.fixedOrderColumn}`]: QueryOrder.ASC }];
         }
         return [];
     }
@@ -863,7 +873,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         const relationsToPopulate = populate.map(({ field }) => field.split(':')[0]);
         const toPopulate = meta.relations
-            .filter(prop => prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner && !prop.lazy && !relationsToPopulate.includes(prop.name))
+            .filter(prop => prop.kind === ReferenceKind.ONE_TO_ONE && !prop.owner && !prop.lazy && !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}:ref`, strategy: prop.strategy }));
         return [...populate, ...toPopulate];
@@ -875,18 +885,18 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         return populate.filter(hint => {
             const [propName, ref] = hint.field.split(':', 2);
             const prop = meta.properties[propName] || {};
-            if (hint.filter && hint.strategy === core_1.LoadStrategy.JOINED) {
+            if (hint.filter && hint.strategy === LoadStrategy.JOINED) {
                 return true;
             }
             // skip redundant joins for 1:1 owner population hints when using `mapToPk`
-            if (prop.kind === core_1.ReferenceKind.ONE_TO_ONE && prop.mapToPk && prop.owner) {
+            if (prop.kind === ReferenceKind.ONE_TO_ONE && prop.mapToPk && prop.owner) {
                 return false;
             }
-            if ((options?.strategy || hint.strategy || prop.strategy || this.config.get('loadStrategy')) !== core_1.LoadStrategy.JOINED) {
+            if ((options?.strategy || hint.strategy || prop.strategy || this.config.get('loadStrategy')) !== LoadStrategy.JOINED) {
                 // force joined strategy for explicit 1:1 owner populate hint as it would require a join anyway
-                return prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner;
+                return prop.kind === ReferenceKind.ONE_TO_ONE && !prop.owner;
             }
-            return ![core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.EMBEDDED].includes(prop.kind);
+            return ![ReferenceKind.SCALAR, ReferenceKind.EMBEDDED].includes(prop.kind);
         });
     }
     /**
@@ -896,7 +906,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const res = [];
         const map = {};
         for (const item of rawResults) {
-            const pk = core_1.Utils.getCompositeKeyHash(item, meta);
+            const pk = Utils.getCompositeKeyHash(item, meta);
             if (map[pk]) {
                 for (const hint of joinedProps) {
                     const [propName, ref] = hint.field.split(':', 2);
@@ -904,17 +914,17 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                     if (!item[propName]) {
                         continue;
                     }
-                    if ([core_1.ReferenceKind.ONE_TO_MANY, core_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind) && ref) {
+                    if ([ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind) && ref) {
                         map[pk][propName] = [...map[pk][propName], ...item[propName]];
                         continue;
                     }
                     switch (prop.kind) {
-                        case core_1.ReferenceKind.ONE_TO_MANY:
-                        case core_1.ReferenceKind.MANY_TO_MANY:
+                        case ReferenceKind.ONE_TO_MANY:
+                        case ReferenceKind.MANY_TO_MANY:
                             map[pk][propName] = this.mergeJoinedResult([...map[pk][propName], ...item[propName]], prop.targetMeta, hint.children ?? []);
                             break;
-                        case core_1.ReferenceKind.MANY_TO_ONE:
-                        case core_1.ReferenceKind.ONE_TO_ONE:
+                        case ReferenceKind.MANY_TO_ONE:
+                        case ReferenceKind.ONE_TO_ONE:
                             map[pk][propName] = this.mergeJoinedResult([map[pk][propName], item[propName]], prop.targetMeta, hint.children ?? [])[0];
                             break;
                     }
@@ -931,35 +941,35 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const fields = [];
         const populate = options.populate ?? [];
         const joinedProps = this.joinedProps(meta, populate, options);
-        const shouldHaveColumn = (prop, populate, fields) => {
+        const shouldHaveColumn = (meta, prop, populate, fields) => {
             if (!this.platform.shouldHaveColumn(prop, populate, options.exclude)) {
                 return false;
             }
-            if (!fields || fields.includes('*') || prop.primary) {
+            if (!fields || fields.includes('*') || prop.primary || meta.root.discriminatorColumn === prop.name) {
                 return true;
             }
             return fields.some(f => f === prop.name || f.toString().startsWith(prop.name + '.'));
         };
-        const populateWhereAll = options?._populateWhere === 'all' || core_1.Utils.isEmpty(options?._populateWhere);
+        const populateWhereAll = options?._populateWhere === 'all' || Utils.isEmpty(options?._populateWhere);
         // root entity is already handled, skip that
         if (options.parentJoinPath) {
             // alias all fields in the primary table
             meta.props
-                .filter(prop => shouldHaveColumn(prop, populate, options.explicitFields))
+                .filter(prop => shouldHaveColumn(meta, prop, populate, options.explicitFields))
                 .forEach(prop => fields.push(...this.mapPropToFieldNames(qb, prop, options.parentTableAlias)));
         }
         for (const hint of joinedProps) {
             const [propName, ref] = hint.field.split(':', 2);
             const prop = meta.properties[propName];
             // ignore ref joins of known FKs unless it's a filter hint
-            if (ref && !hint.filter && (prop.kind === core_1.ReferenceKind.MANY_TO_ONE || (prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner))) {
+            if (ref && !hint.filter && (prop.kind === ReferenceKind.MANY_TO_ONE || (prop.kind === ReferenceKind.ONE_TO_ONE && !prop.owner))) {
                 continue;
             }
-            if (options.count && (!options?.populateFilter || !options.populateFilter[prop.name])) {
+            if (options.count && !options?.populateFilter?.[prop.name]) {
                 continue;
             }
             const meta2 = this.metadata.find(prop.type);
-            const pivotRefJoin = prop.kind === core_1.ReferenceKind.MANY_TO_MANY && ref;
+            const pivotRefJoin = prop.kind === ReferenceKind.MANY_TO_MANY && ref;
             const tableAlias = qb.getNextAlias(prop.name);
             const field = `${options.parentTableAlias}.${prop.name}`;
             let path = options.parentJoinPath ? `${options.parentJoinPath}.${prop.name}` : `${meta.name}.${prop.name}`;
@@ -967,15 +977,15 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 path = '[populate]' + path;
             }
             const joinType = pivotRefJoin
-                ? query_1.JoinType.pivotJoin
+                ? JoinType.pivotJoin
                 : hint.filter && !prop.nullable
-                    ? query_1.JoinType.innerJoin
-                    : query_1.JoinType.leftJoin;
+                    ? JoinType.innerJoin
+                    : JoinType.leftJoin;
             qb.join(field, tableAlias, {}, joinType, path);
             if (pivotRefJoin) {
                 fields.push(...prop.joinColumns.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)), ...prop.inverseJoinColumns.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)));
             }
-            if (prop.kind === core_1.ReferenceKind.ONE_TO_MANY && ref) {
+            if (prop.kind === ReferenceKind.ONE_TO_MANY && ref) {
                 fields.push(...this.getFieldsForJoinedLoad(qb, meta2, {
                     ...options,
                     explicitFields: prop.referencedColumnNames,
@@ -985,13 +995,13 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                     parentJoinPath: path,
                 }));
             }
-            const childExplicitFields = options.explicitFields?.filter(f => core_1.Utils.isPlainObject(f)).map(o => o[prop.name])[0] || [];
+            const childExplicitFields = options.explicitFields?.filter(f => Utils.isPlainObject(f)).map(o => o[prop.name])[0] || [];
             options.explicitFields?.forEach(f => {
                 if (typeof f === 'string' && f.startsWith(`${prop.name}.`)) {
                     childExplicitFields.push(f.substring(prop.name.length + 1));
                 }
             });
-            const childExclude = options.exclude ? core_1.Utils.extractChildElements(options.exclude, prop.name) : options.exclude;
+            const childExclude = options.exclude ? Utils.extractChildElements(options.exclude, prop.name) : options.exclude;
             if (!ref && !prop.mapToPk) {
                 fields.push(...this.getFieldsForJoinedLoad(qb, meta2, {
                     ...options,
@@ -1020,16 +1030,16 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 }
                 const prefixed = this.platform.quoteIdentifier(`${tableAlias}.${col}`);
                 const aliased = this.platform.quoteIdentifier(`${tableAlias}__${col}`);
-                return (0, core_1.raw)(`${prop.customTypes[idx].convertToJSValueSQL(prefixed, this.platform)} as ${aliased}`);
+                return raw(`${prop.customTypes[idx].convertToJSValueSQL(prefixed, this.platform)} as ${aliased}`);
             });
         }
         if (prop.customType?.convertToJSValueSQL) {
             const prefixed = this.platform.quoteIdentifier(`${tableAlias}.${prop.fieldNames[0]}`);
-            return [(0, core_1.raw)(`${prop.customType.convertToJSValueSQL(prefixed, this.platform)} as ${aliased}`)];
+            return [raw(`${prop.customType.convertToJSValueSQL(prefixed, this.platform)} as ${aliased}`)];
         }
         if (prop.formula) {
             const alias = this.platform.quoteIdentifier(tableAlias);
-            return [(0, core_1.raw)(`${prop.formula(alias)} as ${aliased}`)];
+            return [raw(`${prop.formula(alias)} as ${aliased}`)];
         }
         return prop.fieldNames.map(fieldName => {
             return `${tableAlias}.${fieldName} as ${tableAlias}__${fieldName}`;
@@ -1039,9 +1049,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
     createQueryBuilder(entityName, ctx, preferredConnectionType, convertCustomTypes, loggerContext, alias, em) {
         // do not compute the connectionType if EM is provided as it will be computed from it in the QB later on
         const connectionType = em ? preferredConnectionType : this.resolveConnectionType({ ctx, connectionType: preferredConnectionType });
-        const qb = new query_1.QueryBuilder(entityName, this.metadata, this, ctx, alias, connectionType, em, loggerContext);
+        const qb = new QueryBuilder(entityName, this.metadata, this, ctx, alias, connectionType, em, loggerContext);
         if (!convertCustomTypes) {
-            qb.unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES);
+            qb.unsetFlag(QueryFlag.CONVERT_CUSTOM_TYPES);
         }
         return qb;
     }
@@ -1063,8 +1073,8 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         const ret = {};
         this.metadata.find(entityName).relations.forEach(prop => {
-            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));
+            if (prop.kind === ReferenceKind.MANY_TO_MANY && data[prop.name]) {
+                ret[prop.name] = data[prop.name].map((item) => Utils.asArray(item));
                 delete data[prop.name];
             }
         });
@@ -1077,17 +1087,17 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         for (const prop of meta.relations) {
             if (collections[prop.name]) {
                 const pivotMeta = this.metadata.find(prop.pivotEntity);
-                const persister = new PivotCollectionPersister_1.PivotCollectionPersister(pivotMeta, this, options?.ctx, options?.schema);
+                const persister = new PivotCollectionPersister(pivotMeta, this, options?.ctx, options?.schema);
                 persister.enqueueUpdate(prop, collections[prop.name], clear, pks);
                 await this.rethrow(persister.execute());
             }
         }
     }
     async lockPessimistic(entity, options) {
-        const meta = (0, core_1.helper)(entity).__meta;
+        const meta = helper(entity).__meta;
         const qb = this.createQueryBuilder(entity.constructor.name, options.ctx, undefined, undefined, options.logging).withSchema(options.schema ?? meta.schema);
-        const cond = core_1.Utils.getPrimaryKeyCond(entity, meta.primaryKeys);
-        qb.select((0, core_1.raw)('1')).where(cond).setLockMode(options.lockMode, options.lockTableAliases);
+        const cond = Utils.getPrimaryKeyCond(entity, meta.primaryKeys);
+        qb.select(raw('1')).where(cond).setLockMode(options.lockMode, options.lockTableAliases);
         await this.rethrow(qb.execute());
     }
     buildPopulateWhere(meta, joinedProps, options) {
@@ -1095,45 +1105,45 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         for (const hint of joinedProps) {
             const [propName] = hint.field.split(':', 2);
             const prop = meta.properties[propName];
-            if (!core_1.Utils.isEmpty(prop.where)) {
-                where[prop.name] = core_1.Utils.copy(prop.where);
+            if (!Utils.isEmpty(prop.where)) {
+                where[prop.name] = Utils.copy(prop.where);
             }
             if (hint.children) {
                 const inner = this.buildPopulateWhere(prop.targetMeta, hint.children, {});
-                if (!core_1.Utils.isEmpty(inner)) {
+                if (!Utils.isEmpty(inner)) {
                     where[prop.name] ??= {};
                     Object.assign(where[prop.name], inner);
                 }
             }
         }
-        if (core_1.Utils.isEmpty(options.populateWhere)) {
+        if (Utils.isEmpty(options.populateWhere)) {
             return where;
         }
-        if (core_1.Utils.isEmpty(where)) {
+        if (Utils.isEmpty(where)) {
             return options.populateWhere;
         }
-        /* istanbul ignore next */
+        /* v8 ignore next */
         return { $and: [options.populateWhere, where] };
     }
     buildOrderBy(qb, meta, populate, options) {
         const joinedProps = this.joinedProps(meta, populate, options);
         // `options._populateWhere` is a copy of the value provided by user with a fallback to the global config option
         // as `options.populateWhere` will be always recomputed to respect filters
-        const populateWhereAll = options._populateWhere !== 'infer' && !core_1.Utils.isEmpty(options._populateWhere);
+        const populateWhereAll = options._populateWhere !== 'infer' && !Utils.isEmpty(options._populateWhere);
         const path = (populateWhereAll ? '[populate]' : '') + meta.className;
-        const populateOrderBy = this.buildPopulateOrderBy(qb, meta, core_1.Utils.asArray(options.populateOrderBy ?? options.orderBy), path, !!options.populateOrderBy);
+        const populateOrderBy = this.buildPopulateOrderBy(qb, meta, Utils.asArray(options.populateOrderBy ?? options.orderBy), path, !!options.populateOrderBy);
         const joinedPropsOrderBy = this.buildJoinedPropsOrderBy(qb, meta, joinedProps, options, path);
-        return [...core_1.Utils.asArray(options.orderBy), ...populateOrderBy, ...joinedPropsOrderBy];
+        return [...Utils.asArray(options.orderBy), ...populateOrderBy, ...joinedPropsOrderBy];
     }
     buildPopulateOrderBy(qb, meta, populateOrderBy, parentPath, explicit, parentAlias = qb.alias) {
         const orderBy = [];
         for (let i = 0; i < populateOrderBy.length; i++) {
             const orderHint = populateOrderBy[i];
-            for (const propName of core_1.Utils.keys(orderHint)) {
-                const raw = core_1.RawQueryFragment.getKnownFragment(propName, explicit);
+            for (const propName of Utils.keys(orderHint)) {
+                const raw = RawQueryFragment.getKnownFragment(propName, explicit);
                 if (raw) {
-                    const sql = raw.sql.replace(new RegExp(core_1.ALIAS_REPLACEMENT_RE, 'g'), parentAlias);
-                    const raw2 = new core_1.RawQueryFragment(sql, raw.params);
+                    const sql = raw.sql.replace(new RegExp(ALIAS_REPLACEMENT_RE, 'g'), parentAlias);
+                    const raw2 = new RawQueryFragment(sql, raw.params);
                     orderBy.push({ [raw2]: orderHint[propName] });
                     continue;
                 }
@@ -1144,10 +1154,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 let path = parentPath;
                 const meta2 = this.metadata.find(prop.type);
                 const childOrder = orderHint[prop.name];
-                if (![core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) || !prop.owner || core_1.Utils.isPlainObject(childOrder)) {
+                if (![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) || !prop.owner || Utils.isPlainObject(childOrder)) {
                     path += `.${propName}`;
                 }
-                if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY && typeof childOrder !== 'object') {
+                if (prop.kind === ReferenceKind.MANY_TO_MANY && typeof childOrder !== 'object') {
                     path += '[pivot]';
                 }
                 const join = qb.getJoinForPath(path, { matchPopulateJoins: true });
@@ -1155,12 +1165,12 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 if (!join && parentAlias === qb.alias) {
                     continue;
                 }
-                if (![core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.EMBEDDED].includes(prop.kind) && typeof childOrder === 'object') {
-                    const children = this.buildPopulateOrderBy(qb, meta2, core_1.Utils.asArray(childOrder), path, explicit, propAlias);
+                if (![ReferenceKind.SCALAR, ReferenceKind.EMBEDDED].includes(prop.kind) && typeof childOrder === 'object') {
+                    const children = this.buildPopulateOrderBy(qb, meta2, Utils.asArray(childOrder), path, explicit, propAlias);
                     orderBy.push(...children);
                     continue;
                 }
-                if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY && join) {
+                if (prop.kind === ReferenceKind.MANY_TO_MANY && join) {
                     if (prop.fixedOrderColumn) {
                         orderBy.push({ [`${join.alias}.${prop.fixedOrderColumn}`]: childOrder });
                     }
@@ -1187,23 +1197,23 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             const prop = meta.properties[propName];
             const propOrderBy = prop.orderBy;
             let path = `${parentPath}.${propName}`;
-            if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY && ref) {
+            if (prop.kind === ReferenceKind.MANY_TO_MANY && ref) {
                 path += '[pivot]';
             }
             const join = qb.getJoinForPath(path, { matchPopulateJoins: true });
             const propAlias = qb.getAliasForJoinPath(join ?? path, { matchPopulateJoins: true });
             const meta2 = this.metadata.find(prop.type);
-            if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY && prop.fixedOrder && join) {
+            if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.fixedOrder && join) {
                 const alias = ref ? propAlias : join.ownerAlias;
-                orderBy.push({ [`${alias}.${prop.fixedOrderColumn}`]: core_1.QueryOrder.ASC });
+                orderBy.push({ [`${alias}.${prop.fixedOrderColumn}`]: QueryOrder.ASC });
             }
             if (propOrderBy) {
-                for (const item of core_1.Utils.asArray(propOrderBy)) {
-                    for (const field of core_1.Utils.keys(item)) {
-                        const rawField = core_1.RawQueryFragment.getKnownFragment(field, false);
+                for (const item of Utils.asArray(propOrderBy)) {
+                    for (const field of Utils.keys(item)) {
+                        const rawField = RawQueryFragment.getKnownFragment(field, false);
                         if (rawField) {
-                            const sql = propAlias ? rawField.sql.replace(new RegExp(core_1.ALIAS_REPLACEMENT_RE, 'g'), propAlias) : rawField.sql;
-                            const raw2 = (0, core_1.raw)(sql, rawField.params);
+                            const sql = propAlias ? rawField.sql.replace(new RegExp(ALIAS_REPLACEMENT_RE, 'g'), propAlias) : rawField.sql;
+                            const raw2 = raw(sql, rawField.params);
                             orderBy.push({ [raw2.toString()]: item[field] });
                             continue;
                         }
@@ -1225,7 +1235,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 ret.push(prefix + field);
                 continue;
             }
-            if (core_1.Utils.isPlainObject(field)) {
+            if (Utils.isPlainObject(field)) {
                 for (const key of Object.keys(field)) {
                     ret.push(...this.normalizeFields(field[key], key + '.'));
                 }
@@ -1234,10 +1244,10 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         return ret;
     }
     processField(meta, prop, field, ret, populate, joinedProps, qb) {
-        if (!prop || (prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner)) {
+        if (!prop || (prop.kind === ReferenceKind.ONE_TO_ONE && !prop.owner)) {
             return;
         }
-        if (prop.kind === core_1.ReferenceKind.EMBEDDED) {
+        if (prop.kind === ReferenceKind.EMBEDDED) {
             if (prop.object) {
                 ret.push(prop.name);
                 return;
@@ -1281,7 +1291,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 }
                 const parts = field.split('.');
                 const rootPropName = parts.shift(); // first one is the `prop`
-                const prop = core_1.QueryHelper.findProperty(rootPropName, {
+                const prop = QueryHelper.findProperty(rootPropName, {
                     metadata: this.metadata,
                     platform: this.platform,
                     entityName: meta.className,
@@ -1293,8 +1303,11 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             if (!options.fields.includes('*') && !options.fields.includes(`${qb.alias}.*`)) {
                 ret.unshift(...meta.primaryKeys.filter(pk => !options.fields.includes(pk)));
             }
+            if (meta.root.discriminatorColumn && !options.fields.includes(`${qb.alias}.${meta.root.discriminatorColumn}`)) {
+                ret.push(meta.root.discriminatorColumn);
+            }
         }
-        else if (!core_1.Utils.isEmpty(options.exclude) || lazyProps.some(p => !p.formula && (p.kind !== '1:1' || p.owner))) {
+        else if (!Utils.isEmpty(options.exclude) || lazyProps.some(p => !p.formula && (p.kind !== '1:1' || p.owner))) {
             const props = meta.props.filter(prop => this.platform.shouldHaveColumn(prop, populate, options.exclude, false));
             ret.push(...props.filter(p => !lazyProps.includes(p)).map(p => p.name));
             addFormulas = true;
@@ -1312,7 +1325,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 .forEach(prop => {
                 const a = this.platform.quoteIdentifier(alias);
                 const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]);
-                ret.push((0, core_1.raw)(`${prop.formula(a)} as ${aliased}`));
+                ret.push(raw(`${prop.formula(a)} as ${aliased}`));
             });
             meta.props
                 .filter(prop => !prop.object && (prop.hasConvertToDatabaseValueSQL || prop.hasConvertToJSValueSQL))
@@ -1329,7 +1342,6 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 ...options,
             }));
         }
-        return core_1.Utils.unique(ret);
+        return Utils.unique(ret);
     }
 }
-exports.AbstractSqlDriver = AbstractSqlDriver;