typeorm 0.3.29-dev.cc07c90 → 1.0.0-beta.1

package/browser/query-builder/SelectQueryBuilder.js

@@ -1,33 +1,32 @@
-import { RawSqlResultsToEntityTransformer } from "./transformer/RawSqlResultsToEntityTransformer";
-import { PessimisticLockTransactionRequiredError } from "../error/PessimisticLockTransactionRequiredError";
-import { NoVersionOrUpdateDateColumnError } from "../error/NoVersionOrUpdateDateColumnError";
-import { OptimisticLockVersionMismatchError } from "../error/OptimisticLockVersionMismatchError";
-import { OptimisticLockCanNotBeUsedError } from "../error/OptimisticLockCanNotBeUsedError";
-import { JoinAttribute } from "./JoinAttribute";
-import { RelationIdAttribute } from "./relation-id/RelationIdAttribute";
-import { RelationCountAttribute } from "./relation-count/RelationCountAttribute";
-import { RelationIdLoader } from "./relation-id/RelationIdLoader";
-import { RelationIdLoader as QueryStrategyRelationIdLoader } from "./RelationIdLoader";
-import { RelationIdMetadataToAttributeTransformer } from "./relation-id/RelationIdMetadataToAttributeTransformer";
-import { RelationCountLoader } from "./relation-count/RelationCountLoader";
-import { RelationCountMetadataToAttributeTransformer } from "./relation-count/RelationCountMetadataToAttributeTransformer";
-import { QueryBuilder } from "./QueryBuilder";
-import { LockNotSupportedOnGivenDriverError } from "../error/LockNotSupportedOnGivenDriverError";
-import { OffsetWithoutLimitNotSupportedError } from "../error/OffsetWithoutLimitNotSupportedError";
-import { ObjectUtils } from "../util/ObjectUtils";
-import { DriverUtils } from "../driver/DriverUtils";
-import { EntityNotFoundError } from "../error/EntityNotFoundError";
-import { TypeORMError } from "../error";
-import { FindOptionsUtils } from "../find-options/FindOptionsUtils";
-import { OrmUtils } from "../util/OrmUtils";
-import { EntityPropertyNotFoundError } from "../error/EntityPropertyNotFoundError";
-import { InstanceChecker } from "../util/InstanceChecker";
-import { FindOperator } from "../find-options/FindOperator";
-import { ApplyValueTransformers } from "../util/ApplyValueTransformers";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectQueryBuilder = void 0;
+const RawSqlResultsToEntityTransformer_1 = require("./transformer/RawSqlResultsToEntityTransformer");
+const PessimisticLockTransactionRequiredError_1 = require("../error/PessimisticLockTransactionRequiredError");
+const NoVersionOrUpdateDateColumnError_1 = require("../error/NoVersionOrUpdateDateColumnError");
+const OptimisticLockVersionMismatchError_1 = require("../error/OptimisticLockVersionMismatchError");
+const OptimisticLockCanNotBeUsedError_1 = require("../error/OptimisticLockCanNotBeUsedError");
+const JoinAttribute_1 = require("./JoinAttribute");
+const RelationIdAttribute_1 = require("./relation-id/RelationIdAttribute");
+const RelationIdLoader_1 = require("./relation-id/RelationIdLoader");
+const RelationIdLoader_2 = require("./RelationIdLoader");
+const RelationIdMetadataToAttributeTransformer_1 = require("./relation-id/RelationIdMetadataToAttributeTransformer");
+const QueryBuilder_1 = require("./QueryBuilder");
+const LockNotSupportedOnGivenDriverError_1 = require("../error/LockNotSupportedOnGivenDriverError");
+const OffsetWithoutLimitNotSupportedError_1 = require("../error/OffsetWithoutLimitNotSupportedError");
+const ObjectUtils_1 = require("../util/ObjectUtils");
+const DriverUtils_1 = require("../driver/DriverUtils");
+const EntityNotFoundError_1 = require("../error/EntityNotFoundError");
+const error_1 = require("../error");
+const FindOptionsUtils_1 = require("../find-options/FindOptionsUtils");
+const OrmUtils_1 = require("../util/OrmUtils");
+const EntityPropertyNotFoundError_1 = require("../error/EntityPropertyNotFoundError");
+const InstanceChecker_1 = require("../util/InstanceChecker");
+const ApplyValueTransformers_1 = require("../util/ApplyValueTransformers");
 /**
  * Allows to build complex sql queries in a fashion way and execute those queries.
  */
