typeorm 0.3.0-rc.9 → 0.3.0

package/browser/query-builder/QueryBuilder.js

@@ -1,13 +1,10 @@
-import * as tslib_1 from "tslib";
 import { QueryExpressionMap } from "./QueryExpressionMap";
 import { Brackets } from "./Brackets";
-import { EntityMetadata } from "../metadata/EntityMetadata";
-import { SqljsDriver } from "../driver/sqljs/SqljsDriver";
-import { SqlServerDriver } from "../driver/sqlserver/SqlServerDriver";
-import { OracleDriver } from "../driver/oracle/OracleDriver";
-import { EntitySchema } from "../";
 import { FindOperator } from "../find-options/FindOperator";
 import { In } from "../find-options/operator/In";
+import { TypeORMError } from "../error";
+import { EntityPropertyNotFoundError } from "../error/EntityPropertyNotFoundError";
+import { InstanceChecker } from "../util/InstanceChecker";
 // todo: completely cover query builder with tests
 // todo: entityOrProperty can be target name. implement proper behaviour if it is.
 // todo: check in persistment if id exist on object and throw exception (can be in partial selection?)
@@ -24,12 +21,17 @@ import { In } from "../find-options/operator/In";
 /**
  * Allows to build complex sql queries in a fashion way and execute those queries.
  */