-export class SelectQueryBuilder extends QueryBuilder {
+class SelectQueryBuilder extends QueryBuilder_1.QueryBuilder {
     constructor() {
         super(...arguments);
         this["@instanceof"] = Symbol.for("SelectQueryBuilder");
@@ -37,6 +36,7 @@ export class SelectQueryBuilder extends QueryBuilder {
         this.conditions = "";
         this.orderBys = [];
         this.relationMetadatas = [];
+        this.eagerLoadChain = new Set();
     }
     // -------------------------------------------------------------------------
     // Public Implemented Methods
@@ -64,6 +64,9 @@ export class SelectQueryBuilder extends QueryBuilder {
     // Public Methods
     // -------------------------------------------------------------------------
     setFindOptions(findOptions) {
+        FindOptionsUtils_1.FindOptionsUtils.rejectJoinOption(findOptions);
+        FindOptionsUtils_1.FindOptionsUtils.rejectStringArraySelect(findOptions);
+        FindOptionsUtils_1.FindOptionsUtils.rejectStringArrayRelations(findOptions);
         this.findOptions = findOptions;
         this.applyFindOptions();
         return this;
@@ -80,6 +83,8 @@ export class SelectQueryBuilder extends QueryBuilder {
     /**
      * Creates SELECT query and selects given data.
      * Replaces all previous selections if they exist.
+     * @param selection
+     * @param selectionAliasName
      */
     select(selection, selectionAliasName) {
         this.expressionMap.queryType = "select";
@@ -105,6 +110,8 @@ export class SelectQueryBuilder extends QueryBuilder {
     }
     /**
      * Adds new selection to the SELECT query.
+     * @param selection
+     * @param selectionAliasName
      */
     addSelect(selection, selectionAliasName) {
         if (!selection)
@@ -138,6 +145,7 @@ export class SelectQueryBuilder extends QueryBuilder {
     }
     /**
      * Sets whether the selection is DISTINCT.
+     * @param distinct
      */
     distinct(distinct = true) {
         this.expressionMap.selectDistinct = distinct;
@@ -145,19 +153,22 @@ export class SelectQueryBuilder extends QueryBuilder {
     }
     /**
      * Sets the distinct on clause for Postgres.
+     * @param distinctOn
      */
     distinctOn(distinctOn) {
         this.expressionMap.selectDistinctOn = distinctOn;
         return this;
     }
     fromDummy() {
-        return this.from(this.connection.driver.dummyTableName ??
+        return this.from(this.dataSource.driver.dummyTableName ??
             "(SELECT 1 AS dummy_column)", "dummy_table");
     }
     /**
      * Specifies FROM which entity's table select/update/delete will be executed.
      * Also sets a main string alias of the selection data.
      * Removes all previously set from-s.
+     * @param entityTarget
+     * @param aliasName
      */
     from(entityTarget, aliasName) {
         const mainAlias = this.createFromAlias(entityTarget, aliasName);
@@ -167,6 +178,8 @@ export class SelectQueryBuilder extends QueryBuilder {
     /**
      * Specifies FROM which entity's table select/update/delete will be executed.
      * Also sets a main string alias of the selection data.
+     * @param entityTarget
+     * @param aliasName
      */
     addFrom(entityTarget, aliasName) {
         const alias = this.createFromAlias(entityTarget, aliasName);
@@ -178,6 +191,10 @@ export class SelectQueryBuilder extends QueryBuilder {
      * INNER JOINs (without selection).
      * You also need to specify an alias of the joined data.
      * Optionally, you can add condition and parameters used in condition.
+     * @param entityOrProperty
+     * @param alias
+     * @param condition
+     * @param parameters
      */
     innerJoin(entityOrProperty, alias, condition, parameters) {
         this.join("INNER", entityOrProperty, alias, condition, parameters);
@@ -187,6 +204,10 @@ export class SelectQueryBuilder extends QueryBuilder {
      * LEFT JOINs (without selection).
      * You also need to specify an alias of the joined data.
      * Optionally, you can add condition and parameters used in condition.
+     * @param entityOrProperty
+     * @param alias
+     * @param condition
+     * @param parameters
      */
     leftJoin(entityOrProperty, alias, condition, parameters) {
         this.join("LEFT", entityOrProperty, alias, condition, parameters);
@@ -196,6 +217,10 @@ export class SelectQueryBuilder extends QueryBuilder {
      * INNER JOINs and adds all selection properties to SELECT.
      * You also need to specify an alias of the joined data.
      * Optionally, you can add condition and parameters used in condition.
+     * @param entityOrProperty
+     * @param alias
+     * @param condition
+     * @param parameters
      */
     innerJoinAndSelect(entityOrProperty, alias, condition, parameters) {
         this.addSelect(alias);
@@ -206,6 +231,10 @@ export class SelectQueryBuilder extends QueryBuilder {
      * LEFT JOINs and adds all selection properties to SELECT.
      * You also need to specify an alias of the joined data.
      * Optionally, you can add condition and parameters used in condition.
+     * @param entityOrProperty
+     * @param alias
+     * @param condition
+     * @param parameters
      */
     leftJoinAndSelect(entityOrProperty, alias, condition, parameters) {
         this.addSelect(alias);
@@ -218,6 +247,11 @@ export class SelectQueryBuilder extends QueryBuilder {
      * It will assume that there are multiple rows of selecting data, and mapped result will be an array.
      * You also need to specify an alias of the joined data.
      * Optionally, you can add condition and parameters used in condition.
+     * @param mapToProperty
+     * @param entityOrProperty
+     * @param alias
+     * @param condition
+     * @param parameters
      */
     innerJoinAndMapMany(mapToProperty, entityOrProperty, alias, condition, parameters) {
         this.addSelect(alias);
@@ -230,6 +264,12 @@ export class SelectQueryBuilder extends QueryBuilder {
      * It will assume that there is a single row of selecting data, and mapped result will be a single selected value.
      * You also need to specify an alias of the joined data.
      * Optionally, you can add condition and parameters used in condition.
+     * @param mapToProperty
+     * @param entityOrProperty
+     * @param alias
+     * @param condition
+     * @param parameters
+     * @param mapAsEntity
      */
     innerJoinAndMapOne(mapToProperty, entityOrProperty, alias, condition, parameters, mapAsEntity) {
         this.addSelect(alias);
@@ -242,6 +282,11 @@ export class SelectQueryBuilder extends QueryBuilder {
      * It will assume that there are multiple rows of selecting data, and mapped result will be an array.
      * You also need to specify an alias of the joined data.
      * Optionally, you can add condition and parameters used in condition.
+     * @param mapToProperty
+     * @param entityOrProperty
+     * @param alias
+     * @param condition
+     * @param parameters
      */
     leftJoinAndMapMany(mapToProperty, entityOrProperty, alias, condition, parameters) {
         this.addSelect(alias);
@@ -254,6 +299,12 @@ export class SelectQueryBuilder extends QueryBuilder {
      * It will assume that there is a single row of selecting data, and mapped result will be a single selected value.
      * You also need to specify an alias of the joined data.
      * Optionally, you can add condition and parameters used in condition.
+     * @param mapToProperty
+     * @param entityOrProperty
+     * @param alias
+     * @param condition
+     * @param parameters
+     * @param mapAsEntity
      */
     leftJoinAndMapOne(mapToProperty, entityOrProperty, alias, condition, parameters, mapAsEntity) {
         this.addSelect(alias);
@@ -263,9 +314,13 @@ export class SelectQueryBuilder extends QueryBuilder {
     /**
      * LEFT JOINs relation id and maps it into some entity's property.
      * Optionally, you can add condition and parameters used in condition.
+     * @param mapToProperty
+     * @param relationName
+     * @param aliasNameOrOptions
+     * @param queryBuilderFactory
      */
     loadRelationIdAndMap(mapToProperty, relationName, aliasNameOrOptions, queryBuilderFactory) {
-        const relationIdAttribute = new RelationIdAttribute(this.expressionMap);
+        const relationIdAttribute = new RelationIdAttribute_1.RelationIdAttribute(this.expressionMap);
         relationIdAttribute.mapToProperty = mapToProperty;
         relationIdAttribute.relationName = relationName;
         if (typeof aliasNameOrOptions === "string")
@@ -284,34 +339,13 @@ export class SelectQueryBuilder extends QueryBuilder {
         }
         return this;
     }
-    /**
-     * Counts number of entities of entity's relation and maps the value into some entity's property.
-     * Optionally, you can add condition and parameters used in condition.
-     */
-    loadRelationCountAndMap(mapToProperty, relationName, aliasName, queryBuilderFactory) {
-        const relationCountAttribute = new RelationCountAttribute(this.expressionMap);
-        relationCountAttribute.mapToProperty = mapToProperty;
-        relationCountAttribute.relationName = relationName;
-        relationCountAttribute.alias = aliasName;
-        relationCountAttribute.queryBuilderFactory = queryBuilderFactory;
-        this.expressionMap.relationCountAttributes.push(relationCountAttribute);
-        this.expressionMap.createAlias({
-            type: "other",
-            name: relationCountAttribute.junctionAlias,
-        });
-        if (relationCountAttribute.relation.junctionEntityMetadata) {
-            this.expressionMap.createAlias({
-                type: "other",
-                name: relationCountAttribute.junctionAlias,
-                metadata: relationCountAttribute.relation.junctionEntityMetadata,
-            });
-        }
-        return this;
-    }
     /**
      * Loads all relation ids for all relations of the selected entity.
      * All relation ids will be mapped to relation property themself.
      * If array of strings is given then loads only relation ids of the given properties.
+     * @param options
+     * @param options.relations
+     * @param options.disableMixedMap
      */
     loadAllRelationIds(options) {
         // todo: add skip relations
@@ -333,6 +367,8 @@ export class SelectQueryBuilder extends QueryBuilder {
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      * Additionally you can add parameters used in where expression.
+     * @param where
+     * @param parameters
      */
     where(where, parameters) {
         this.expressionMap.wheres = []; // don't move this block below since computeWhereParameter can add where expressions
@@ -349,6 +385,8 @@ export class SelectQueryBuilder extends QueryBuilder {
     /**
      * Adds new AND WHERE condition in the query builder.
      * Additionally you can add parameters used in where expression.
+     * @param where
+     * @param parameters
      */
     andWhere(where, parameters) {
         this.expressionMap.wheres.push({
@@ -362,6 +400,8 @@ export class SelectQueryBuilder extends QueryBuilder {
     /**
      * Adds new OR WHERE condition in the query builder.
      * Additionally you can add parameters used in where expression.
+     * @param where
+     * @param parameters
      */
     orWhere(where, parameters) {
         this.expressionMap.wheres.push({
@@ -374,18 +414,21 @@ export class SelectQueryBuilder extends QueryBuilder {
     }
     /**
      * Sets a new where EXISTS clause
+     * @param subQuery
      */
     whereExists(subQuery) {
         return this.where(...this.getExistsCondition(subQuery));
     }
     /**
      * Adds a new AND where EXISTS clause
+     * @param subQuery
      */
     andWhereExists(subQuery) {
         return this.andWhere(...this.getExistsCondition(subQuery));
     }
     /**
      * Adds a new OR where EXISTS clause
+     * @param subQuery
      */
     orWhereExists(subQuery) {
         return this.orWhere(...this.getExistsCondition(subQuery));
@@ -397,6 +440,7 @@ export class SelectQueryBuilder extends QueryBuilder {
      * It means if you have single primary key you can pass a simple id values, for example [1, 2, 3].
      * If you have multiple primary keys you need to pass object with property names and values specified,
      * for example [{ firstId: 1, secondId: 2 }, { firstId: 2, secondId: 3 }, ...]
+     * @param ids
      */
     whereInIds(ids) {
         return this.where(this.getWhereInIdsCondition(ids));
@@ -408,6 +452,7 @@ export class SelectQueryBuilder extends QueryBuilder {
      * It means if you have single primary key you can pass a simple id values, for example [1, 2, 3].
      * If you have multiple primary keys you need to pass object with property names and values specified,
      * for example [{ firstId: 1, secondId: 2 }, { firstId: 2, secondId: 3 }, ...]
+     * @param ids
      */
     andWhereInIds(ids) {
         return this.andWhere(this.getWhereInIdsCondition(ids));
@@ -419,6 +464,7 @@ export class SelectQueryBuilder extends QueryBuilder {
      * It means if you have single primary key you can pass a simple id values, for example [1, 2, 3].
      * If you have multiple primary keys you need to pass object with property names and values specified,
      * for example [{ firstId: 1, secondId: 2 }, { firstId: 2, secondId: 3 }, ...]
+     * @param ids
      */
     orWhereInIds(ids) {
         return this.orWhere(this.getWhereInIdsCondition(ids));
@@ -428,6 +474,8 @@ export class SelectQueryBuilder extends QueryBuilder {
      * If you had previously HAVING expression defined,
      * calling this function will override previously set HAVING conditions.
      * Additionally you can add parameters used in where expression.
+     * @param having
+     * @param parameters
      */
     having(having, parameters) {
         this.expressionMap.havings.push({ type: "simple", condition: having });
@@ -438,6 +486,8 @@ export class SelectQueryBuilder extends QueryBuilder {
     /**
      * Adds new AND HAVING condition in the query builder.
      * Additionally you can add parameters used in where expression.
+     * @param having
+     * @param parameters
      */
     andHaving(having, parameters) {
         this.expressionMap.havings.push({ type: "and", condition: having });
@@ -448,6 +498,8 @@ export class SelectQueryBuilder extends QueryBuilder {
     /**
      * Adds new OR HAVING condition in the query builder.
      * Additionally you can add parameters used in where expression.
+     * @param having
+     * @param parameters
      */
     orHaving(having, parameters) {
         this.expressionMap.havings.push({ type: "or", condition: having });
@@ -459,6 +511,7 @@ export class SelectQueryBuilder extends QueryBuilder {
      * Sets GROUP BY condition in the query builder.
      * If you had previously GROUP BY expression defined,
      * calling this function will override previously set GROUP BY conditions.
+     * @param groupBy
      */
     groupBy(groupBy) {
         if (groupBy) {
@@ -471,6 +524,7 @@ export class SelectQueryBuilder extends QueryBuilder {
     }
     /**
      * Adds GROUP BY condition in the query builder.
+     * @param groupBy
      */
     addGroupBy(groupBy) {
         this.expressionMap.groupBys.push(groupBy);
@@ -478,9 +532,10 @@ export class SelectQueryBuilder extends QueryBuilder {
     }
     /**
      * Enables time travelling for the current query (only supported by cockroach currently)
+     * @param timeTravelFn
      */
     timeTravelQuery(timeTravelFn) {
-        if (this.connection.driver.options.type === "cockroachdb") {
+        if (this.dataSource.driver.options.type === "cockroachdb") {
             if (timeTravelFn === undefined) {
                 this.expressionMap.timeTravel = "follower_read_timestamp()";
             }
@@ -494,14 +549,17 @@ export class SelectQueryBuilder extends QueryBuilder {
      * Sets ORDER BY condition in the query builder.
      * If you had previously ORDER BY expression defined,
      * calling this function will override previously set ORDER BY conditions.
+     * @param sort
+     * @param order
+     * @param nulls
      */
     orderBy(sort, order = "ASC", nulls) {
         if (order !== undefined && order !== "ASC" && order !== "DESC")
-            throw new TypeORMError(`SelectQueryBuilder.addOrderBy "order" can accept only "ASC" and "DESC" values.`);
+            throw new error_1.TypeORMError(`SelectQueryBuilder.addOrderBy "order" can accept only "ASC" and "DESC" values.`);
         if (nulls !== undefined &&
             nulls !== "NULLS FIRST" &&
             nulls !== "NULLS LAST")
-            throw new TypeORMError(`SelectQueryBuilder.addOrderBy "nulls" can accept only "NULLS FIRST" and "NULLS LAST" values.`);
+            throw new error_1.TypeORMError(`SelectQueryBuilder.addOrderBy "nulls" can accept only "NULLS FIRST" and "NULLS LAST" values.`);
         if (sort) {
             if (typeof sort === "object") {
                 this.expressionMap.orderBys = sort;
@@ -524,14 +582,17 @@ export class SelectQueryBuilder extends QueryBuilder {
     }
     /**
      * Adds ORDER BY condition in the query builder.
+     * @param sort
+     * @param order
+     * @param nulls
      */
     addOrderBy(sort, order = "ASC", nulls) {
         if (order !== undefined && order !== "ASC" && order !== "DESC")
-            throw new TypeORMError(`SelectQueryBuilder.addOrderBy "order" can accept only "ASC" and "DESC" values.`);
+            throw new error_1.TypeORMError(`SelectQueryBuilder.addOrderBy "order" can accept only "ASC" and "DESC" values.`);
         if (nulls !== undefined &&
             nulls !== "NULLS FIRST" &&
             nulls !== "NULLS LAST")
-            throw new TypeORMError(`SelectQueryBuilder.addOrderBy "nulls" can accept only "NULLS FIRST" and "NULLS LAST" values.`);
+            throw new error_1.TypeORMError(`SelectQueryBuilder.addOrderBy "nulls" can accept only "NULLS FIRST" and "NULLS LAST" values.`);
         if (nulls) {
             this.expressionMap.orderBys[sort] = { order, nulls };
         }
@@ -542,53 +603,54 @@ export class SelectQueryBuilder extends QueryBuilder {
     }
     /**
      * Sets LIMIT - maximum number of rows to be selected.
-     * NOTE that it may not work as you expect if you are using joins.
-     * If you want to implement pagination, and you are having join in your query,
-     * then use the take method instead.
+     * When joins are present, a two-query distinct-id strategy is used
+     * so that LIMIT applies to root entities rather than raw joined rows.
+     * @param limit
      */
     limit(limit) {
         this.expressionMap.limit = this.normalizeNumber(limit);
         if (this.expressionMap.limit !== undefined &&
             isNaN(this.expressionMap.limit))
-            throw new TypeORMError(`Provided "limit" value is not a number. Please provide a numeric value.`);
+            throw new error_1.TypeORMError(`Provided "limit" value is not a number. Please provide a numeric value.`);
         return this;
     }
     /**
      * Sets OFFSET - selection offset.
-     * NOTE that it may not work as you expect if you are using joins.
-     * If you want to implement pagination, and you are having join in your query,
-     * then use the skip method instead.
+     * When joins are present, a two-query distinct-id strategy is used
+     * so that OFFSET applies to root entities rather than raw joined rows.
+     * @param offset
      */
     offset(offset) {
         this.expressionMap.offset = this.normalizeNumber(offset);
         if (this.expressionMap.offset !== undefined &&
             isNaN(this.expressionMap.offset))
-            throw new TypeORMError(`Provided "offset" value is not a number. Please provide a numeric value.`);
+            throw new error_1.TypeORMError(`Provided "offset" value is not a number. Please provide a numeric value.`);
         return this;
     }
     /**
      * Sets maximal number of entities to take.
+     * @param take
      */
     take(take) {
         this.expressionMap.take = this.normalizeNumber(take);
         if (this.expressionMap.take !== undefined &&
             isNaN(this.expressionMap.take))
-            throw new TypeORMError(`Provided "take" value is not a number. Please provide a numeric value.`);
+            throw new error_1.TypeORMError(`Provided "take" value is not a number. Please provide a numeric value.`);
         return this;
     }
     /**
      * Sets number of entities to skip.
+     * @param skip
      */
     skip(skip) {
         this.expressionMap.skip = this.normalizeNumber(skip);
         if (this.expressionMap.skip !== undefined &&
             isNaN(this.expressionMap.skip))
-            throw new TypeORMError(`Provided "skip" value is not a number. Please provide a numeric value.`);
+            throw new error_1.TypeORMError(`Provided "skip" value is not a number. Please provide a numeric value.`);
         return this;
     }
     /**
      * Set certain index to be used by the query.
-     *
      * @param index Name of index to be used.
      */
     useIndex(index) {
@@ -597,6 +659,9 @@ export class SelectQueryBuilder extends QueryBuilder {
     }
     /**
      * Sets locking mode.
+     * @param lockMode
+     * @param lockVersion
+     * @param lockTables
      */
     setLock(lockMode, lockVersion, lockTables) {
         this.expressionMap.lockMode = lockMode;
@@ -606,6 +671,7 @@ export class SelectQueryBuilder extends QueryBuilder {
     }
     /**
      * Sets lock handling by adding NO WAIT or SKIP LOCKED.
+     * @param onLocked
      */
     setOnLocked(onLocked) {
         this.expressionMap.onLocked = onLocked;
@@ -629,7 +695,7 @@ export class SelectQueryBuilder extends QueryBuilder {
      */
     async getRawMany() {
         if (this.expressionMap.lockMode === "optimistic")
-            throw new OptimisticLockCanNotBeUsedError();
+            throw new OptimisticLockCanNotBeUsedError_1.OptimisticLockCanNotBeUsedError();
         this.expressionMap.queryEntity = false;
         const queryRunner = this.obtainQueryRunner();
         let transactionStartedByUs = false;
@@ -715,12 +781,12 @@ export class SelectQueryBuilder extends QueryBuilder {
                 const actualVersion = metadata.updateDateColumn.getEntityValue(result); // what if columns arent set?
                 if (actualVersion.getTime() !==
                     this.expressionMap.lockVersion.getTime())
-                    throw new OptimisticLockVersionMismatchError(metadata.name, this.expressionMap.lockVersion, actualVersion);
+                    throw new OptimisticLockVersionMismatchError_1.OptimisticLockVersionMismatchError(metadata.name, this.expressionMap.lockVersion, actualVersion);
             }
             else {
                 const actualVersion = metadata.versionColumn.getEntityValue(result); // what if columns arent set?
                 if (actualVersion !== this.expressionMap.lockVersion)
-                    throw new OptimisticLockVersionMismatchError(metadata.name, this.expressionMap.lockVersion, actualVersion);
+                    throw new OptimisticLockVersionMismatchError_1.OptimisticLockVersionMismatchError(metadata.name, this.expressionMap.lockVersion, actualVersion);
             }
         }
         if (result === undefined) {
@@ -734,7 +800,7 @@ export class SelectQueryBuilder extends QueryBuilder {
     async getOneOrFail() {
         const entity = await this.getOne();
         if (!entity) {
-            throw new EntityNotFoundError(this.expressionMap.mainAlias.target, this.expressionMap.parameters);
+            throw new EntityNotFoundError_1.EntityNotFoundError(this.expressionMap.mainAlias.target, this.expressionMap.parameters);
         }
         return entity;
     }
@@ -743,7 +809,7 @@ export class SelectQueryBuilder extends QueryBuilder {
      */
     async getMany() {
         if (this.expressionMap.lockMode === "optimistic")
-            throw new OptimisticLockCanNotBeUsedError();
+            throw new OptimisticLockCanNotBeUsedError_1.OptimisticLockCanNotBeUsedError();
         const results = await this.getRawAndEntities();
         return results.entities;
     }
@@ -753,7 +819,7 @@ export class SelectQueryBuilder extends QueryBuilder {
      */
     async getCount() {
         if (this.expressionMap.lockMode === "optimistic")
-            throw new OptimisticLockCanNotBeUsedError();
+            throw new OptimisticLockCanNotBeUsedError_1.OptimisticLockCanNotBeUsedError();
         const queryRunner = this.obtainQueryRunner();
         let transactionStartedByUs = false;
         try {
@@ -793,7 +859,7 @@ export class SelectQueryBuilder extends QueryBuilder {
      */
     async getExists() {
         if (this.expressionMap.lockMode === "optimistic")
-            throw new OptimisticLockCanNotBeUsedError();
+            throw new OptimisticLockCanNotBeUsedError_1.OptimisticLockCanNotBeUsedError();
         const queryRunner = this.obtainQueryRunner();
         let transactionStartedByUs = false;
         try {
@@ -833,7 +899,7 @@ export class SelectQueryBuilder extends QueryBuilder {
      */
     async getManyAndCount() {
         if (this.expressionMap.lockMode === "optimistic")
-            throw new OptimisticLockCanNotBeUsedError();
+            throw new OptimisticLockCanNotBeUsedError_1.OptimisticLockCanNotBeUsedError();
         const queryRunner = this.obtainQueryRunner();
         let transactionStartedByUs = false;
         try {
@@ -958,6 +1024,8 @@ export class SelectQueryBuilder extends QueryBuilder {
     }
     /**
      * Enables or disables query result caching.
+     * @param enabledOrMillisecondsOrId
+     * @param maybeMilliseconds
      */
     cache(enabledOrMillisecondsOrId, maybeMilliseconds) {
         if (typeof enabledOrMillisecondsOrId === "boolean") {
@@ -979,6 +1047,7 @@ export class SelectQueryBuilder extends QueryBuilder {
     }
     /**
      * Sets extra options that can be used to configure how query builder works.
+     * @param option
      */
     setOption(option) {
         this.expressionMap.options.push(option);
@@ -991,7 +1060,7 @@ export class SelectQueryBuilder extends QueryBuilder {
         if (parameters) {
             this.setParameters(parameters);
         }
-        const joinAttribute = new JoinAttribute(this.connection, this.expressionMap);
+        const joinAttribute = new JoinAttribute_1.JoinAttribute(this.dataSource, this.expressionMap);
         joinAttribute.direction = direction;
         joinAttribute.mapAsEntity = mapAsEntity;
         joinAttribute.mapToProperty = mapToProperty;
@@ -1000,6 +1069,22 @@ export class SelectQueryBuilder extends QueryBuilder {
         joinAttribute.condition = condition; // joinInverseSideCondition
         // joinAttribute.junctionAlias = joinAttribute.relation.isOwning ? parentAlias + "_" + destinationTableAlias : destinationTableAlias + "_" + parentAlias;
         this.expressionMap.joinAttributes.push(joinAttribute);
+        const isEntity = this.dataSource.hasMetadata(entityOrProperty);
+        const isSubQuery = (!isEntity && typeof entityOrProperty === "function") ||
+            (typeof entityOrProperty === "string" &&
+                entityOrProperty.startsWith("(") &&
+                entityOrProperty.endsWith(")"));
+        let subQuery = "";
+        if (isSubQuery) {
+            if (typeof entityOrProperty === "string") {
+                subQuery = entityOrProperty;
+            }
+            else {
+                const subQueryBuilder = entityOrProperty(this.subQuery());
+                this.setParameters(subQueryBuilder.getParameters());
+                subQuery = subQueryBuilder.getQuery();
+            }
+        }
         const joinAttributeMetadata = joinAttribute.metadata;
         if (joinAttributeMetadata) {
             if (joinAttributeMetadata.deleteDateColumn &&
@@ -1014,6 +1099,7 @@ export class SelectQueryBuilder extends QueryBuilder {
                 type: "join",
                 name: aliasName,
                 metadata: joinAttributeMetadata,
+                subQuery: isSubQuery ? subQuery : undefined,
             });
             if (joinAttribute.relation &&
                 joinAttribute.relation.junctionEntityMetadata) {
@@ -1025,18 +1111,6 @@ export class SelectQueryBuilder extends QueryBuilder {
             }
         }
         else {
-            let subQuery = "";
-            if (typeof entityOrProperty === "function") {
-                const subQueryBuilder = entityOrProperty(this.subQuery());
-                this.setParameters(subQueryBuilder.getParameters());
-                subQuery = subQueryBuilder.getQuery();
-            }
-            else {
-                subQuery = entityOrProperty;
-            }
-            const isSubQuery = typeof entityOrProperty === "function" ||
-                (entityOrProperty.substr(0, 1) === "(" &&
-                    entityOrProperty.substr(-1) === ")");
             joinAttribute.alias = this.expressionMap.createAlias({
                 type: "join",
                 name: aliasName,
@@ -1052,7 +1126,7 @@ export class SelectQueryBuilder extends QueryBuilder {
      */
     createSelectExpression() {
         if (!this.expressionMap.mainAlias)
-            throw new TypeORMError("Cannot build query because main alias is not set (call qb#from method)");
+            throw new error_1.TypeORMError("Cannot build query because main alias is not set (call qb#from method)");
         // todo throw exception if selects or from is missing
         const allSelects = [];
         const excludedSelects = [];
@@ -1082,7 +1156,7 @@ export class SelectQueryBuilder extends QueryBuilder {
         this.expressionMap.selects
             .filter((select) => excludedSelects.indexOf(select) === -1)
             .forEach((select) => allSelects.push({
-            selection: this.replacePropertyNames(select.selection),
+            selection: select.selection,
             aliasName: select.aliasName,
         }));
         // if still selection is empty, then simply set it to all (*)
@@ -1091,7 +1165,7 @@ export class SelectQueryBuilder extends QueryBuilder {
         // Use certain index
         let useIndex = "";
         if (this.expressionMap.useIndex) {
-            if (DriverUtils.isMySQLFamily(this.connection.driver)) {
+            if (DriverUtils_1.DriverUtils.isMySQLFamily(this.dataSource.driver)) {
                 useIndex = ` USE INDEX (${this.expressionMap.useIndex})`;
             }
         }
@@ -1125,18 +1199,16 @@ export class SelectQueryBuilder extends QueryBuilder {
      */
     createSelectDistinctExpression() {
         const { selectDistinct, selectDistinctOn, maxExecutionTime } = this.expressionMap;
-        const { driver } = this.connection;
+        const { driver } = this.dataSource;
         let select = "SELECT ";
         if (maxExecutionTime > 0) {
-            if (DriverUtils.isMySQLFamily(driver)) {
+            if (DriverUtils_1.DriverUtils.isMySQLFamily(driver)) {
                 select += `/*+ MAX_EXECUTION_TIME(${this.expressionMap.maxExecutionTime}) */ `;
             }
         }
-        if (DriverUtils.isPostgresFamily(driver) &&
+        if (DriverUtils_1.DriverUtils.isPostgresFamily(driver) &&
             selectDistinctOn.length > 0) {
-            const selectDistinctOnMap = selectDistinctOn
-                .map((on) => this.replacePropertyNames(on))
-                .join(", ");
+            const selectDistinctOnMap = selectDistinctOn.join(", ");
             select = `SELECT DISTINCT ON (${selectDistinctOnMap}) `;
         }
         else if (selectDistinct) {
@@ -1176,9 +1248,7 @@ export class SelectQueryBuilder extends QueryBuilder {
                     " " +
                     this.escape(destinationTableAlias) +
                     this.createTableLockExpression() +
-                    (joinAttr.condition
-                        ? " ON " + this.replacePropertyNames(joinAttr.condition)
-                        : ""));
+                    (joinAttr.condition ? " ON " + joinAttr.condition : ""));
             }
             // if real entity relation is involved
             if (relation.isManyToOne || relation.isOneToOneOwner) {
@@ -1204,7 +1274,8 @@ export class SelectQueryBuilder extends QueryBuilder {
                     this.escape(destinationTableAlias) +
                     this.createTableLockExpression() +
                     " ON " +
-                    this.replacePropertyNames(condition + appendedCondition));
+                    condition +
+                    appendedCondition);
             }
             else if (relation.isOneToMany || relation.isOneToOneNotOwner) {
                 // JOIN `post` `post` ON `post`.`categoryId` = `category`.`id`
@@ -1236,7 +1307,7 @@ export class SelectQueryBuilder extends QueryBuilder {
                 })
                     .join(" AND ");
                 if (!condition)
-                    throw new TypeORMError(`Relation ${relation.entityMetadata.name}.${relation.propertyName} does not have join columns.`);
+                    throw new error_1.TypeORMError(`Relation ${relation.entityMetadata.name}.${relation.propertyName} does not have join columns.`);
                 return (" " +
                     joinAttr.direction +
                     " JOIN " +
@@ -1245,13 +1316,14 @@ export class SelectQueryBuilder extends QueryBuilder {
                     this.escape(destinationTableAlias) +
                     this.createTableLockExpression() +
                     " ON " +
-                    this.replacePropertyNames(condition + appendedCondition));
+                    condition +
+                    appendedCondition);
             }
             else {
                 // means many-to-many
                 const junctionTableName = relation.junctionEntityMetadata.tablePath;
                 const junctionAlias = joinAttr.junctionAlias;
-                let junctionCondition = "", destinationCondition = "";
+                let junctionCondition, destinationCondition;
                 if (relation.isOwning) {
                     junctionCondition = relation.joinColumns
                         .map((joinColumn) => {
@@ -1312,7 +1384,7 @@ export class SelectQueryBuilder extends QueryBuilder {
                     this.escape(junctionAlias) +
                     this.createTableLockExpression() +
                     " ON " +
-                    this.replacePropertyNames(junctionCondition) +
+                    junctionCondition +
                     " " +
                     joinAttr.direction +
                     " JOIN " +
@@ -1321,7 +1393,8 @@ export class SelectQueryBuilder extends QueryBuilder {
                     this.escape(destinationTableAlias) +
                     this.createTableLockExpression() +
                     " ON " +
-                    this.replacePropertyNames(destinationCondition + appendedCondition));
+                    destinationCondition +
+                    appendedCondition);
             }
         });
         return joins.join(" ");
@@ -1332,8 +1405,7 @@ export class SelectQueryBuilder extends QueryBuilder {
     createGroupByExpression() {
         if (!this.expressionMap.groupBys || !this.expressionMap.groupBys.length)
             return "";
-        return (" GROUP BY " +
-            this.replacePropertyNames(this.expressionMap.groupBys.join(", ")));
+        return " GROUP BY " + this.expressionMap.groupBys.join(", ");
     }
     /**
      * Creates "ORDER BY" part of SQL query.
@@ -1350,6 +1422,10 @@ export class SelectQueryBuilder extends QueryBuilder {
                     : orderBys[columnName].order +
                         " " +
                         orderBys[columnName].nulls;
+                const selectionByAlias = this.expressionMap.selects.find((s) => s.aliasName === columnName);
+                if (selectionByAlias) {
+                    return this.escape(columnName) + " " + orderValue;
+                }
                 const selection = this.expressionMap.selects.find((s) => s.selection === columnName);
                 if (selection &&
                     !selection.aliasName &&
@@ -1358,15 +1434,15 @@ export class SelectQueryBuilder extends QueryBuilder {
                     const aliasName = criteriaParts[0];
                     const propertyPath = criteriaParts.slice(1).join(".");
                     const alias = this.expressionMap.aliases.find((alias) => alias.name === aliasName);
-                    if (alias) {
+                    if (alias?.hasMetadata) {
                         const column = alias.metadata.findColumnWithPropertyPath(propertyPath);
                         if (column) {
-                            const orderAlias = DriverUtils.buildAlias(this.connection.driver, undefined, aliasName, column.databaseName);
+                            const orderAlias = DriverUtils_1.DriverUtils.buildAlias(this.dataSource.driver, undefined, aliasName, column.databaseName);
                             return (this.escape(orderAlias) + " " + orderValue);
                         }
                     }
                 }
-                return (this.replacePropertyNames(columnName) + " " + orderValue);
+                return columnName + " " + orderValue;
             })
                 .join(", "));
     }
@@ -1386,7 +1462,7 @@ export class SelectQueryBuilder extends QueryBuilder {
         // Helper functions to check if values are set (including 0)
         const hasLimit = limit !== undefined && limit !== null;
         const hasOffset = offset !== undefined && offset !== null;
-        if (this.connection.driver.options.type === "mssql") {
+        if (this.dataSource.driver.options.type === "mssql") {
             // Due to a limitation in SQL Server's parser implementation it does not support using
             // OFFSET or FETCH NEXT without an ORDER BY clause being provided. In cases where the
             // user does not request one we insert a dummy ORDER BY that does nothing and should
@@ -1409,18 +1485,18 @@ export class SelectQueryBuilder extends QueryBuilder {
             if (hasOffset)
                 return prefix + " OFFSET " + offset + " ROWS";
         }
-        else if (DriverUtils.isMySQLFamily(this.connection.driver) ||
-            this.connection.driver.options.type === "aurora-mysql" ||
-            this.connection.driver.options.type === "sap" ||
-            this.connection.driver.options.type === "spanner") {
+        else if (DriverUtils_1.DriverUtils.isMySQLFamily(this.dataSource.driver) ||
+            this.dataSource.driver.options.type === "aurora-mysql" ||
+            this.dataSource.driver.options.type === "sap" ||
+            this.dataSource.driver.options.type === "spanner") {
             if (hasLimit && hasOffset)
                 return " LIMIT " + limit + " OFFSET " + offset;
             if (hasLimit)
                 return " LIMIT " + limit;
             if (hasOffset)
-                throw new OffsetWithoutLimitNotSupportedError();
+                throw new OffsetWithoutLimitNotSupportedError_1.OffsetWithoutLimitNotSupportedError();
         }
-        else if (DriverUtils.isSQLiteFamily(this.connection.driver)) {
+        else if (DriverUtils_1.DriverUtils.isSQLiteFamily(this.dataSource.driver)) {
             if (hasLimit && hasOffset)
                 return " LIMIT " + limit + " OFFSET " + offset;
             if (hasLimit)
@@ -1428,7 +1504,7 @@ export class SelectQueryBuilder extends QueryBuilder {
             if (hasOffset)
                 return " LIMIT -1 OFFSET " + offset;
         }
-        else if (this.connection.driver.options.type === "oracle") {
+        else if (this.dataSource.driver.options.type === "oracle") {
             if (hasLimit && hasOffset)
                 return (" OFFSET " +
                     offset +
@@ -1459,7 +1535,7 @@ export class SelectQueryBuilder extends QueryBuilder {
      *      ON U.ID=O.OrderID
      */
     createTableLockExpression() {
-        if (this.connection.driver.options.type === "mssql") {
+        if (this.dataSource.driver.options.type === "mssql") {
             switch (this.expressionMap.lockMode) {
                 case "pessimistic_read":
                     return " WITH (HOLDLOCK, ROWLOCK)";
@@ -1472,18 +1548,17 @@ export class SelectQueryBuilder extends QueryBuilder {
         return "";
     }
     /**
-     * Creates "LOCK" part of SQL query.
+     * @returns "LOCK" part of SQL query
      */
     createLockExpression() {
-        const driver = this.connection.driver;
+        const driver = this.dataSource.driver;
         let lockTablesClause = "";
         if (this.expressionMap.lockTables) {
-            if (!(DriverUtils.isPostgresFamily(driver) ||
-                driver.options.type === "cockroachdb")) {
-                throw new TypeORMError("Lock tables not supported in selected driver");
+            if (!DriverUtils_1.DriverUtils.isPostgresFamily(driver)) {
+                throw new error_1.TypeORMError("Lock tables not supported in selected driver");
             }
             if (this.expressionMap.lockTables.length < 1) {
-                throw new TypeORMError("lockTables cannot be an empty array");
+                throw new error_1.TypeORMError("lockTables cannot be an empty array");
             }
             lockTablesClause = " OF " + this.expressionMap.lockTables.join(", ");
         }
@@ -1492,13 +1567,18 @@ export class SelectQueryBuilder extends QueryBuilder {
             onLockExpression = " NOWAIT";
         }
         else if (this.expressionMap.onLocked === "skip_locked") {
-            onLockExpression = " SKIP LOCKED";
+            if (driver.options.type === "sap") {
+                onLockExpression = " IGNORE LOCKED";
+            }
+            else {
+                onLockExpression = " SKIP LOCKED";
+            }
         }
         switch (this.expressionMap.lockMode) {
             case "pessimistic_read":
                 if (driver.options.type === "mysql" ||
                     driver.options.type === "aurora-mysql") {
-                    if (DriverUtils.isReleaseVersionOrGreater(driver, "8.0.0")) {
+                    if (DriverUtils_1.DriverUtils.isReleaseVersionOrGreater(driver, "8.0.0")) {
                         return (" FOR SHARE" + lockTablesClause + onLockExpression);
                     }
                     else {
@@ -1508,9 +1588,12 @@ export class SelectQueryBuilder extends QueryBuilder {
                 else if (driver.options.type === "mariadb") {
                     return " LOCK IN SHARE MODE";
                 }
-                else if (DriverUtils.isPostgresFamily(driver)) {
+                else if (DriverUtils_1.DriverUtils.isPostgresFamily(driver)) {
                     return " FOR SHARE" + lockTablesClause + onLockExpression;
                 }
+                else if (driver.options.type === "sap") {
+                    return (" FOR SHARE LOCK" + lockTablesClause + onLockExpression);
+                }
                 else if (driver.options.type === "oracle") {
                     return " FOR UPDATE";
                 }
@@ -1518,61 +1601,39 @@ export class SelectQueryBuilder extends QueryBuilder {
                     return "";
                 }
                 else {
-                    throw new LockNotSupportedOnGivenDriverError();
+                    throw new LockNotSupportedOnGivenDriverError_1.LockNotSupportedOnGivenDriverError();
                 }
             case "pessimistic_write":
-                if (DriverUtils.isMySQLFamily(driver) ||
+                if (DriverUtils_1.DriverUtils.isMySQLFamily(driver) ||
                     driver.options.type === "aurora-mysql" ||
                     driver.options.type === "oracle") {
                     return " FOR UPDATE" + onLockExpression;
                 }
-                else if (DriverUtils.isPostgresFamily(driver) ||
-                    driver.options.type === "cockroachdb") {
+                else if (DriverUtils_1.DriverUtils.isPostgresFamily(driver) ||
+                    driver.options.type === "sap") {
                     return " FOR UPDATE" + lockTablesClause + onLockExpression;
                 }
                 else if (driver.options.type === "mssql") {
                     return "";
                 }
                 else {
-                    throw new LockNotSupportedOnGivenDriverError();
-                }
-            case "pessimistic_partial_write":
-                if (DriverUtils.isPostgresFamily(driver)) {
-                    return " FOR UPDATE" + lockTablesClause + " SKIP LOCKED";
-                }
-                else if (DriverUtils.isMySQLFamily(driver)) {
-                    return " FOR UPDATE SKIP LOCKED";
-                }
-                else {
-                    throw new LockNotSupportedOnGivenDriverError();
-                }
-            case "pessimistic_write_or_fail":
-                if (DriverUtils.isPostgresFamily(driver) ||
-                    driver.options.type === "cockroachdb") {
-                    return " FOR UPDATE" + lockTablesClause + " NOWAIT";
-                }
-                else if (DriverUtils.isMySQLFamily(driver)) {
-                    return " FOR UPDATE NOWAIT";
-                }
-                else {
-                    throw new LockNotSupportedOnGivenDriverError();
+                    throw new LockNotSupportedOnGivenDriverError_1.LockNotSupportedOnGivenDriverError();
                 }
             case "for_no_key_update":
-                if (DriverUtils.isPostgresFamily(driver) ||
-                    driver.options.type === "cockroachdb") {
+                if (DriverUtils_1.DriverUtils.isPostgresFamily(driver)) {
                     return (" FOR NO KEY UPDATE" +
                         lockTablesClause +
                         onLockExpression);
                 }
                 else {
-                    throw new LockNotSupportedOnGivenDriverError();
+                    throw new LockNotSupportedOnGivenDriverError_1.LockNotSupportedOnGivenDriverError();
                 }
             case "for_key_share":
-                if (DriverUtils.isPostgresFamily(driver)) {
+                if (DriverUtils_1.DriverUtils.isPostgresFamily(driver)) {
                     return (" FOR KEY SHARE" + lockTablesClause + onLockExpression);
                 }
                 else {
-                    throw new LockNotSupportedOnGivenDriverError();
+                    throw new LockNotSupportedOnGivenDriverError_1.LockNotSupportedOnGivenDriverError();
                 }
             default:
                 return "";
@@ -1588,13 +1649,11 @@ export class SelectQueryBuilder extends QueryBuilder {
             .map((having, index) => {
             switch (having.type) {
                 case "and":
-                    return ((index > 0 ? "AND " : "") +
-                        this.replacePropertyNames(having.condition));
+                    return (index > 0 ? "AND " : "") + having.condition;
                 case "or":
-                    return ((index > 0 ? "OR " : "") +
-                        this.replacePropertyNames(having.condition));
+                    return (index > 0 ? "OR " : "") + having.condition;
                 default:
-                    return this.replacePropertyNames(having.condition);
+                    return having.condition;
             }
         })
             .join(" ");
@@ -1608,10 +1667,13 @@ export class SelectQueryBuilder extends QueryBuilder {
         if (hasMainAlias) {
             columns.push(...metadata.columns.filter((column) => column.isSelect === true));
         }
-        columns.push(...metadata.columns.filter((column) => {
-            return this.expressionMap.selects.some((select) => select.selection ===
-                aliasName + "." + column.propertyPath);
-        }));
+        const columnsMap = new Map(metadata.columns.map((col) => [
+            `${aliasName}.${col.propertyPath}`,
+            col,
+        ]));
+        columns.push(...this.expressionMap.selects
+            .map((select) => columnsMap.get(select.selection))
+            .filter((col) => !!col));
         // if user used partial selection and did not select some primary columns which are required to be selected
         // we select those primary columns and mark them as "virtual". Later virtual column values will be removed from final entity
         // to make entity contain exactly what user selected
@@ -1629,14 +1691,17 @@ export class SelectQueryBuilder extends QueryBuilder {
             if (column.isVirtualProperty && column.query) {
                 selectionPath = `(${column.query(escapedAliasName)})`;
             }
-            if (this.connection.driver.spatialTypes.indexOf(column.type) !== -1) {
-                if (DriverUtils.isMySQLFamily(this.connection.driver) ||
-                    this.connection.driver.options.type === "aurora-mysql") {
-                    const useLegacy = this.connection.driver.options.legacySpatialSupport;
+            if (DriverUtils_1.DriverUtils.isSQLiteFamily(this.dataSource.driver)) {
+                selectionPath = this.dataSource.driver.wrapWithJsonFunction(selectionPath, column, false);
+            }
+            if (this.dataSource.driver.spatialTypes.indexOf(column.type) !== -1) {
+                if (DriverUtils_1.DriverUtils.isMySQLFamily(this.dataSource.driver) ||
+                    this.dataSource.driver.options.type === "aurora-mysql") {
+                    const useLegacy = this.dataSource.driver.options.legacySpatialSupport;
                     const asText = useLegacy ? "AsText" : "ST_AsText";
                     selectionPath = `${asText}(${selectionPath})`;
                 }
-                if (DriverUtils.isPostgresFamily(this.connection.driver))
+                if (DriverUtils_1.DriverUtils.isPostgresFamily(this.dataSource.driver))
                     if (column.precision) {
                         // cast to JSON to trigger parsing in the driver
                         selectionPath = `ST_AsGeoJSON(${selectionPath}, ${column.precision})::json`;
@@ -1644,7 +1709,7 @@ export class SelectQueryBuilder extends QueryBuilder {
                     else {
                         selectionPath = `ST_AsGeoJSON(${selectionPath})::json`;
                     }
-                if (this.connection.driver.options.type === "mssql")
+                if (this.dataSource.driver.options.type === "mssql")
                     selectionPath = `${selectionPath}.ToString()`;
             }
             const selections = this.expressionMap.selects.filter((select) => select.selection === aliasName + "." + column.propertyPath);
@@ -1654,7 +1719,7 @@ export class SelectQueryBuilder extends QueryBuilder {
                         selection: selectionPath,
                         aliasName: selection.aliasName
                             ? selection.aliasName
-                            : DriverUtils.buildAlias(this.connection.driver, undefined, aliasName, column.databaseName),
+                            : DriverUtils_1.DriverUtils.buildAlias(this.dataSource.driver, undefined, aliasName, column.databaseName),
                         // todo: need to keep in mind that custom selection.aliasName breaks hydrator. fix it later!
                         virtual: selection.virtual,
                     });
@@ -1663,7 +1728,7 @@ export class SelectQueryBuilder extends QueryBuilder {
             else {
                 finalSelects.push({
                     selection: selectionPath,
-                    aliasName: DriverUtils.buildAlias(this.connection.driver, undefined, aliasName, column.databaseName),
+                    aliasName: DriverUtils_1.DriverUtils.buildAlias(this.dataSource.driver, undefined, aliasName, column.databaseName),
                     // todo: need to keep in mind that custom selection.aliasName breaks hydrator. fix it later!
                     virtual: hasMainAlias,
                 });
@@ -1684,13 +1749,12 @@ export class SelectQueryBuilder extends QueryBuilder {
         // If we aren't doing anything that will create a join, we can use a simpler `COUNT` instead
         // so we prevent poor query patterns in the most likely cases
         if (this.expressionMap.joinAttributes.length === 0 &&
-            this.expressionMap.relationIdAttributes.length === 0 &&
-            this.expressionMap.relationCountAttributes.length === 0) {
+            this.expressionMap.relationIdAttributes.length === 0) {
             return "COUNT(1)";
         }
         // For everything else, we'll need to do some hackery to get the correct count values.
-        if (this.connection.driver.options.type === "cockroachdb" ||
-            DriverUtils.isPostgresFamily(this.connection.driver)) {
+        if (this.dataSource.driver.options.type === "cockroachdb" ||
+            DriverUtils_1.DriverUtils.isPostgresFamily(this.dataSource.driver)) {
             // Postgres and CockroachDB can pass multiple parameters to the `DISTINCT` function
             // https://www.postgresql.org/docs/9.5/sql-select.html#SQL-DISTINCT
             return ("COUNT(DISTINCT(" +
@@ -1699,7 +1763,7 @@ export class SelectQueryBuilder extends QueryBuilder {
                     .join(", ") +
                 "))");
         }
-        if (DriverUtils.isMySQLFamily(this.connection.driver)) {
+        if (DriverUtils_1.DriverUtils.isMySQLFamily(this.dataSource.driver)) {
             // MySQL & MariaDB can pass multiple parameters to the `DISTINCT` language construct
             // https://mariadb.com/kb/en/count-distinct/
             return ("COUNT(DISTINCT " +
@@ -1708,7 +1772,7 @@ export class SelectQueryBuilder extends QueryBuilder {
                     .join(", ") +
                 ")");
         }
-        if (this.connection.driver.options.type === "mssql") {
+        if (this.dataSource.driver.options.type === "mssql") {
             // SQL Server has gotta be different from everyone else.  They don't support
             // distinct counting multiple columns & they don't have the same operator
             // characteristic for concatenating, so we gotta use the `CONCAT` function.
@@ -1721,7 +1785,7 @@ export class SelectQueryBuilder extends QueryBuilder {
             }
             return `COUNT(DISTINCT(CONCAT(${columnsExpression})))`;
         }
-        if (this.connection.driver.options.type === "spanner") {
+        if (this.dataSource.driver.options.type === "spanner") {
             // spanner also has gotta be different from everyone else.
             // they do not support concatenation of different column types without casting them to string
             if (primaryColumns.length === 1) {
@@ -1760,7 +1824,7 @@ export class SelectQueryBuilder extends QueryBuilder {
         return parseInt(results[0]["cnt"]);
     }
     async executeExistsQuery(queryRunner) {
-        const results = await this.connection
+        const results = await this.dataSource
             .createQueryBuilder()
             .fromDummy()
             .select("1", "row_exists")
@@ -1784,28 +1848,17 @@ export class SelectQueryBuilder extends QueryBuilder {
                 this.withDeleted();
             }
             if (this.findOptions.select) {
-                const select = Array.isArray(this.findOptions.select)
-                    ? OrmUtils.propertyPathsToTruthyObject(this.findOptions.select)
-                    : this.findOptions.select;
-                this.buildSelect(select, this.expressionMap.mainAlias.metadata, this.expressionMap.mainAlias.name);
+                this.buildSelect(this.findOptions.select, this.expressionMap.mainAlias.metadata, this.expressionMap.mainAlias.name);
             }
             if (this.selects.length) {
                 this.select(this.selects);
             }
             this.selects = [];
             if (this.findOptions.relations) {
-                const relations = Array.isArray(this.findOptions.relations)
-                    ? OrmUtils.propertyPathsToTruthyObject(this.findOptions.relations)
-                    : this.findOptions.relations;
-                this.buildRelations(relations, typeof this.findOptions.select === "object"
-                    ? this.findOptions.select
-                    : undefined, this.expressionMap.mainAlias.metadata, this.expressionMap.mainAlias.name);
+                this.buildRelations(this.findOptions.relations, this.findOptions.select, this.expressionMap.mainAlias.metadata, this.expressionMap.mainAlias.name);
                 if (this.findOptions.loadEagerRelations !== false &&
                     this.expressionMap.relationLoadStrategy === "join") {
-                    this.buildEagerRelations(relations, typeof this.findOptions.select === "object"
-                        ? this.findOptions
-                            .select
-                        : undefined, this.expressionMap.mainAlias.metadata, this.expressionMap.mainAlias.name);
+                    this.buildEagerRelations(this.findOptions.relations, this.findOptions.select, this.expressionMap.mainAlias.metadata, this.expressionMap.mainAlias.name);
                 }
             }
             if (this.selects.length) {
@@ -1814,9 +1867,9 @@ export class SelectQueryBuilder extends QueryBuilder {
             if (this.findOptions.where) {
                 this.conditions = this.buildWhere(this.findOptions.where, this.expressionMap.mainAlias.metadata, this.expressionMap.mainAlias.name);
                 if (this.conditions.length)
-                    this.andWhere(this.conditions.substr(0, 1) !== "("
-                        ? "(" + this.conditions + ")"
-                        : this.conditions); // temporary and where and braces
+                    this.andWhere(this.conditions.startsWith("(")
+                        ? this.conditions
+                        : `(${this.conditions})`); // temporary and where and braces
             }
             if (this.findOptions.order) {
                 this.buildOrder(this.findOptions.order, this.expressionMap.mainAlias.metadata, this.expressionMap.mainAlias.name);
@@ -1884,24 +1937,6 @@ export class SelectQueryBuilder extends QueryBuilder {
             else if (typeof this.findOptions.cache === "object") {
                 this.cache(this.findOptions.cache.id, this.findOptions.cache.milliseconds);
             }
-            if (this.findOptions.join) {
-                if (this.findOptions.join.leftJoin)
-                    Object.keys(this.findOptions.join.leftJoin).forEach((key) => {
-                        this.leftJoin(this.findOptions.join.leftJoin[key], key);
-                    });
-                if (this.findOptions.join.innerJoin)
-                    Object.keys(this.findOptions.join.innerJoin).forEach((key) => {
-                        this.innerJoin(this.findOptions.join.innerJoin[key], key);
-                    });
-                if (this.findOptions.join.leftJoinAndSelect)
-                    Object.keys(this.findOptions.join.leftJoinAndSelect).forEach((key) => {
-                        this.leftJoinAndSelect(this.findOptions.join.leftJoinAndSelect[key], key);
-                    });
-                if (this.findOptions.join.innerJoinAndSelect)
-                    Object.keys(this.findOptions.join.innerJoinAndSelect).forEach((key) => {
-                        this.innerJoinAndSelect(this.findOptions.join.innerJoinAndSelect[key], key);
-                    });
-            }
             if (this.findOptions.lock) {
                 if (this.findOptions.lock.mode === "optimistic") {
                     this.setLock(this.findOptions.lock.mode, this.findOptions.lock.version);
@@ -1909,10 +1944,6 @@ export class SelectQueryBuilder extends QueryBuilder {
                 else if (this.findOptions.lock.mode === "pessimistic_read" ||
                     this.findOptions.lock.mode === "pessimistic_write" ||
                     this.findOptions.lock.mode === "dirty_read" ||
-                    this.findOptions.lock.mode ===
-                        "pessimistic_partial_write" ||
-                    this.findOptions.lock.mode ===
-                        "pessimistic_write_or_fail" ||
                     this.findOptions.lock.mode === "for_no_key_update" ||
                     this.findOptions.lock.mode === "for_key_share") {
                     const tableNames = this.findOptions.lock.tables
@@ -1922,7 +1953,7 @@ export class SelectQueryBuilder extends QueryBuilder {
                                     .tableNameWithoutPrefix === table);
                             });
                             if (!tableAlias) {
-                                throw new TypeORMError(`"${table}" is not part of this query`);
+                                throw new error_1.TypeORMError(`"${table}" is not part of this query`);
                             }
                             return this.escape(tableAlias.name);
                         })
@@ -1939,8 +1970,14 @@ export class SelectQueryBuilder extends QueryBuilder {
             else if (typeof this.findOptions.loadRelationIds === "object") {
                 this.loadAllRelationIds(this.findOptions.loadRelationIds);
             }
-            if (this.findOptions.loadEagerRelations !== false) {
-                FindOptionsUtils.joinEagerRelations(this, this.expressionMap.mainAlias.name, this.expressionMap.mainAlias.metadata);
+            if (this.findOptions.loadEagerRelations !== false &&
+                this.expressionMap.mainAlias) {
+                if (this.expressionMap.relationLoadStrategy === "join") {
+                    FindOptionsUtils_1.FindOptionsUtils.joinEagerRelations(this, this.expressionMap.mainAlias.name, this.expressionMap.mainAlias.metadata);
+                }
+                else if (this.expressionMap.relationLoadStrategy === "query") {
+                    this.concatRelationMetadata(...this.expressionMap.mainAlias.metadata.eagerRelations);
+                }
             }
             if (this.findOptions.transaction === true) {
                 this.expressionMap.useTransaction = true;
@@ -1960,40 +1997,46 @@ export class SelectQueryBuilder extends QueryBuilder {
             // }
         }
     }
-    concatRelationMetadata(relationMetadata) {
-        this.relationMetadatas.push(relationMetadata);
+    /**
+     * Registers relation metadata for loading via separate queries when using
+     * the "query" relation load strategy. Duplicates (by propertyPath) are
+     * silently skipped.
+     * @param relationMetadata - one or more relation metadata entries to register
+     */
+    concatRelationMetadata(...relationMetadata) {
+        const newRelationMetadata = relationMetadata.filter((metadata) => !this.relationMetadatas.some((existentMetadata) => existentMetadata.propertyPath === metadata.propertyPath));
+        this.relationMetadatas.push(...newRelationMetadata);
     }
     /**
      * Executes sql generated by query builder and returns object with raw results and entities created from them.
+     * @param queryRunner
      */
     async executeEntitiesAndRawResults(queryRunner) {
         if (!this.expressionMap.mainAlias)
-            throw new TypeORMError(`Alias is not set. Use "from" method to set an alias.`);
+            throw new error_1.TypeORMError(`Alias is not set. Use "from" method to set an alias.`);
         if ((this.expressionMap.lockMode === "pessimistic_read" ||
             this.expressionMap.lockMode === "pessimistic_write" ||
-            this.expressionMap.lockMode === "pessimistic_partial_write" ||
-            this.expressionMap.lockMode === "pessimistic_write_or_fail" ||
             this.expressionMap.lockMode === "for_no_key_update" ||
             this.expressionMap.lockMode === "for_key_share") &&
             !queryRunner.isTransactionActive)
-            throw new PessimisticLockTransactionRequiredError();
+            throw new PessimisticLockTransactionRequiredError_1.PessimisticLockTransactionRequiredError();
         if (this.expressionMap.lockMode === "optimistic") {
             const metadata = this.expressionMap.mainAlias.metadata;
             if (!metadata.versionColumn && !metadata.updateDateColumn)
-                throw new NoVersionOrUpdateDateColumnError(metadata.name);
+                throw new NoVersionOrUpdateDateColumnError_1.NoVersionOrUpdateDateColumnError(metadata.name);
         }
-        const relationIdLoader = new RelationIdLoader(this.connection, queryRunner, this.expressionMap.relationIdAttributes);
-        const relationCountLoader = new RelationCountLoader(this.connection, queryRunner, this.expressionMap.relationCountAttributes);
-        const relationIdMetadataTransformer = new RelationIdMetadataToAttributeTransformer(this.expressionMap);
+        const relationIdLoader = new RelationIdLoader_1.RelationIdLoader(this.dataSource, queryRunner, this.expressionMap.relationIdAttributes);
+        const relationIdMetadataTransformer = new RelationIdMetadataToAttributeTransformer_1.RelationIdMetadataToAttributeTransformer(this.expressionMap);
         relationIdMetadataTransformer.transform();
-        const relationCountMetadataTransformer = new RelationCountMetadataToAttributeTransformer(this.expressionMap);
-        relationCountMetadataTransformer.transform();
-        let rawResults = [], entities = [];
+        let rawResults, entities = [];
         // for pagination enabled (e.g. skip and take) its much more complicated - its a special process
         // where we make two queries to find the data we need
         // first query find ids in skip and take range
         // and second query loads the actual data in given ids range
-        if ((this.expressionMap.skip || this.expressionMap.take) &&
+        if ((this.expressionMap.skip ||
+            this.expressionMap.take ||
+            this.expressionMap.offset ||
+            this.expressionMap.limit) &&
             this.expressionMap.joinAttributes.length > 0) {
             // we are skipping order by here because its not working in subqueries anyway
             // to make order by working we need to apply it on a distinct query
@@ -2002,17 +2045,20 @@ export class SelectQueryBuilder extends QueryBuilder {
             const mainAliasName = this.expressionMap.mainAlias.name;
             const querySelects = metadata.primaryColumns.map((primaryColumn) => {
                 const distinctAlias = this.escape("distinctAlias");
-                const columnAlias = this.escape(DriverUtils.buildAlias(this.connection.driver, undefined, mainAliasName, primaryColumn.databaseName));
+                const columnAlias = this.escape(DriverUtils_1.DriverUtils.buildAlias(this.dataSource.driver, undefined, mainAliasName, primaryColumn.databaseName));
                 if (!orderBys[columnAlias])
                     // make sure we aren't overriding user-defined order in inverse direction
                     orderBys[columnAlias] = "ASC";
-                const alias = DriverUtils.buildAlias(this.connection.driver, undefined, "ids_" + mainAliasName, primaryColumn.databaseName);
+                const alias = DriverUtils_1.DriverUtils.buildAlias(this.dataSource.driver, undefined, "ids_" + mainAliasName, primaryColumn.databaseName);
                 return `${distinctAlias}.${columnAlias} AS ${this.escape(alias)}`;
             });
             const originalQuery = this.clone();
+            // clear limit/offset from the inner query since pagination is handled by the outer distinct query
+            originalQuery.expressionMap.limit = undefined;
+            originalQuery.expressionMap.offset = undefined;
             // preserve original timeTravel value since we set it to "false" in subquery
             const originalQueryTimeTravel = originalQuery.expressionMap.timeTravel;
-            rawResults = await new SelectQueryBuilder(this.connection, queryRunner)
+            const paginationQueryBuilder = new SelectQueryBuilder(this.dataSource, queryRunner)
                 .select(`DISTINCT ${querySelects.join(", ")}`)
                 .addSelect(selects)
                 .from(`(${originalQuery
@@ -2020,17 +2066,16 @@ export class SelectQueryBuilder extends QueryBuilder {
                 .timeTravelQuery(false) // set it to "false" since time travel clause must appear at the very end and applies to the entire SELECT clause.
                 .getQuery()})`, "distinctAlias")
                 .timeTravelQuery(originalQueryTimeTravel)
-                .offset(this.expressionMap.skip)
-                .limit(this.expressionMap.take)
+                .offset(this.expressionMap.skip ?? this.expressionMap.offset)
+                .limit(this.expressionMap.take ?? this.expressionMap.limit)
                 .orderBy(orderBys)
                 .cache(this.expressionMap.cache && this.expressionMap.cacheId
                 ? `${this.expressionMap.cacheId}-pagination`
                 : this.expressionMap.cache, this.expressionMap.cacheDuration)
-                .setParameters(this.getParameters())
-                .setNativeParameters(this.expressionMap.nativeParameters)
-                .getRawMany();
+                .setParameters(this.getParameters());
+            rawResults = await paginationQueryBuilder.getRawMany();
             if (rawResults.length > 0) {
-                let condition = "";
+                let condition;
                 const parameters = {};
                 if (metadata.hasMultiplePrimaryKeys) {
                     condition = rawResults
@@ -2038,7 +2083,7 @@ export class SelectQueryBuilder extends QueryBuilder {
                         return metadata.primaryColumns
                             .map((primaryColumn) => {
                             const paramKey = `orm_distinct_ids_${index}_${primaryColumn.databaseName}`;
-                            const paramKeyResult = DriverUtils.buildAlias(this.connection.driver, undefined, "ids_" + mainAliasName, primaryColumn.databaseName);
+                            const paramKeyResult = DriverUtils_1.DriverUtils.buildAlias(this.dataSource.driver, undefined, "ids_" + mainAliasName, primaryColumn.databaseName);
                             parameters[paramKey] =
                                 result[paramKeyResult];
                             return `${mainAliasName}.${primaryColumn.propertyPath}=:${paramKey}`;
@@ -2048,7 +2093,7 @@ export class SelectQueryBuilder extends QueryBuilder {
                         .join(" OR ");
                 }
                 else {
-                    const alias = DriverUtils.buildAlias(this.connection.driver, undefined, "ids_" + mainAliasName, metadata.primaryColumns[0].databaseName);
+                    const alias = DriverUtils_1.DriverUtils.buildAlias(this.dataSource.driver, undefined, "ids_" + mainAliasName, metadata.primaryColumns[0].databaseName);
                     const ids = rawResults.map((result) => result[alias]);
                     const areAllNumbers = ids.every((id) => typeof id === "number");
                     if (areAllNumbers) {
@@ -2064,12 +2109,14 @@ export class SelectQueryBuilder extends QueryBuilder {
                                 " IN (:...orm_distinct_ids)";
                     }
                 }
-                rawResults = await this.clone()
+                const secondQuery = this.clone()
                     .mergeExpressionMap({
                     extraAppendedAndWhereCondition: condition,
                 })
-                    .setParameters(parameters)
-                    .loadRawResults(queryRunner);
+                    .setParameters(parameters);
+                secondQuery.expressionMap.limit = undefined;
+                secondQuery.expressionMap.offset = undefined;
+                rawResults = await secondQuery.loadRawResults(queryRunner);
             }
         }
         else {
@@ -2078,8 +2125,7 @@ export class SelectQueryBuilder extends QueryBuilder {
         if (rawResults.length > 0) {
             // transform raw results into entities
             const rawRelationIdResults = await relationIdLoader.load(rawResults);
-            const rawRelationCountResults = await relationCountLoader.load(rawResults);
-            const transformer = new RawSqlResultsToEntityTransformer(this.expressionMap, this.connection.driver, rawRelationIdResults, rawRelationCountResults, this.queryRunner);
+            const transformer = new RawSqlResultsToEntityTransformer_1.RawSqlResultsToEntityTransformer(this.expressionMap, this.dataSource.driver, rawRelationIdResults, this.queryRunner);
             entities = transformer.transform(rawResults, this.expressionMap.mainAlias);
             // broadcast all "after load" events
             if (this.expressionMap.callListeners === true &&
@@ -2088,31 +2134,40 @@ export class SelectQueryBuilder extends QueryBuilder {
             }
         }
         if (this.expressionMap.relationLoadStrategy === "query") {
-            const queryStrategyRelationIdLoader = new QueryStrategyRelationIdLoader(this.connection, queryRunner);
+            const queryStrategyRelationIdLoader = new RelationIdLoader_2.RelationIdLoader(this.dataSource, queryRunner, this.findOptions.loadEagerRelations);
             await Promise.all(this.relationMetadatas.map(async (relation) => {
+                // Prevent infinite recursion from circular eager
+                // chains (e.g. A→B→C→A). Each branch maintains its
+                // own visited set so parallel branches don't interfere.
+                if (relation.isEager) {
+                    const targetEntity = relation.inverseEntityMetadata.name;
+                    if (this.eagerLoadChain.has(targetEntity))
+                        return;
+                }
                 const relationTarget = relation.inverseEntityMetadata.target;
                 const relationAlias = relation.inverseEntityMetadata.targetName;
-                const select = Array.isArray(this.findOptions.select)
-                    ? OrmUtils.propertyPathsToTruthyObject(this.findOptions.select)
-                    : this.findOptions.select;
-                const relations = Array.isArray(this.findOptions.relations)
-                    ? OrmUtils.propertyPathsToTruthyObject(this.findOptions.relations)
-                    : this.findOptions.relations;
                 const queryBuilder = this.createQueryBuilder(queryRunner)
                     .select(relationAlias)
-                    .from(relationTarget, relationAlias)
-                    .setFindOptions({
-                    select: select
-                        ? OrmUtils.deepValue(select, relation.propertyPath)
+                    .from(relationTarget, relationAlias);
+                // Propagate eager load chain with current entity
+                // added, so the child detects cycles in its branch
+                if (relation.isEager) {
+                    queryBuilder.eagerLoadChain = new Set(this.eagerLoadChain);
+                    queryBuilder.eagerLoadChain.add(relation.entityMetadata.name);
+                }
+                queryBuilder.setFindOptions({
+                    select: this.findOptions.select
+                        ? OrmUtils_1.OrmUtils.deepValue(this.findOptions.select, relation.propertyPath)
                         : undefined,
                     order: this.findOptions.order
-                        ? OrmUtils.deepValue(this.findOptions.order, relation.propertyPath)
+                        ? OrmUtils_1.OrmUtils.deepValue(this.findOptions.order, relation.propertyPath)
                         : undefined,
-                    relations: relations
-                        ? OrmUtils.deepValue(relations, relation.propertyPath)
+                    relations: this.findOptions.relations
+                        ? OrmUtils_1.OrmUtils.deepValue(this.findOptions.relations, relation.propertyPath)
                         : undefined,
                     withDeleted: this.findOptions.withDeleted,
                     relationLoadStrategy: this.findOptions.relationLoadStrategy,
+                    loadEagerRelations: this.findOptions.loadEagerRelations,
                 });
                 if (entities.length > 0) {
                     const relatedEntityGroups = await queryStrategyRelationIdLoader.loadManyToManyRelationIdsAndGroup(relation, entities, undefined, queryBuilder);
@@ -2143,10 +2198,14 @@ export class SelectQueryBuilder extends QueryBuilder {
                 const aliasName = criteriaParts[0];
                 const propertyPath = criteriaParts.slice(1).join(".");
                 const alias = this.expressionMap.findAliasByName(aliasName);
-                const column = alias.metadata.findColumnWithPropertyPath(propertyPath);
+                const column = alias.metadata.findColumnWithPropertyPath(propertyPath) ??
+                    alias.metadata.findColumnWithDatabaseName(propertyPath);
+                const databaseName = column
+                    ? column.databaseName
+                    : propertyPath;
                 return (this.escape(parentAlias) +
                     "." +
-                    this.escape(DriverUtils.buildAlias(this.connection.driver, undefined, aliasName, column.databaseName)));
+                    this.escape(DriverUtils_1.DriverUtils.buildAlias(this.dataSource.driver, undefined, aliasName, databaseName)));
             }
             else {
                 if (this.expressionMap.selects.find((select) => select.selection === orderCriteria ||
@@ -2165,10 +2224,12 @@ export class SelectQueryBuilder extends QueryBuilder {
                 const aliasName = criteriaParts[0];
                 const propertyPath = criteriaParts.slice(1).join(".");
                 const alias = this.expressionMap.findAliasByName(aliasName);
-                const column = alias.metadata.findColumnWithPropertyPath(propertyPath);
+                const column = alias.metadata.findColumnWithPropertyPath(propertyPath) ??
+                    alias.metadata.findColumnWithDatabaseName(propertyPath);
+                const databaseName = column ? column.databaseName : propertyPath;
                 orderByObject[this.escape(parentAlias) +
                     "." +
-                    this.escape(DriverUtils.buildAlias(this.connection.driver, undefined, aliasName, column.databaseName))] = orderBys[orderCriteria];
+                    this.escape(DriverUtils_1.DriverUtils.buildAlias(this.dataSource.driver, undefined, aliasName, databaseName))] = orderBys[orderCriteria];
             }
             else {
                 if (this.expressionMap.selects.find((select) => select.selection === orderCriteria ||
@@ -2186,14 +2247,15 @@ export class SelectQueryBuilder extends QueryBuilder {
     }
     /**
      * Loads raw results from the database.
+     * @param queryRunner
      */
     async loadRawResults(queryRunner) {
         const [sql, parameters] = this.getQueryAndParameters();
         const queryId = sql +
             " -- PARAMETERS: " +
             JSON.stringify(parameters, (_, value) => typeof value === "bigint" ? value.toString() : value);
-        const cacheOptions = typeof this.connection.options.cache === "object"
-            ? this.connection.options.cache
+        const cacheOptions = typeof this.dataSource.options.cache === "object"
+            ? this.dataSource.options.cache
             : {};
         let savedQueryResultCacheOptions = undefined;
         const isCachingEnabled = 
@@ -2203,10 +2265,10 @@ export class SelectQueryBuilder extends QueryBuilder {
             // ...or it's enabled locally explicitly.
             this.expressionMap.cache === true;
         let cacheError = false;
-        if (this.connection.queryResultCache && isCachingEnabled) {
+        if (this.dataSource.queryResultCache && isCachingEnabled) {
             try {
                 savedQueryResultCacheOptions =
-                    await this.connection.queryResultCache.getFromCache({
+                    await this.dataSource.queryResultCache.getFromCache({
                         identifier: this.expressionMap.cacheId,
                         query: queryId,
                         duration: this.expressionMap.cacheDuration ||
@@ -2214,7 +2276,7 @@ export class SelectQueryBuilder extends QueryBuilder {
                             1000,
                     }, queryRunner);
                 if (savedQueryResultCacheOptions &&
-                    !this.connection.queryResultCache.isExpired(savedQueryResultCacheOptions)) {
+                    !this.dataSource.queryResultCache.isExpired(savedQueryResultCacheOptions)) {
                     return JSON.parse(savedQueryResultCacheOptions.result);
                 }
             }
@@ -2227,10 +2289,10 @@ export class SelectQueryBuilder extends QueryBuilder {
         }
         const results = await queryRunner.query(sql, parameters, true);
         if (!cacheError &&
-            this.connection.queryResultCache &&
+            this.dataSource.queryResultCache &&
             isCachingEnabled) {
             try {
-                await this.connection.queryResultCache.storeInCache({
+                await this.dataSource.queryResultCache.storeInCache({
                     identifier: this.expressionMap.cacheId,
                     query: queryId,
                     time: Date.now(),
@@ -2250,13 +2312,15 @@ export class SelectQueryBuilder extends QueryBuilder {
     }
     /**
      * Merges into expression map given expression map properties.
+     * @param expressionMap
      */
     mergeExpressionMap(expressionMap) {
-        ObjectUtils.assign(this.expressionMap, expressionMap);
+        ObjectUtils_1.ObjectUtils.assign(this.expressionMap, expressionMap);
         return this;
     }
     /**
      * Normalizes a give number - converts to int if possible.
+     * @param num
      */
     normalizeNumber(num) {
         if (typeof num === "number" || num === undefined || num === null)
@@ -2268,7 +2332,7 @@ export class SelectQueryBuilder extends QueryBuilder {
      */
     obtainQueryRunner() {
         return (this.queryRunner ||
-            this.connection.createQueryRunner(this.connection.defaultReplicationModeForReads()));
+            this.dataSource.createQueryRunner(this.dataSource.defaultReplicationModeForReads()));
     }
     buildSelect(select, metadata, alias, embedPrefix) {
         for (const key in select) {
@@ -2279,7 +2343,7 @@ export class SelectQueryBuilder extends QueryBuilder {
             const embed = metadata.findEmbeddedWithPropertyPath(propertyPath);
             const relation = metadata.findRelationWithPropertyPath(propertyPath);
             if (!embed && !column && !relation)
-                throw new EntityPropertyNotFoundError(propertyPath, metadata);
+                throw new EntityPropertyNotFoundError_1.EntityPropertyNotFoundError(propertyPath, metadata);
             if (column) {
                 this.selects.push(alias + "." + propertyPath);
                 // this.addSelect(alias + "." + propertyPath);
@@ -2302,7 +2366,10 @@ export class SelectQueryBuilder extends QueryBuilder {
             }
         }
     }
-    buildRelations(relations, selection, metadata, alias, embedPrefix) {
+    getRelationJoinType(relation, parentJoinType = "inner") {
+        return FindOptionsUtils_1.FindOptionsUtils.getRelationJoinType(relation, this.expressionMap.withDeleted, parentJoinType);
+    }
+    buildRelations(relations, selection, metadata, alias, embedPrefix, parentJoinType = "inner") {
         if (!relations)
             return;
         Object.keys(relations).forEach((relationName) => {
@@ -2313,24 +2380,24 @@ export class SelectQueryBuilder extends QueryBuilder {
             const embed = metadata.findEmbeddedWithPropertyPath(propertyPath);
             const relation = metadata.findRelationWithPropertyPath(propertyPath);
             if (!embed && !relation)
-                throw new EntityPropertyNotFoundError(propertyPath, metadata);
+                throw new EntityPropertyNotFoundError_1.EntityPropertyNotFoundError(propertyPath, metadata);
             if (embed) {
                 this.buildRelations(relationValue, typeof selection === "object"
-                    ? OrmUtils.deepValue(selection, embed.propertyPath)
+                    ? OrmUtils_1.OrmUtils.deepValue(selection, embed.propertyPath)
                     : undefined, metadata, alias, propertyPath);
             }
             else if (relation) {
                 let joinAlias = alias + "_" + propertyPath.replace(".", "_");
-                joinAlias = DriverUtils.buildAlias(this.connection.driver, { joiner: "__" }, alias, joinAlias);
+                joinAlias = DriverUtils_1.DriverUtils.buildAlias(this.dataSource.driver, { joiner: "__" }, alias, joinAlias);
+                const joinType = this.getRelationJoinType(relation, parentJoinType);
                 if (relationValue === true ||
                     typeof relationValue === "object") {
                     if (this.expressionMap.relationLoadStrategy === "query") {
                         this.concatRelationMetadata(relation);
                     }
                     else {
-                        // join
                         this.joins.push({
-                            type: "left",
+                            type: joinType,
                             select: true,
                             selection: selection &&
                                 typeof selection[relationName] === "object"
@@ -2349,8 +2416,8 @@ export class SelectQueryBuilder extends QueryBuilder {
                 if (typeof relationValue === "object" &&
                     this.expressionMap.relationLoadStrategy === "join") {
                     this.buildRelations(relationValue, typeof selection === "object"
-                        ? OrmUtils.deepValue(selection, relation.propertyPath)
-                        : undefined, relation.inverseEntityMetadata, joinAlias, undefined);
+                        ? OrmUtils_1.OrmUtils.deepValue(selection, relation.propertyPath)
+                        : undefined, relation.inverseEntityMetadata, joinAlias, undefined, joinType);
                 }
             }
         });
@@ -2366,26 +2433,30 @@ export class SelectQueryBuilder extends QueryBuilder {
             const embed = metadata.findEmbeddedWithPropertyPath(propertyPath);
             const relation = metadata.findRelationWithPropertyPath(propertyPath);
             if (!embed && !relation)
-                throw new EntityPropertyNotFoundError(propertyPath, metadata);
+                throw new EntityPropertyNotFoundError_1.EntityPropertyNotFoundError(propertyPath, metadata);
             if (embed) {
                 this.buildEagerRelations(relationValue, typeof selection === "object"
-                    ? OrmUtils.deepValue(selection, embed.propertyPath)
+                    ? OrmUtils_1.OrmUtils.deepValue(selection, embed.propertyPath)
                     : undefined, metadata, alias, propertyPath);
             }
             else if (relation) {
                 let joinAlias = alias + "_" + propertyPath.replace(".", "_");
-                joinAlias = DriverUtils.buildAlias(this.connection.driver, { joiner: "__" }, alias, joinAlias);
-                if (relationValue === true ||
-                    typeof relationValue === "object") {
+                joinAlias = DriverUtils_1.DriverUtils.buildAlias(this.dataSource.driver, { joiner: "__" }, alias, joinAlias);
+                if ((relationValue === true ||
+                    typeof relationValue === "object") &&
+                    this.expressionMap.relationLoadStrategy === "join") {
+                    // Determine this relation's join type to propagate to eager children
+                    const parentJoin = this.joins.find((j) => j.alias === joinAlias);
+                    const parentJoinType = parentJoin?.type ?? "inner";
                     relation.inverseEntityMetadata.eagerRelations.forEach((eagerRelation) => {
                         let eagerRelationJoinAlias = joinAlias +
                             "_" +
                             eagerRelation.propertyPath.replace(".", "_");
-                        eagerRelationJoinAlias = DriverUtils.buildAlias(this.connection.driver, { joiner: "__" }, joinAlias, eagerRelationJoinAlias);
+                        eagerRelationJoinAlias = DriverUtils_1.DriverUtils.buildAlias(this.dataSource.driver, { joiner: "__" }, joinAlias, eagerRelationJoinAlias);
                         const existJoin = this.joins.find((join) => join.alias === eagerRelationJoinAlias);
                         if (!existJoin) {
                             this.joins.push({
-                                type: "left",
+                                type: this.getRelationJoinType(eagerRelation, parentJoinType),
                                 select: true,
                                 alias: eagerRelationJoinAlias,
                                 parentAlias: joinAlias,
@@ -2401,7 +2472,7 @@ export class SelectQueryBuilder extends QueryBuilder {
                 }
                 if (typeof relationValue === "object") {
                     this.buildEagerRelations(relationValue, typeof selection === "object"
-                        ? OrmUtils.deepValue(selection, relation.propertyPath)
+                        ? OrmUtils_1.OrmUtils.deepValue(selection, relation.propertyPath)
                         : undefined, relation.inverseEntityMetadata, joinAlias, undefined);
                 }
             }
@@ -2416,7 +2487,7 @@ export class SelectQueryBuilder extends QueryBuilder {
             const embed = metadata.findEmbeddedWithPropertyPath(propertyPath);
             const relation = metadata.findRelationWithPropertyPath(propertyPath);
             if (!embed && !column && !relation)
-                throw new EntityPropertyNotFoundError(propertyPath, metadata);
+                throw new EntityPropertyNotFoundError_1.EntityPropertyNotFoundError(propertyPath, metadata);
             if (column) {
                 let direction = typeof order[key] === "object"
                     ? order[key].direction
@@ -2444,7 +2515,7 @@ export class SelectQueryBuilder extends QueryBuilder {
                 //     // this is not building correctly now???
                 //     aliasPath = this.escape(
                 //         DriverUtils.buildAlias(
-                //             this.connection.driver,
+                //             this.dataSource.driver,
                 //             undefined,
                 //             alias,
                 //             column.databaseName,
@@ -2465,14 +2536,15 @@ export class SelectQueryBuilder extends QueryBuilder {
             }
             else if (relation) {
                 let joinAlias = alias + "_" + propertyPath.replace(".", "_");
-                joinAlias = DriverUtils.buildAlias(this.connection.driver, { joiner: "__" }, alias, joinAlias);
-                // console.log("joinAlias", joinAlias, joinAlias.length, this.connection.driver.maxAliasLength)
+                joinAlias = DriverUtils_1.DriverUtils.buildAlias(this.dataSource.driver, { joiner: "__" }, alias, joinAlias);
+                // console.log("joinAlias", joinAlias, joinAlias.length, this.dataSource.driver.maxAliasLength)
                 // todo: use expressionMap.joinAttributes, and create a new one using
-                //  const joinAttribute = new JoinAttribute(this.connection, this.expressionMap);
+                //  const joinAttribute = new JoinAttribute(this.dataSource, this.expressionMap);
                 const existJoin = this.joins.find((join) => join.alias === joinAlias);
                 if (!existJoin) {
+                    const parentJoin = this.joins.find((j) => j.alias === alias);
                     this.joins.push({
-                        type: "left",
+                        type: this.getRelationJoinType(relation, parentJoin?.type ?? "inner"),
                         select: false,
                         alias: joinAlias,
                         parentAlias: alias,
@@ -2486,7 +2558,6 @@ export class SelectQueryBuilder extends QueryBuilder {
     }
     buildWhere(where, metadata, alias, embedPrefix) {
         let condition = "";
-        // let parameterIndex = Object.keys(this.expressionMap.nativeParameters).length;
         if (Array.isArray(where)) {
             if (where.length) {
                 condition = where
@@ -2507,25 +2578,25 @@ export class SelectQueryBuilder extends QueryBuilder {
                 const embed = metadata.findEmbeddedWithPropertyPath(propertyPath);
                 const relation = metadata.findRelationWithPropertyPath(propertyPath);
                 if (!embed && !column && !relation) {
-                    throw new EntityPropertyNotFoundError(propertyPath, metadata);
+                    throw new EntityPropertyNotFoundError_1.EntityPropertyNotFoundError(propertyPath, metadata);
                 }
                 if (parameterValue === undefined) {
-                    const undefinedBehavior = this.connection.options.invalidWhereValuesBehavior
-                        ?.undefined || "ignore";
+                    const undefinedBehavior = this.dataSource.options.invalidWhereValuesBehavior
+                        ?.undefined || "throw";
                     if (undefinedBehavior === "throw") {
-                        throw new TypeORMError(`Undefined value encountered in property '${alias}.${key}' of a where condition. ` +
+                        throw new error_1.TypeORMError(`Undefined value encountered in property '${alias}.${key}' of a where condition. ` +
                             `Set 'invalidWhereValuesBehavior.undefined' to 'ignore' in connection options to skip properties with undefined values.`);
                     }
                     continue;
                 }
                 if (parameterValue === null) {
-                    const nullBehavior = this.connection.options.invalidWhereValuesBehavior
-                        ?.null || "ignore";
+                    const nullBehavior = this.dataSource.options.invalidWhereValuesBehavior
+                        ?.null || "throw";
                     if (nullBehavior === "ignore") {
                         continue;
                     }
                     else if (nullBehavior === "throw") {
-                        throw new TypeORMError(`Null value encountered in property '${alias}.${key}' of a where condition. ` +
+                        throw new error_1.TypeORMError(`Null value encountered in property '${alias}.${key}' of a where condition. ` +
                             `To match with SQL NULL, the IsNull() operator must be used. ` +
                             `Set 'invalidWhereValuesBehavior.null' to 'ignore' or 'sql-null' in connection options to skip or handle null values.`);
                     }
@@ -2542,20 +2613,15 @@ export class SelectQueryBuilder extends QueryBuilder {
                     }
                     // const parameterName = alias + "_" + propertyPath.split(".").join("_") + "_" + parameterIndex;
                     // todo: we need to handle other operators as well?
-                    if (InstanceChecker.isEqualOperator(where[key])) {
+                    if (InstanceChecker_1.InstanceChecker.isEqualOperator(where[key])) {
                         parameterValue = where[key].value;
                     }
                     if (column.transformer) {
-                        if (parameterValue instanceof FindOperator) {
-                            parameterValue.transformValue(column.transformer);
-                        }
-                        else {
-                            parameterValue = ApplyValueTransformers.transformTo(column.transformer, parameterValue);
-                        }
+                        parameterValue = ApplyValueTransformers_1.ApplyValueTransformers.transformTo(column.transformer, parameterValue);
                     }
                     // MSSQL requires parameters to carry extra type information
-                    if (this.connection.driver.options.type === "mssql") {
-                        parameterValue = this.connection.driver.parametrizeValues(column, parameterValue);
+                    if (this.dataSource.driver.options.type === "mssql") {
+                        parameterValue = this.dataSource.driver.parametrizeValues(column, parameterValue);
                     }
                     andConditions.push(this.createWhereConditionExpression(this.getWherePredicateCondition(aliasPath, parameterValue)));
                     // this.conditions.push(`${alias}.${propertyPath} = :${paramName}`);
@@ -2568,13 +2634,13 @@ export class SelectQueryBuilder extends QueryBuilder {
                 }
                 else if (relation) {
                     if (where[key] === null) {
-                        const nullBehavior = this.connection.options.invalidWhereValuesBehavior
-                            ?.null || "ignore";
+                        const nullBehavior = this.dataSource.options.invalidWhereValuesBehavior
+                            ?.null || "throw";
                         if (nullBehavior === "sql-null") {
                             andConditions.push(`${alias}.${propertyPath} IS NULL`);
                         }
                         else if (nullBehavior === "throw") {
-                            throw new TypeORMError(`Null value encountered in property '${alias}.${key}' of a where condition. ` +
+                            throw new error_1.TypeORMError(`Null value encountered in property '${alias}.${key}' of a where condition. ` +
                                 `Set 'invalidWhereValuesBehavior.null' to 'ignore' or 'sql-null' in connection options to skip or handle null values.`);
                         }
                         // 'ignore' behavior falls through to continue
@@ -2583,12 +2649,25 @@ export class SelectQueryBuilder extends QueryBuilder {
                     // if all properties of where are undefined we don't need to join anything
                     // this can happen when user defines map with conditional queries inside
                     if (typeof where[key] === "object") {
-                        const allAllUndefined = Object.keys(where[key]).every((k) => where[key][k] === undefined);
-                        if (allAllUndefined) {
+                        const whereKeys = Object.keys(where[key]);
+                        // empty object — no predicates to apply, skip the join
+                        if (whereKeys.length === 0) {
+                            continue;
+                        }
+                        const allUndefined = whereKeys.every((k) => where[key][k] === undefined);
+                        if (allUndefined) {
+                            const undefinedBehavior = this.dataSource.options
+                                .invalidWhereValuesBehavior?.undefined ||
+                                "throw";
+                            if (undefinedBehavior === "throw") {
+                                throw new error_1.TypeORMError(`Undefined value encountered in nested relation '${alias}.${key}' of a where condition. ` +
+                                    `All properties of the nested object are undefined. ` +
+                                    `Set 'invalidWhereValuesBehavior.undefined' to 'ignore' in connection options to skip properties with undefined values.`);
+                            }
                             continue;
                         }
                     }
-                    if (InstanceChecker.isFindOperator(where[key])) {
+                    if (InstanceChecker_1.InstanceChecker.isFindOperator(where[key])) {
                         if (where[key].type === "moreThan" ||
                             where[key].type === "lessThan" ||
                             where[key].type === "moreThanOrEqual" ||
@@ -2623,7 +2702,8 @@ export class SelectQueryBuilder extends QueryBuilder {
                                     .from(relation.inverseRelation.joinTableName, relation.inverseRelation.joinTableName)
                                     .where(relation
                                     .inverseRelation.inverseJoinColumns.map((column) => {
-                                    return `${relation.inverseRelation
+                                    return `${relation
+                                        .inverseRelation
                                         .joinTableName}.${column.propertyName} = ${alias}.${column.referencedColumn
                                         .propertyName}`;
                                 })
@@ -2671,11 +2751,12 @@ export class SelectQueryBuilder extends QueryBuilder {
                         let joinAlias = alias +
                             "_" +
                             relation.propertyPath.replace(".", "_");
-                        joinAlias = DriverUtils.buildAlias(this.connection.driver, { joiner: "__" }, alias, joinAlias);
+                        joinAlias = DriverUtils_1.DriverUtils.buildAlias(this.dataSource.driver, { joiner: "__" }, alias, joinAlias);
                         const existJoin = this.joins.find((join) => join.alias === joinAlias);
                         if (!existJoin) {
+                            const parentJoin = this.joins.find((j) => j.alias === alias);
                             this.joins.push({
-                                type: "left",
+                                type: this.getRelationJoinType(relation, parentJoin?.type ?? "inner"),
                                 select: false,
                                 selection: undefined,
                                 alias: joinAlias,
@@ -2686,7 +2767,6 @@ export class SelectQueryBuilder extends QueryBuilder {
                         const condition = this.buildWhere(where[key], relation.inverseEntityMetadata, joinAlias);
                         if (condition) {
                             andConditions.push(condition);
-                            // parameterIndex = Object.keys(this.expressionMap.nativeParameters).length;
                         }
                     }
                 }
@@ -2698,5 +2778,5 @@ export class SelectQueryBuilder extends QueryBuilder {
         return condition.length ? "(" + condition + ")" : condition;
     }
 }
-
-//# sourceMappingURL=SelectQueryBuilder.js.map
+exports.SelectQueryBuilder = SelectQueryBuilder;
+//# sourceMappingURL=SelectQueryBuilder.js.map