-var QueryBuilder = /** @class */ (function () {
+export class QueryBuilder {
     /**
      * QueryBuilder can be initialized from given Connection and QueryRunner objects or from given other QueryBuilder.
      */
-    function QueryBuilder(connectionOrQueryBuilder, queryRunner) {
-        if (connectionOrQueryBuilder instanceof QueryBuilder) {
+    constructor(connectionOrQueryBuilder, queryRunner) {
+        this["@instanceof"] = Symbol.for("QueryBuilder");
+        /**
+         * Memo to help keep place of current parameter index for `createParameter`
+         */
+        this.parameterIndex = 0;
+        if (InstanceChecker.isQueryBuilder(connectionOrQueryBuilder)) {
             this.connection = connectionOrQueryBuilder.connection;
             this.queryRunner = connectionOrQueryBuilder.queryRunner;
             this.expressionMap = connectionOrQueryBuilder.expressionMap.clone();
@@ -40,284 +42,313 @@ var QueryBuilder = /** @class */ (function () {
             this.expressionMap = new QueryExpressionMap(this.connection);
         }
     }
-    Object.defineProperty(QueryBuilder.prototype, "alias", {
-        // -------------------------------------------------------------------------
-        // Accessors
-        // -------------------------------------------------------------------------
-        /**
-         * Gets the main alias string used in this query builder.
-         */
-        get: function () {
-            if (!this.expressionMap.mainAlias)
-                throw new Error("Main alias is not set"); // todo: better exception
-            return this.expressionMap.mainAlias.name;
-        },
-        enumerable: true,
-        configurable: true
-    });
+    // -------------------------------------------------------------------------
+    // Accessors
+    // -------------------------------------------------------------------------
+    /**
+     * Gets the main alias string used in this query builder.
+     */
+    get alias() {
+        if (!this.expressionMap.mainAlias)
+            throw new TypeORMError(`Main alias is not set`); // todo: better exception
+        return this.expressionMap.mainAlias.name;
+    }
     /**
      * Creates SELECT query and selects given data.
      * Replaces all previous selections if they exist.
      */
-    QueryBuilder.prototype.select = function (selection, selectionAliasName) {
+    select(selection, selectionAliasName) {
         this.expressionMap.queryType = "select";
-        if (selection instanceof Array) {
-            this.expressionMap.selects = selection.map(function (selection) { return ({ selection: selection }); });
+        if (Array.isArray(selection)) {
+            this.expressionMap.selects = selection.map((selection) => ({
+                selection: selection,
+            }));
         }
         else if (selection) {
-            this.expressionMap.selects = [{ selection: selection, aliasName: selectionAliasName }];
+            this.expressionMap.selects = [
+                { selection: selection, aliasName: selectionAliasName },
+            ];
         }
         // loading it dynamically because of circular issue
-        var SelectQueryBuilderCls = require("./SelectQueryBuilder").SelectQueryBuilder;
-        if (this instanceof SelectQueryBuilderCls)
+        const SelectQueryBuilderCls = require("./SelectQueryBuilder").SelectQueryBuilder;
+        if (InstanceChecker.isSelectQueryBuilder(this))
             return this;
         return new SelectQueryBuilderCls(this);
-    };
+    }
     /**
      * Creates INSERT query.
      */
-    QueryBuilder.prototype.insert = function () {
+    insert() {
         this.expressionMap.queryType = "insert";
         // loading it dynamically because of circular issue
-        var InsertQueryBuilderCls = require("./InsertQueryBuilder").InsertQueryBuilder;
-        if (this instanceof InsertQueryBuilderCls)
+        const InsertQueryBuilderCls = require("./InsertQueryBuilder").InsertQueryBuilder;
+        if (InstanceChecker.isInsertQueryBuilder(this))
             return this;
         return new InsertQueryBuilderCls(this);
-    };
+    }
     /**
      * Creates UPDATE query and applies given update values.
      */
-    QueryBuilder.prototype.update = function (entityOrTableNameUpdateSet, maybeUpdateSet) {
-        var updateSet = maybeUpdateSet ? maybeUpdateSet : entityOrTableNameUpdateSet;
-        entityOrTableNameUpdateSet = entityOrTableNameUpdateSet instanceof EntitySchema ? entityOrTableNameUpdateSet.options.name : entityOrTableNameUpdateSet;
-        if (entityOrTableNameUpdateSet instanceof Function || typeof entityOrTableNameUpdateSet === "string") {
-            var mainAlias = this.createFromAlias(entityOrTableNameUpdateSet);
+    update(entityOrTableNameUpdateSet, maybeUpdateSet) {
+        const updateSet = maybeUpdateSet
+            ? maybeUpdateSet
+            : entityOrTableNameUpdateSet;
+        entityOrTableNameUpdateSet = InstanceChecker.isEntitySchema(entityOrTableNameUpdateSet)
+            ? entityOrTableNameUpdateSet.options.name
+            : entityOrTableNameUpdateSet;
+        if (typeof entityOrTableNameUpdateSet === "function" ||
+            typeof entityOrTableNameUpdateSet === "string") {
+            const mainAlias = this.createFromAlias(entityOrTableNameUpdateSet);
             this.expressionMap.setMainAlias(mainAlias);
         }
         this.expressionMap.queryType = "update";
         this.expressionMap.valuesSet = updateSet;
         // loading it dynamically because of circular issue
-        var UpdateQueryBuilderCls = require("./UpdateQueryBuilder").UpdateQueryBuilder;
-        if (this instanceof UpdateQueryBuilderCls)
+        const UpdateQueryBuilderCls = require("./UpdateQueryBuilder").UpdateQueryBuilder;
+        if (InstanceChecker.isUpdateQueryBuilder(this))
             return this;
         return new UpdateQueryBuilderCls(this);
-    };
+    }
     /**
      * Creates DELETE query.
      */
-    QueryBuilder.prototype.delete = function () {
+    delete() {
         this.expressionMap.queryType = "delete";
         // loading it dynamically because of circular issue
-        var DeleteQueryBuilderCls = require("./DeleteQueryBuilder").DeleteQueryBuilder;
-        if (this instanceof DeleteQueryBuilderCls)
+        const DeleteQueryBuilderCls = require("./DeleteQueryBuilder").DeleteQueryBuilder;
+        if (InstanceChecker.isDeleteQueryBuilder(this))
             return this;
         return new DeleteQueryBuilderCls(this);
-    };
+    }
+    softDelete() {
+        this.expressionMap.queryType = "soft-delete";
+        // loading it dynamically because of circular issue
+        const SoftDeleteQueryBuilderCls = require("./SoftDeleteQueryBuilder").SoftDeleteQueryBuilder;
+        if (InstanceChecker.isSoftDeleteQueryBuilder(this))
+            return this;
+        return new SoftDeleteQueryBuilderCls(this);
+    }
+    restore() {
+        this.expressionMap.queryType = "restore";
+        // loading it dynamically because of circular issue
+        const SoftDeleteQueryBuilderCls = require("./SoftDeleteQueryBuilder").SoftDeleteQueryBuilder;
+        if (InstanceChecker.isSoftDeleteQueryBuilder(this))
+            return this;
+        return new SoftDeleteQueryBuilderCls(this);
+    }
     /**
      * Sets entity's relation with which this query builder gonna work.
      */
-    QueryBuilder.prototype.relation = function (entityTargetOrPropertyPath, maybePropertyPath) {
-        var entityTarget = arguments.length === 2 ? entityTargetOrPropertyPath : undefined;
-        var propertyPath = arguments.length === 2 ? maybePropertyPath : entityTargetOrPropertyPath;
+    relation(entityTargetOrPropertyPath, maybePropertyPath) {
+        const entityTarget = arguments.length === 2 ? entityTargetOrPropertyPath : undefined;
+        const propertyPath = arguments.length === 2
+            ? maybePropertyPath
+            : entityTargetOrPropertyPath;
         this.expressionMap.queryType = "relation";
         this.expressionMap.relationPropertyPath = propertyPath;
         if (entityTarget) {
-            var mainAlias = this.createFromAlias(entityTarget);
+            const mainAlias = this.createFromAlias(entityTarget);
             this.expressionMap.setMainAlias(mainAlias);
         }
         // loading it dynamically because of circular issue
-        var RelationQueryBuilderCls = require("./RelationQueryBuilder").RelationQueryBuilder;
-        if (this instanceof RelationQueryBuilderCls)
+        const RelationQueryBuilderCls = require("./RelationQueryBuilder").RelationQueryBuilder;
+        if (InstanceChecker.isRelationQueryBuilder(this))
             return this;
         return new RelationQueryBuilderCls(this);
-    };
+    }
     /**
      * Checks if given relation or relations exist in the entity.
      * Returns true if relation exists, false otherwise.
      *
      * todo: move this method to manager? or create a shortcut?
      */
-    QueryBuilder.prototype.hasRelation = function (target, relation) {
-        var entityMetadata = this.connection.getMetadata(target);
-        var relations = relation instanceof Array ? relation : [relation];
-        return relations.every(function (relation) {
+    hasRelation(target, relation) {
+        const entityMetadata = this.connection.getMetadata(target);
+        const relations = Array.isArray(relation) ? relation : [relation];
+        return relations.every((relation) => {
             return !!entityMetadata.findRelationWithPropertyPath(relation);
         });
-    };
+    }
+    /**
+     * Check the existence of a parameter for this query builder.
+     */
+    hasParameter(key) {
+        var _a;
+        return (((_a = this.parentQueryBuilder) === null || _a === void 0 ? void 0 : _a.hasParameter(key)) ||
+            key in this.expressionMap.parameters);
+    }
     /**
      * Sets parameter name and its value.
+     *
+     * The key for this parametere may contain numbers, letters, underscores, or periods.
      */
-    QueryBuilder.prototype.setParameter = function (key, value) {
+    setParameter(key, value) {
+        if (typeof value === "function") {
+            throw new TypeORMError(`Function parameter isn't supported in the parameters. Please check "${key}" parameter.`);
+        }
+        if (!key.match(/^([A-Za-z0-9_.]+)$/)) {
+            throw new TypeORMError("QueryBuilder parameter keys may only contain numbers, letters, underscores, or periods.");
+        }
+        if (this.parentQueryBuilder) {
+            this.parentQueryBuilder.setParameter(key, value);
+        }
         this.expressionMap.parameters[key] = value;
         return this;
-    };
+    }
     /**
      * Adds all parameters from the given object.
      */
-    QueryBuilder.prototype.setParameters = function (parameters) {
-        var _this = this;
-        // remove function parameters
-        Object.keys(parameters).forEach(function (key) {
-            if (parameters[key] instanceof Function) {
-                throw new Error("Function parameter isn't supported in the parameters. Please check \"" + key + "\" parameter.");
-            }
-        });
-        // set parent query builder parameters as well in sub-query mode
-        if (this.expressionMap.parentQueryBuilder)
-            this.expressionMap.parentQueryBuilder.setParameters(parameters);
-        Object.keys(parameters).forEach(function (key) { return _this.setParameter(key, parameters[key]); });
+    setParameters(parameters) {
+        for (const [key, value] of Object.entries(parameters)) {
+            this.setParameter(key, value);
+        }
         return this;
-    };
+    }
+    createParameter(value) {
+        let parameterName;
+        do {
+            parameterName = `orm_param_${this.parameterIndex++}`;
+        } while (this.hasParameter(parameterName));
+        this.setParameter(parameterName, value);
+        return `:${parameterName}`;
+    }
     /**
      * Adds native parameters from the given object.
+     *
+     * @deprecated Use `setParameters` instead
      */
-    QueryBuilder.prototype.setNativeParameters = function (parameters) {
-        var _this = this;
+    setNativeParameters(parameters) {
         // set parent query builder parameters as well in sub-query mode
-        if (this.expressionMap.parentQueryBuilder)
-            this.expressionMap.parentQueryBuilder.setNativeParameters(parameters);
-        Object.keys(parameters).forEach(function (key) {
-            _this.expressionMap.nativeParameters[key] = parameters[key];
+        if (this.parentQueryBuilder) {
+            this.parentQueryBuilder.setNativeParameters(parameters);
+        }
+        Object.keys(parameters).forEach((key) => {
+            this.expressionMap.nativeParameters[key] = parameters[key];
         });
         return this;
-    };
+    }
     /**
      * Gets all parameters.
      */
-    QueryBuilder.prototype.getParameters = function () {
-        var parameters = Object.assign({}, this.expressionMap.parameters);
+    getParameters() {
+        const parameters = Object.assign({}, this.expressionMap.parameters);
         // add discriminator column parameter if it exist
-        if (this.expressionMap.mainAlias && this.expressionMap.mainAlias.hasMetadata) {
-            var metadata = this.expressionMap.mainAlias.metadata;
+        if (this.expressionMap.mainAlias &&
+            this.expressionMap.mainAlias.hasMetadata) {
+            const metadata = this.expressionMap.mainAlias.metadata;
             if (metadata.discriminatorColumn && metadata.parentEntityMetadata) {
-                var values = metadata.childEntityMetadatas
-                    .filter(function (childMetadata) { return childMetadata.discriminatorColumn; })
-                    .map(function (childMetadata) { return childMetadata.discriminatorValue; });
+                const values = metadata.childEntityMetadatas
+                    .filter((childMetadata) => childMetadata.discriminatorColumn)
+                    .map((childMetadata) => childMetadata.discriminatorValue);
                 values.push(metadata.discriminatorValue);
                 parameters["discriminatorColumnValues"] = values;
             }
         }
         return parameters;
-    };
+    }
     /**
      * Prints sql to stdout using console.log.
      */
-    QueryBuilder.prototype.printSql = function () {
-        var _a = tslib_1.__read(this.getQueryAndParameters(), 2), query = _a[0], parameters = _a[1];
+    printSql() {
+        // TODO rename to logSql()
+        const [query, parameters] = this.getQueryAndParameters();
         this.connection.logger.logQuery(query, parameters);
         return this;
-    };
+    }
     /**
      * Gets generated sql that will be executed.
      * Parameters in the query are escaped for the currently used driver.
      */
-    QueryBuilder.prototype.getSql = function () {
+    getSql() {
         return this.getQueryAndParameters()[0];
-    };
+    }
     /**
      * Gets query to be executed with all parameters used in it.
      */
-    QueryBuilder.prototype.getQueryAndParameters = function () {
+    getQueryAndParameters() {
         // this execution order is important because getQuery method generates this.expressionMap.nativeParameters values
-        var query = this.getQuery();
-        var parameters = this.getParameters();
+        const query = this.getQuery();
+        const parameters = this.getParameters();
         return this.connection.driver.escapeQueryWithParameters(query, parameters, this.expressionMap.nativeParameters);
-    };
+    }
     /**
      * Executes sql generated by query builder and returns raw database results.
      */
-    QueryBuilder.prototype.execute = function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var _a, sql, parameters, queryRunner;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = tslib_1.__read(this.getQueryAndParameters(), 2), sql = _a[0], parameters = _a[1];
-                        queryRunner = this.obtainQueryRunner();
-                        _b.label = 1;
-                    case 1:
-                        _b.trys.push([1, , 3, 8]);
-                        return [4 /*yield*/, queryRunner.query(sql, parameters)];
-                    case 2: return [2 /*return*/, _b.sent()]; // await is needed here because we are using finally
-                    case 3:
-                        if (!(queryRunner !== this.queryRunner)) return [3 /*break*/, 5];
-                        return [4 /*yield*/, queryRunner.release()];
-                    case 4:
-                        _b.sent();
-                        _b.label = 5;
-                    case 5:
-                        if (!(this.connection.driver instanceof SqljsDriver)) return [3 /*break*/, 7];
-                        return [4 /*yield*/, this.connection.driver.autoSave()];
-                    case 6:
-                        _b.sent();
-                        _b.label = 7;
-                    case 7: return [7 /*endfinally*/];
-                    case 8: return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async execute() {
+        const [sql, parameters] = this.getQueryAndParameters();
+        const queryRunner = this.obtainQueryRunner();
+        try {
+            return await queryRunner.query(sql, parameters); // await is needed here because we are using finally
+        }
+        finally {
+            if (queryRunner !== this.queryRunner) {
+                // means we created our own query runner
+                await queryRunner.release();
+            }
+        }
+    }
     /**
      * Creates a completely new query builder.
      * Uses same query runner as current QueryBuilder.
      */
-    QueryBuilder.prototype.createQueryBuilder = function () {
+    createQueryBuilder() {
         return new this.constructor(this.connection, this.queryRunner);
-    };
+    }
     /**
      * Clones query builder as it is.
      * Note: it uses new query runner, if you want query builder that uses exactly same query runner,
      * you can create query builder using its constructor, for example new SelectQueryBuilder(queryBuilder)
      * where queryBuilder is cloned QueryBuilder.
      */
-    QueryBuilder.prototype.clone = function () {
+    clone() {
         return new this.constructor(this);
-    };
+    }
+    /**
+     * Includes a Query comment in the query builder.  This is helpful for debugging purposes,
+     * such as finding a specific query in the database server's logs, or for categorization using
+     * an APM product.
+     */
+    comment(comment) {
+        this.expressionMap.comment = comment;
+        return this;
+    }
     /**
      * Disables escaping.
      */
-    QueryBuilder.prototype.disableEscaping = function () {
+    disableEscaping() {
         this.expressionMap.disableEscaping = false;
         return this;
-    };
+    }
     /**
      * Escapes table name, column name or alias name using current database's escaping character.
      */
-    QueryBuilder.prototype.escape = function (name) {
+    escape(name) {
         if (!this.expressionMap.disableEscaping)
             return name;
         return this.connection.driver.escape(name);
-    };
+    }
     /**
      * Sets or overrides query builder's QueryRunner.
      */
-    QueryBuilder.prototype.setQueryRunner = function (queryRunner) {
+    setQueryRunner(queryRunner) {
         this.queryRunner = queryRunner;
         return this;
-    };
+    }
     /**
      * Indicates if listeners and subscribers must be called before and after query execution.
      * Enabled by default.
      */
-    QueryBuilder.prototype.callListeners = function (enabled) {
+    callListeners(enabled) {
         this.expressionMap.callListeners = enabled;
         return this;
-    };
-    /**
-     * Indicates if observers must be called before and after query execution.
-     * Enabled by default.
-     */
-    QueryBuilder.prototype.callObservers = function (enabled) {
-        this.expressionMap.callObservers = enabled;
-        return this;
-    };
+    }
     /**
      * If set to true the query will be wrapped into a transaction.
      */
-    QueryBuilder.prototype.useTransaction = function (enabled) {
+    useTransaction(enabled) {
         this.expressionMap.useTransaction = enabled;
         return this;
-    };
+    }
     // -------------------------------------------------------------------------
     // Protected Methods
     // -------------------------------------------------------------------------
@@ -325,148 +356,240 @@ var QueryBuilder = /** @class */ (function () {
      * Gets escaped table name with schema name if SqlServer driver used with custom
      * schema name, otherwise returns escaped table name.
      */
-    QueryBuilder.prototype.getTableName = function (tablePath) {
-        var _this = this;
-        return tablePath.split(".")
-            .map(function (i) {
+    getTableName(tablePath) {
+        return tablePath
+            .split(".")
+            .map((i) => {
             // this condition need because in SQL Server driver when custom database name was specified and schema name was not, we got `dbName..tableName` string, and doesn't need to escape middle empty string
             if (i === "")
                 return i;
-            return _this.escape(i);
-        }).join(".");
-    };
+            return this.escape(i);
+        })
+            .join(".");
+    }
     /**
      * Gets name of the table where insert should be performed.
      */
-    QueryBuilder.prototype.getMainTableName = function () {
+    getMainTableName() {
         if (!this.expressionMap.mainAlias)
-            throw new Error("Entity where values should be inserted is not specified. Call \"qb.into(entity)\" method to specify it.");
+            throw new TypeORMError(`Entity where values should be inserted is not specified. Call "qb.into(entity)" method to specify it.`);
         if (this.expressionMap.mainAlias.hasMetadata)
             return this.expressionMap.mainAlias.metadata.tablePath;
         return this.expressionMap.mainAlias.tablePath;
-    };
+    }
     /**
      * Specifies FROM which entity's table select/update/delete will be executed.
      * Also sets a main string alias of the selection data.
      */
-    QueryBuilder.prototype.createFromAlias = function (entityTarget, aliasName) {
+    createFromAlias(entityTarget, aliasName) {
         // if table has a metadata then find it to properly escape its properties
         // const metadata = this.connection.entityMetadatas.find(metadata => metadata.tableName === tableName);
         if (this.connection.hasMetadata(entityTarget)) {
-            var metadata = this.connection.getMetadata(entityTarget);
+            const metadata = this.connection.getMetadata(entityTarget);
             return this.expressionMap.createAlias({
                 type: "from",
                 name: aliasName,
                 metadata: this.connection.getMetadata(entityTarget),
-                tablePath: metadata.tablePath
+                tablePath: metadata.tablePath,
             });
         }
         else {
-            var subQuery = "";
-            if (entityTarget instanceof Function) {
-                var subQueryBuilder = entityTarget(this.subQuery());
-                this.setParameters(subQueryBuilder.getParameters());
-                subQuery = subQueryBuilder.getQuery();
-            }
-            else {
-                subQuery = entityTarget;
+            if (typeof entityTarget === "string") {
+                const isSubquery = entityTarget.substr(0, 1) === "(" &&
+                    entityTarget.substr(-1) === ")";
+                return this.expressionMap.createAlias({
+                    type: "from",
+                    name: aliasName,
+                    tablePath: !isSubquery
+                        ? entityTarget
+                        : undefined,
+                    subQuery: isSubquery ? entityTarget : undefined,
+                });
             }
-            var isSubQuery = entityTarget instanceof Function || entityTarget.substr(0, 1) === "(" && entityTarget.substr(-1) === ")";
+            const subQueryBuilder = entityTarget(this.subQuery());
+            this.setParameters(subQueryBuilder.getParameters());
+            const subquery = subQueryBuilder.getQuery();
             return this.expressionMap.createAlias({
                 type: "from",
                 name: aliasName,
-                tablePath: isSubQuery === false ? entityTarget : undefined,
-                subQuery: isSubQuery === true ? subQuery : undefined,
+                subQuery: subquery,
             });
         }
-    };
+    }
     /**
      * Replaces all entity's propertyName to name in the given statement.
      */
-    QueryBuilder.prototype.replacePropertyNames = function (statement) {
-        var _this = this;
-        this.expressionMap.aliases.forEach(function (alias) {
+    replacePropertyNames(statement) {
+        // Escape special characters in regular expressions
+        // Per https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Escaping
+        const escapeRegExp = (s) => s.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&");
+        for (const alias of this.expressionMap.aliases) {
             if (!alias.hasMetadata)
-                return;
-            var replaceAliasNamePrefix = _this.expressionMap.aliasNamePrefixingEnabled ? alias.name + "\\." : "";
-            var replacementAliasNamePrefix = _this.expressionMap.aliasNamePrefixingEnabled ? _this.escape(alias.name) + "." : "";
-            alias.metadata.columns.forEach(function (column) {
-                var expression = "([ =\(]|^.{0})" + replaceAliasNamePrefix + column.propertyPath + "([ =\)\,]|.{0}$)";
-                statement = statement.replace(new RegExp(expression, "gm"), "$1" + replacementAliasNamePrefix + _this.escape(column.databaseName) + "$2");
-                var expression2 = "([ =\(]|^.{0})" + replaceAliasNamePrefix + column.propertyName + "([ =\)\,]|.{0}$)";
-                statement = statement.replace(new RegExp(expression2, "gm"), "$1" + replacementAliasNamePrefix + _this.escape(column.databaseName) + "$2");
-            });
-            alias.metadata.relations.forEach(function (relation) {
-                tslib_1.__spread(relation.joinColumns, relation.inverseJoinColumns).forEach(function (joinColumn) {
-                    var expression = "([ =\(]|^.{0})" + replaceAliasNamePrefix + relation.propertyPath + "\\." + joinColumn.referencedColumn.propertyPath + "([ =\)\,]|.{0}$)";
-                    statement = statement.replace(new RegExp(expression, "gm"), "$1" + replacementAliasNamePrefix + _this.escape(joinColumn.databaseName) + "$2"); // todo: fix relation.joinColumns[0], what if multiple columns
-                });
-                if (relation.joinColumns.length > 0) {
-                    var expression = "([ =\(]|^.{0})" + replaceAliasNamePrefix + relation.propertyPath + "([ =\)\,]|.{0}$)";
-                    statement = statement.replace(new RegExp(expression, "gm"), "$1" + replacementAliasNamePrefix + _this.escape(relation.joinColumns[0].databaseName) + "$2"); // todo: fix relation.joinColumns[0], what if multiple columns
+                continue;
+            const replaceAliasNamePrefix = this.expressionMap
+                .aliasNamePrefixingEnabled
+                ? `${alias.name}.`
+                : "";
+            const replacementAliasNamePrefix = this.expressionMap
+                .aliasNamePrefixingEnabled
+                ? `${this.escape(alias.name)}.`
+                : "";
+            const replacements = {};
+            // Insert & overwrite the replacements from least to most relevant in our replacements object.
+            // To do this we iterate and overwrite in the order of relevance.
+            // Least to Most Relevant:
+            // * Relation Property Path to first join column key
+            // * Relation Property Path + Column Path
+            // * Column Database Name
+            // * Column Propety Name
+            // * Column Property Path
+            for (const relation of alias.metadata.relations) {
+                if (relation.joinColumns.length > 0)
+                    replacements[relation.propertyPath] =
+                        relation.joinColumns[0].databaseName;
+            }
+            for (const relation of alias.metadata.relations) {
+                for (const joinColumn of [
+                    ...relation.joinColumns,
+                    ...relation.inverseJoinColumns,
+                ]) {
+                    const propertyKey = `${relation.propertyPath}.${joinColumn.referencedColumn.propertyPath}`;
+                    replacements[propertyKey] = joinColumn.databaseName;
                 }
-            });
-        });
+            }
+            for (const column of alias.metadata.columns) {
+                replacements[column.databaseName] = column.databaseName;
+            }
+            for (const column of alias.metadata.columns) {
+                replacements[column.propertyName] = column.databaseName;
+            }
+            for (const column of alias.metadata.columns) {
+                replacements[column.propertyPath] = column.databaseName;
+            }
+            const replacementKeys = Object.keys(replacements);
+            if (replacementKeys.length) {
+                statement = statement.replace(new RegExp(
+                // Avoid a lookbehind here since it's not well supported
+                `([ =\(]|^.{0})` +
+                    `${escapeRegExp(replaceAliasNamePrefix)}(${replacementKeys
+                        .map(escapeRegExp)
+                        .join("|")})` +
+                    `(?=[ =\)\,]|.{0}$)`, "gm"), (_, pre, p) => `${pre}${replacementAliasNamePrefix}${this.escape(replacements[p])}`);
+            }
+        }
         return statement;
-    };
+    }
+    createComment() {
+        if (!this.expressionMap.comment) {
+            return "";
+        }
+        // ANSI SQL 2003 support C style comments - comments that start with `/*` and end with `*/`
+        // In some dialects query nesting is available - but not all.  Because of this, we'll need
+        // to scrub "ending" characters from the SQL but otherwise we can leave everything else
+        // as-is and it should be valid.
+        return `/* ${this.expressionMap.comment.replace("*/", "")} */ `;
+    }
     /**
      * Creates "WHERE" expression.
      */
-    QueryBuilder.prototype.createWhereExpression = function () {
-        var conditions = this.createWhereExpressionString();
+    createWhereExpression() {
+        const conditionsArray = [];
+        const whereExpression = this.createWhereClausesExpression(this.expressionMap.wheres);
+        if (whereExpression.length > 0 && whereExpression !== "1=1") {
+            conditionsArray.push(this.replacePropertyNames(whereExpression));
+        }
         if (this.expressionMap.mainAlias.hasMetadata) {
-            var metadata = this.expressionMap.mainAlias.metadata;
+            const metadata = this.expressionMap.mainAlias.metadata;
+            // Adds the global condition of "non-deleted" for the entity with delete date columns in select query.
+            if (this.expressionMap.queryType === "select" &&
+                !this.expressionMap.withDeleted &&
+                metadata.deleteDateColumn) {
+                const column = this.expressionMap.aliasNamePrefixingEnabled
+                    ? this.expressionMap.mainAlias.name +
+                        "." +
+                        metadata.deleteDateColumn.propertyName
+                    : metadata.deleteDateColumn.propertyName;
+                const condition = `${this.replacePropertyNames(column)} IS NULL`;
+                conditionsArray.push(condition);
+            }
             if (metadata.discriminatorColumn && metadata.parentEntityMetadata) {
-                var column = this.expressionMap.aliasNamePrefixingEnabled
-                    ? this.expressionMap.mainAlias.name + "." + metadata.discriminatorColumn.databaseName
+                const column = this.expressionMap.aliasNamePrefixingEnabled
+                    ? this.expressionMap.mainAlias.name +
+                        "." +
+                        metadata.discriminatorColumn.databaseName
                     : metadata.discriminatorColumn.databaseName;
-                var condition = this.replacePropertyNames(column) + " IN (:...discriminatorColumnValues)";
-                return " WHERE " + (conditions.length ? "(" + conditions + ") AND" : "") + " " + condition;
+                const condition = `${this.replacePropertyNames(column)} IN (:...discriminatorColumnValues)`;
+                conditionsArray.push(condition);
             }
         }
-        if (!conditions.length) // TODO copy in to discriminator condition
-            return this.expressionMap.extraAppendedAndWhereCondition ? " WHERE " + this.replacePropertyNames(this.expressionMap.extraAppendedAndWhereCondition) : "";
-        if (this.expressionMap.extraAppendedAndWhereCondition)
-            return " WHERE (" + conditions + ") AND " + this.replacePropertyNames(this.expressionMap.extraAppendedAndWhereCondition);
-        return " WHERE " + conditions;
-    };
+        if (this.expressionMap.extraAppendedAndWhereCondition) {
+            const condition = this.replacePropertyNames(this.expressionMap.extraAppendedAndWhereCondition);
+            conditionsArray.push(condition);
+        }
+        if (!conditionsArray.length) {
+            return "";
+        }
+        else if (conditionsArray.length === 1) {
+            return ` WHERE ${conditionsArray[0]}`;
+        }
+        else {
+            return ` WHERE ( ${conditionsArray.join(" ) AND ( ")} )`;
+        }
+    }
     /**
      * Creates "RETURNING" / "OUTPUT" expression.
      */
-    QueryBuilder.prototype.createReturningExpression = function () {
-        var _this = this;
-        var columns = this.getReturningColumns();
-        var driver = this.connection.driver;
+    createReturningExpression(returningType) {
+        const columns = this.getReturningColumns();
+        const driver = this.connection.driver;
         // also add columns we must auto-return to perform entity updation
         // if user gave his own returning
         if (typeof this.expressionMap.returning !== "string" &&
             this.expressionMap.extraReturningColumns.length > 0 &&
-            driver.isReturningSqlSupported()) {
-            columns.push.apply(columns, tslib_1.__spread(this.expressionMap.extraReturningColumns.filter(function (column) {
+            driver.isReturningSqlSupported(returningType)) {
+            columns.push(...this.expressionMap.extraReturningColumns.filter((column) => {
                 return columns.indexOf(column) === -1;
-            })));
+            }));
         }
         if (columns.length) {
-            var columnsExpression = columns.map(function (column) {
-                var name = _this.escape(column.databaseName);
-                if (driver instanceof SqlServerDriver) {
-                    if (_this.expressionMap.queryType === "insert" || _this.expressionMap.queryType === "update") {
+            let columnsExpression = columns
+                .map((column) => {
+                const name = this.escape(column.databaseName);
+                if (driver.options.type === "mssql") {
+                    if (this.expressionMap.queryType === "insert" ||
+                        this.expressionMap.queryType === "update" ||
+                        this.expressionMap.queryType === "soft-delete" ||
+                        this.expressionMap.queryType === "restore") {
                         return "INSERTED." + name;
                     }
                     else {
-                        return _this.escape(_this.getMainTableName()) + "." + name;
+                        return (this.escape(this.getMainTableName()) +
+                            "." +
+                            name);
                     }
                 }
                 else {
                     return name;
                 }
-            }).join(", ");
-            if (driver instanceof OracleDriver) {
-                columnsExpression += " INTO " + columns.map(function (column) {
-                    var parameterName = "output_" + column.databaseName;
-                    _this.expressionMap.nativeParameters[parameterName] = { type: driver.columnTypeToNativeParameter(column.type), dir: driver.oracle.BIND_OUT };
-                    return _this.connection.driver.createParameter(parameterName, Object.keys(_this.expressionMap.nativeParameters).length);
-                }).join(", ");
+            })
+                .join(", ");
+            if (driver.options.type === "oracle") {
+                columnsExpression +=
+                    " INTO " +
+                        columns
+                            .map((column) => {
+                            return this.createParameter({
+                                type: driver.columnTypeToNativeParameter(column.type),
+                                dir: driver.oracle.BIND_OUT,
+                            });
+                        })
+                            .join(", ");
+            }
+            if (driver.options.type === "mssql") {
+                if (this.expressionMap.queryType === "insert" ||
+                    this.expressionMap.queryType === "update") {
+                    columnsExpression += " INTO @OutputTable";
+                }
             }
             return columnsExpression;
         }
@@ -474,184 +597,384 @@ var QueryBuilder = /** @class */ (function () {
             return this.expressionMap.returning;
         }
         return "";
-    };
+    }
     /**
      * If returning / output cause is set to array of column names,
      * then this method will return all column metadatas of those column names.
      */
-    QueryBuilder.prototype.getReturningColumns = function () {
-        var _this = this;
-        var columns = [];
-        if (this.expressionMap.returning instanceof Array) {
-            this.expressionMap.returning.forEach(function (columnName) {
-                if (_this.expressionMap.mainAlias.hasMetadata) {
-                    columns.push.apply(columns, tslib_1.__spread(_this.expressionMap.mainAlias.metadata.findColumnsWithPropertyPath(columnName)));
+    getReturningColumns() {
+        const columns = [];
+        if (Array.isArray(this.expressionMap.returning)) {
+            ;
+            this.expressionMap.returning.forEach((columnName) => {
+                if (this.expressionMap.mainAlias.hasMetadata) {
+                    columns.push(...this.expressionMap.mainAlias.metadata.findColumnsWithPropertyPath(columnName));
                 }
             });
         }
         return columns;
-    };
-    /**
-     * Concatenates all added where expressions into one string.
-     */
-    QueryBuilder.prototype.createWhereExpressionString = function () {
-        var _this = this;
-        return this.expressionMap.wheres.map(function (where, index) {
-            switch (where.type) {
+    }
+    createWhereClausesExpression(clauses) {
+        return clauses
+            .map((clause, index) => {
+            const expression = this.createWhereConditionExpression(clause.condition);
+            switch (clause.type) {
                 case "and":
-                    return (index > 0 ? "AND " : "") + _this.replacePropertyNames(where.condition);
+                    return (index > 0 ? "AND " : "") + expression;
                 case "or":
-                    return (index > 0 ? "OR " : "") + _this.replacePropertyNames(where.condition);
-                default:
-                    return _this.replacePropertyNames(where.condition);
+                    return (index > 0 ? "OR " : "") + expression;
             }
-        }).join(" ");
-    };
+            return expression;
+        })
+            .join(" ")
+            .trim();
+    }
     /**
-     * Creates "WHERE" expression and variables for the given "ids".
+     * Computes given where argument - transforms to a where string all forms it can take.
      */
-    QueryBuilder.prototype.createWhereIdsExpression = function (ids) {
-        var _this = this;
-        var _a;
-        var metadata = this.expressionMap.mainAlias.metadata;
-        var normalized = (Array.isArray(ids) ? ids : [ids]).map(function (id) { return metadata.ensureEntityIdMap(id); });
+    createWhereConditionExpression(condition, alwaysWrap = false) {
+        if (typeof condition === "string")
+            return condition;
+        if (Array.isArray(condition)) {
+            if (condition.length === 0) {
+                return "1=1";
+            }
+            // In the future we should probably remove this entire condition
+            // but for now to prevent any breaking changes it exists.
+            if (condition.length === 1 && !alwaysWrap) {
+                return this.createWhereClausesExpression(condition);
+            }
+            return "(" + this.createWhereClausesExpression(condition) + ")";
+        }
+        const { driver } = this.connection;
+        switch (condition.operator) {
+            case "lessThan":
+                return `${condition.parameters[0]} < ${condition.parameters[1]}`;
+            case "lessThanOrEqual":
+                return `${condition.parameters[0]} <= ${condition.parameters[1]}`;
+            case "moreThan":
+                return `${condition.parameters[0]} > ${condition.parameters[1]}`;
+            case "moreThanOrEqual":
+                return `${condition.parameters[0]} >= ${condition.parameters[1]}`;
+            case "notEqual":
+                return `${condition.parameters[0]} != ${condition.parameters[1]}`;
+            case "equal":
+                return `${condition.parameters[0]} = ${condition.parameters[1]}`;
+            case "ilike":
+                if (driver.options.type === "postgres" ||
+                    driver.options.type === "cockroachdb") {
+                    return `${condition.parameters[0]} ILIKE ${condition.parameters[1]}`;
+                }
+                return `UPPER(${condition.parameters[0]}) LIKE UPPER(${condition.parameters[1]})`;
+            case "like":
+                return `${condition.parameters[0]} LIKE ${condition.parameters[1]}`;
+            case "between":
+                return `${condition.parameters[0]} BETWEEN ${condition.parameters[1]} AND ${condition.parameters[2]}`;
+            case "in":
+                if (condition.parameters.length <= 1) {
+                    return "0=1";
+                }
+                return `${condition.parameters[0]} IN (${condition.parameters
+                    .slice(1)
+                    .join(", ")})`;
+            case "any":
+                return `${condition.parameters[0]} = ANY(${condition.parameters[1]})`;
+            case "isNull":
+                return `${condition.parameters[0]} IS NULL`;
+            case "not":
+                return `NOT(${this.createWhereConditionExpression(condition.condition)})`;
+            case "brackets":
+                return `${this.createWhereConditionExpression(condition.condition, true)}`;
+        }
+        throw new TypeError(`Unsupported FindOperator ${FindOperator.constructor.name}`);
+    }
+    /**
+     * Creates "WHERE" condition for an in-ids condition.
+     */
+    getWhereInIdsCondition(ids) {
+        const metadata = this.expressionMap.mainAlias.metadata;
+        const normalized = (Array.isArray(ids) ? ids : [ids]).map((id) => metadata.ensureEntityIdMap(id));
         // using in(...ids) for single primary key entities
-        if (!metadata.hasMultiplePrimaryKeys
-            && metadata.embeddeds.length === 0) {
-            var primaryColumn_1 = metadata.primaryColumns[0];
+        if (!metadata.hasMultiplePrimaryKeys) {
+            const primaryColumn = metadata.primaryColumns[0];
             // getEntityValue will try to transform `In`, it is a bug
             // todo: remove this transformer check after #2390 is fixed
-            if (!primaryColumn_1.transformer) {
-                return this.computeWhereParameter((_a = {},
-                    _a[primaryColumn_1.propertyName] = In(normalized.map(function (id) { return primaryColumn_1.getEntityValue(id, false); })),
-                    _a));
+            // This also fails for embedded & relation, so until that is fixed skip it.
+            if (!primaryColumn.transformer &&
+                !primaryColumn.relationMetadata &&
+                !primaryColumn.embeddedMetadata) {
+                return {
+                    [primaryColumn.propertyName]: In(normalized.map((id) => primaryColumn.getEntityValue(id, false))),
+                };
             }
         }
-        // create shortcuts for better readability
-        var alias = this.expressionMap.aliasNamePrefixingEnabled ? this.escape(this.expressionMap.mainAlias.name) + "." : "";
-        var parameterIndex = Object.keys(this.expressionMap.nativeParameters).length;
-        if (metadata.primaryColumns.length > 1) {
-            var whereStrings = normalized.map(function (id, index) {
-                var whereSubStrings = [];
-                metadata.primaryColumns.forEach(function (primaryColumn, secondIndex) {
-                    var parameterName = "id_" + index + "_" + secondIndex;
-                    // whereSubStrings.push(alias + this.escape(primaryColumn.databaseName) + "=:id_" + index + "_" + secondIndex);
-                    whereSubStrings.push(alias + _this.escape(primaryColumn.databaseName) + " = " + _this.connection.driver.createParameter(parameterName, parameterIndex));
-                    _this.expressionMap.nativeParameters[parameterName] = primaryColumn.getEntityValue(id, true);
-                    parameterIndex++;
-                });
-                return whereSubStrings.join(" AND ");
-            });
-            return whereStrings.length > 1 ? "(" + whereStrings.map(function (whereString) { return "(" + whereString + ")"; }).join(" OR ") + ")" : whereStrings[0];
+        return new Brackets((qb) => {
+            for (const data of normalized) {
+                qb.orWhere(new Brackets((qb) => qb.where(data)));
+            }
+        });
+    }
+    findColumnsForPropertyPath(propertyPath) {
+        // Make a helper to iterate the entity & relations?
+        // Use that to set the correct alias?  Or the other way around?
+        // Start with the main alias with our property paths
+        let alias = this.expressionMap.mainAlias;
+        const root = [];
+        const propertyPathParts = propertyPath.split(".");
+        while (propertyPathParts.length > 1) {
+            const part = propertyPathParts[0];
+            if (!(alias === null || alias === void 0 ? void 0 : alias.hasMetadata)) {
+                // If there's no metadata, we're wasting our time
+                // and can't actually look any of this up.
+                break;
+            }
+            if (alias.metadata.hasEmbeddedWithPropertyPath(part)) {
+                // If this is an embedded then we should combine the two as part of our lookup.
+                // Instead of just breaking, we keep going with this in case there's an embedded/relation
+                // inside an embedded.
+                propertyPathParts.unshift(`${propertyPathParts.shift()}.${propertyPathParts.shift()}`);
+                continue;
+            }
+            if (alias.metadata.hasRelationWithPropertyPath(part)) {
+                // If this is a relation then we should find the aliases
+                // that match the relation & then continue further down
+                // the property path
+                const joinAttr = this.expressionMap.joinAttributes.find((joinAttr) => joinAttr.relationPropertyPath === part);
+                if (!(joinAttr === null || joinAttr === void 0 ? void 0 : joinAttr.alias)) {
+                    const fullRelationPath = root.length > 0 ? `${root.join(".")}.${part}` : part;
+                    throw new Error(`Cannot find alias for relation at ${fullRelationPath}`);
+                }
+                alias = joinAttr.alias;
+                root.push(...part.split("."));
+                propertyPathParts.shift();
+                continue;
+            }
+            break;
+        }
+        if (!alias) {
+            throw new Error(`Cannot find alias for property ${propertyPath}`);
+        }
+        // Remaining parts are combined back and used to find the actual property path
+        const aliasPropertyPath = propertyPathParts.join(".");
+        const columns = alias.metadata.findColumnsWithPropertyPath(aliasPropertyPath);
+        if (!columns.length) {
+            throw new EntityPropertyNotFoundError(propertyPath, alias.metadata);
+        }
+        return [alias, root, columns];
+    }
+    /**
+     * Creates a property paths for a given ObjectLiteral.
+     */
+    createPropertyPath(metadata, entity, prefix = "") {
+        const paths = [];
+        for (const key of Object.keys(entity)) {
+            const path = prefix ? `${prefix}.${key}` : key;
+            // There's times where we don't actually want to traverse deeper.
+            // If the value is a `FindOperator`, or null, or not an object, then we don't, for example.
+            if (entity[key] === null ||
+                typeof entity[key] !== "object" ||
+                InstanceChecker.isFindOperator(entity[key])) {
+                paths.push(path);
+                continue;
+            }
+            if (metadata.hasEmbeddedWithPropertyPath(path)) {
+                const subPaths = this.createPropertyPath(metadata, entity[key], path);
+                paths.push(...subPaths);
+                continue;
+            }
+            if (metadata.hasRelationWithPropertyPath(path)) {
+                const relation = metadata.findRelationWithPropertyPath(path);
+                // There's also cases where we don't want to return back all of the properties.
+                // These handles the situation where someone passes the model & we don't need to make
+                // a HUGE `where` to uniquely look up the entity.
+                // In the case of a *-to-one, there's only ever one possible entity on the other side
+                // so if the join columns are all defined we can return just the relation itself
+                // because it will fetch only the join columns and do the lookup.
+                if (relation.relationType === "one-to-one" ||
+                    relation.relationType === "many-to-one") {
+                    const joinColumns = relation.joinColumns
+                        .map((j) => j.referencedColumn)
+                        .filter((j) => !!j);
+                    const hasAllJoinColumns = joinColumns.length > 0 &&
+                        joinColumns.every((column) => column.getEntityValue(entity[key], false));
+                    if (hasAllJoinColumns) {
+                        paths.push(path);
+                        continue;
+                    }
+                }
+                if (relation.relationType === "one-to-many" ||
+                    relation.relationType === "many-to-many") {
+                    throw new Error(`Cannot query across ${relation.relationType} for property ${path}`);
+                }
+                // For any other case, if the `entity[key]` contains all of the primary keys we can do a
+                // lookup via these.  We don't need to look up via any other values 'cause these are
+                // the unique primary keys.
+                // This handles the situation where someone passes the model & we don't need to make
+                // a HUGE where.
+                const primaryColumns = relation.inverseEntityMetadata.primaryColumns;
+                const hasAllPrimaryKeys = primaryColumns.length > 0 &&
+                    primaryColumns.every((column) => column.getEntityValue(entity[key], false));
+                if (hasAllPrimaryKeys) {
+                    const subPaths = primaryColumns.map((column) => `${path}.${column.propertyPath}`);
+                    paths.push(...subPaths);
+                    continue;
+                }
+                // If nothing else, just return every property that's being passed to us.
+                const subPaths = this.createPropertyPath(relation.inverseEntityMetadata, entity[key]).map((p) => `${path}.${p}`);
+                paths.push(...subPaths);
+                continue;
+            }
+            paths.push(path);
+        }
+        return paths;
+    }
+    *getPredicates(where) {
+        if (this.expressionMap.mainAlias.hasMetadata) {
+            const propertyPaths = this.createPropertyPath(this.expressionMap.mainAlias.metadata, where);
+            for (const propertyPath of propertyPaths) {
+                const [alias, aliasPropertyPath, columns] = this.findColumnsForPropertyPath(propertyPath);
+                for (const column of columns) {
+                    let containedWhere = where;
+                    for (const part of aliasPropertyPath) {
+                        if (!containedWhere || !(part in containedWhere)) {
+                            containedWhere = {};
+                            break;
+                        }
+                        containedWhere = containedWhere[part];
+                    }
+                    // Use the correct alias & the property path from the column
+                    const aliasPath = this.expressionMap
+                        .aliasNamePrefixingEnabled
+                        ? `${alias.name}.${column.propertyPath}`
+                        : column.propertyPath;
+                    const parameterValue = column.getEntityValue(containedWhere, true);
+                    yield [aliasPath, parameterValue];
+                }
+            }
         }
         else {
-            var _b = tslib_1.__read(metadata.primaryColumns, 1), primaryColumn_2 = _b[0];
-            var normalizedValues = normalized.map(function (ent) { return ent[Object.keys(ent)[0]]; });
-            var areAllNumbers = normalizedValues.every(function (id) { return typeof id === "number"; });
-            if (areAllNumbers) {
-                return alias + this.escape(primaryColumn_2.databaseName) + " IN (" + normalizedValues.join(", ") + ")";
+            for (const key of Object.keys(where)) {
+                const parameterValue = where[key];
+                const aliasPath = this.expressionMap.aliasNamePrefixingEnabled
+                    ? `${this.alias}.${key}`
+                    : key;
+                yield [aliasPath, parameterValue];
+            }
+        }
+    }
+    getWherePredicateCondition(aliasPath, parameterValue) {
+        if (InstanceChecker.isFindOperator(parameterValue)) {
+            let parameters = [];
+            if (parameterValue.useParameter) {
+                if (parameterValue.objectLiteralParameters) {
+                    this.setParameters(parameterValue.objectLiteralParameters);
+                }
+                else if (parameterValue.multipleParameters) {
+                    for (const v of parameterValue.value) {
+                        parameters.push(this.createParameter(v));
+                    }
+                }
+                else {
+                    parameters.push(this.createParameter(parameterValue.value));
+                }
+            }
+            if (parameterValue.type === "raw") {
+                if (parameterValue.getSql) {
+                    return parameterValue.getSql(aliasPath);
+                }
+                else {
+                    return {
+                        operator: "equal",
+                        parameters: [aliasPath, parameterValue.value],
+                    };
+                }
+            }
+            else if (parameterValue.type === "not") {
+                if (parameterValue.child) {
+                    return {
+                        operator: parameterValue.type,
+                        condition: this.getWherePredicateCondition(aliasPath, parameterValue.child),
+                    };
+                }
+                else {
+                    return {
+                        operator: "notEqual",
+                        parameters: [aliasPath, ...parameters],
+                    };
+                }
             }
             else {
-                this.expressionMap.parameters["qb_ids"] = normalized.map(function (val) { return primaryColumn_2.getEntityValue(val, true); });
-                return alias + this.escape(primaryColumn_2.databaseName) + " IN (:...qb_ids)";
+                return {
+                    operator: parameterValue.type,
+                    parameters: [aliasPath, ...parameters],
+                };
             }
+            // } else if (parameterValue === null) {
+            //     return {
+            //         operator: "isNull",
+            //         parameters: [
+            //             aliasPath,
+            //         ]
+            //     };
         }
-    };
-    /**
-     * Computes given where argument - transforms to a where string all forms it can take.
-     */
-    QueryBuilder.prototype.computeWhereParameter = function (where) {
-        var _this = this;
-        if (typeof where === "string")
+        else {
+            return {
+                operator: "equal",
+                parameters: [aliasPath, this.createParameter(parameterValue)],
+            };
+        }
+    }
+    getWhereCondition(where) {
+        if (typeof where === "string") {
             return where;
-        if (where instanceof Brackets) {
-            var whereQueryBuilder = this.createQueryBuilder();
+        }
+        if (InstanceChecker.isBrackets(where)) {
+            const whereQueryBuilder = this.createQueryBuilder();
+            whereQueryBuilder.parentQueryBuilder = this;
+            whereQueryBuilder.expressionMap.mainAlias =
+                this.expressionMap.mainAlias;
+            whereQueryBuilder.expressionMap.aliasNamePrefixingEnabled =
+                this.expressionMap.aliasNamePrefixingEnabled;
+            whereQueryBuilder.expressionMap.parameters =
+                this.expressionMap.parameters;
+            whereQueryBuilder.expressionMap.nativeParameters =
+                this.expressionMap.nativeParameters;
+            whereQueryBuilder.expressionMap.wheres = [];
             where.whereFactory(whereQueryBuilder);
-            var whereString = whereQueryBuilder.createWhereExpressionString();
-            this.setParameters(whereQueryBuilder.getParameters());
-            return whereString ? "(" + whereString + ")" : "";
+            return {
+                operator: InstanceChecker.isNotBrackets(where)
+                    ? "not"
+                    : "brackets",
+                condition: whereQueryBuilder.expressionMap.wheres,
+            };
         }
-        else if (where instanceof Function) {
+        if (typeof where === "function") {
             return where(this);
         }
-        else if (where instanceof Object) {
-            var wheres = where instanceof Array ? where : [where];
-            var andConditions = void 0;
-            var parameterIndex_1 = Object.keys(this.expressionMap.nativeParameters).length;
-            if (this.expressionMap.mainAlias.hasMetadata) {
-                andConditions = wheres.map(function (where, whereIndex) {
-                    var propertyPaths = EntityMetadata.createPropertyPath(_this.expressionMap.mainAlias.metadata, where);
-                    return propertyPaths.map(function (propertyPath, propertyIndex) {
-                        var columns = _this.expressionMap.mainAlias.metadata.findColumnsWithPropertyPath(propertyPath);
-                        return columns.map(function (column, columnIndex) {
-                            var aliasPath = _this.expressionMap.aliasNamePrefixingEnabled ? _this.alias + "." + propertyPath : column.propertyPath;
-                            var parameterValue = column.getEntityValue(where, true);
-                            if (parameterValue === undefined)
-                                return;
-                            var parameterName = "where_" + whereIndex + "_" + propertyIndex + "_" + columnIndex;
-                            var parameterBaseCount = Object.keys(_this.expressionMap.nativeParameters).filter(function (x) { return x.startsWith(parameterName); }).length;
-                            if (parameterValue === null) {
-                                return aliasPath + " IS NULL";
-                            }
-                            else if (parameterValue instanceof FindOperator) {
-                                var parameters_1 = [];
-                                if (parameterValue.useParameter) {
-                                    var realParameterValues = parameterValue.multipleParameters ? parameterValue.value : [parameterValue.value];
-                                    realParameterValues.forEach(function (realParameterValue, realParameterValueIndex) {
-                                        // don't create parameters for number to prevent max number of variables issues as much as possible
-                                        if (typeof realParameterValue === "number") {
-                                            parameters_1.push(realParameterValue);
-                                        }
-                                        else {
-                                            _this.expressionMap.nativeParameters[parameterName + (parameterBaseCount + realParameterValueIndex)] = realParameterValue;
-                                            parameterIndex_1++;
-                                            parameters_1.push(_this.connection.driver.createParameter(parameterName + (parameterBaseCount + realParameterValueIndex), parameterIndex_1 - 1));
-                                        }
-                                    });
-                                }
-                                return parameterValue.toSql(_this.connection, aliasPath, parameters_1);
-                            }
-                            else {
-                                _this.expressionMap.nativeParameters[parameterName] = parameterValue;
-                                parameterIndex_1++;
-                                var parameter = _this.connection.driver.createParameter(parameterName, parameterIndex_1 - 1);
-                                return aliasPath + " = " + parameter;
-                            }
-                        }).filter(function (expression) { return !!expression; }).join(" AND ");
-                    }).filter(function (expression) { return !!expression; }).join(" AND ");
-                });
-            }
-            else {
-                andConditions = wheres.map(function (where, whereIndex) {
-                    return Object.keys(where).map(function (key, parameterIndex) {
-                        var parameterValue = where[key];
-                        var aliasPath = _this.expressionMap.aliasNamePrefixingEnabled ? _this.alias + "." + key : key;
-                        if (parameterValue === null) {
-                            return aliasPath + " IS NULL";
-                        }
-                        else {
-                            var parameterName = "where_" + whereIndex + "_" + parameterIndex;
-                            _this.expressionMap.nativeParameters[parameterName] = parameterValue;
-                            parameterIndex++;
-                            return aliasPath + " = " + _this.connection.driver.createParameter(parameterName, parameterIndex - 1);
-                        }
-                    }).join(" AND ");
+        const wheres = Array.isArray(where) ? where : [where];
+        const clauses = [];
+        for (const where of wheres) {
+            const conditions = [];
+            // Filter the conditions and set up the parameter values
+            for (const [aliasPath, parameterValue] of this.getPredicates(where)) {
+                conditions.push({
+                    type: "and",
+                    condition: this.getWherePredicateCondition(aliasPath, parameterValue),
                 });
             }
-            if (andConditions.length > 1)
-                return andConditions.map(function (where) { return "(" + where + ")"; }).join(" OR ");
-            return andConditions.join("");
+            clauses.push({ type: "or", condition: conditions });
         }
-        return "";
-    };
+        if (clauses.length === 1) {
+            return clauses[0].condition;
+        }
+        return clauses;
+    }
     /**
      * Creates a query builder used to execute sql queries inside this query builder.
      */
-    QueryBuilder.prototype.obtainQueryRunner = function () {
-        return this.queryRunner || this.connection.createQueryRunner("master");
-    };
-    return QueryBuilder;
-}());
-export { QueryBuilder };
+    obtainQueryRunner() {
+        return this.queryRunner || this.connection.createQueryRunner();
+    }
+}
 
 //# sourceMappingURL=QueryBuilder.js.map