@lakutata/orm 3.0.0 → 3.1.1

package/dist/vendor/typeorm/query-builder/QueryBuilder.js

@@ -0,0 +1,1217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBuilder = void 0;
+const QueryExpressionMap_1 = require("./QueryExpressionMap");
+const Brackets_1 = require("./Brackets");
+const FindOperator_1 = require("../find-options/FindOperator");
+const Equal_1 = require("../find-options/operator/Equal");
+const In_1 = require("../find-options/operator/In");
+const error_1 = require("../error");
+const EntityPropertyNotFoundError_1 = require("../error/EntityPropertyNotFoundError");
+const InstanceChecker_1 = require("../util/InstanceChecker");
+const escapeRegExp_1 = require("../util/escapeRegExp");
+// 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?)
+// todo: fix problem with long aliases eg getMaxIdentifierLength
+// todo: fix replacing in .select("COUNT(post.id) AS cnt") statement
+// todo: implement joinAlways in relations and relationId
+// todo: finish partial selection
+// todo: sugar methods like: .addCount and .selectCount, selectCountAndMap, selectSum, selectSumAndMap, ...
+// todo: implement @Select decorator
+// todo: add select and map functions
+// todo: implement relation/entity loading and setting them into properties within a separate query
+// .loadAndMap("post.categories", "post.categories", qb => ...)
+// .loadAndMap("post.categories", Category, qb => ...)
+/**
+ * Query types that mutate rows and therefore must not run with an empty WHERE
+ * that a caller intended to filter on.
+ */
+const WRITE_QUERY_TYPES = ["update", "delete", "soft-delete", "restore"];
+/**
+ * Allows to build complex sql queries in a fashion way and execute those queries.
+ */
+class QueryBuilder {
+    /**
+     * DataSource on which QueryBuilder was created.
+     *
+     * @deprecated since 1.0.0. Use {@link dataSource} instance instead.
+     */
+    get connection() {
+        return this.dataSource;
+    }
+    /**
+     * Contains all registered query builder classes.
+     */
+    static { this.queryBuilderRegistry = {}; }
+    /**
+     * QueryBuilder can be initialized from given Connection and QueryRunner objects or from given other QueryBuilder.
+     *
+     * @param connectionOrQueryBuilder
+     * @param queryRunner
+     */
+    constructor(connectionOrQueryBuilder, queryRunner) {
+        this["@instanceof"] = Symbol.for("QueryBuilder");
+        /**
+         * Memo to help keep place of current parameter index for `createParameter`
+         */
+        this.parameterIndex = 0;
+        if (InstanceChecker_1.InstanceChecker.isDataSource(connectionOrQueryBuilder)) {
+            this.dataSource = connectionOrQueryBuilder;
+            this.queryRunner = queryRunner;
+            this.expressionMap = new QueryExpressionMap_1.QueryExpressionMap(this.dataSource);
+        }
+        else {
+            this.dataSource = connectionOrQueryBuilder.dataSource;
+            this.queryRunner = connectionOrQueryBuilder.queryRunner;
+            this.expressionMap = connectionOrQueryBuilder.expressionMap.clone();
+        }
+    }
+    static registerQueryBuilderClass(name, factory) {
+        QueryBuilder.queryBuilderRegistry[name] = factory;
+    }
+    // -------------------------------------------------------------------------
+    // Accessors
+    // -------------------------------------------------------------------------
+    /**
+     * Gets the main alias string used in this query builder.
+     */
+    get alias() {
+        if (!this.expressionMap.mainAlias)
+            throw new error_1.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.
+     *
+     * @param selection
+     * @param selectionAliasName
+     */
+    select(selection, selectionAliasName) {
+        this.expressionMap.queryType = "select";
+        if (Array.isArray(selection)) {
+            this.expressionMap.selects = selection.map((selection) => ({
+                selection: selection,
+            }));
+        }
+        else if (selection) {
+            this.expressionMap.selects = [
+                { selection: selection, aliasName: selectionAliasName },
+            ];
+        }
+        if (InstanceChecker_1.InstanceChecker.isSelectQueryBuilder(this))
+            return this;
+        return QueryBuilder.queryBuilderRegistry["SelectQueryBuilder"](this);
+    }
+    /**
+     * Creates INSERT query.
+     */
+    insert() {
+        this.expressionMap.queryType = "insert";
+        if (InstanceChecker_1.InstanceChecker.isInsertQueryBuilder(this))
+            return this;
+        return QueryBuilder.queryBuilderRegistry["InsertQueryBuilder"](this);
+    }
+    /**
+     * Creates UPDATE query and applies given update values.
+     *
+     * @param entityOrTableNameUpdateSet
+     * @param maybeUpdateSet
+     */
+    update(entityOrTableNameUpdateSet, maybeUpdateSet) {
+        const updateSet = maybeUpdateSet ??
+            entityOrTableNameUpdateSet;
+        entityOrTableNameUpdateSet = InstanceChecker_1.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;
+        if (InstanceChecker_1.InstanceChecker.isUpdateQueryBuilder(this))
+            return this;
+        return QueryBuilder.queryBuilderRegistry["UpdateQueryBuilder"](this);
+    }
+    /**
+     * Creates DELETE query.
+     */
+    delete() {
+        this.expressionMap.queryType = "delete";
+        if (InstanceChecker_1.InstanceChecker.isDeleteQueryBuilder(this))
+            return this;
+        return QueryBuilder.queryBuilderRegistry["DeleteQueryBuilder"](this);
+    }
+    softDelete() {
+        this.expressionMap.queryType = "soft-delete";
+        if (InstanceChecker_1.InstanceChecker.isSoftDeleteQueryBuilder(this))
+            return this;
+        return QueryBuilder.queryBuilderRegistry["SoftDeleteQueryBuilder"](this);
+    }
+    restore() {
+        this.expressionMap.queryType = "restore";
+        if (InstanceChecker_1.InstanceChecker.isSoftDeleteQueryBuilder(this))
+            return this;
+        return QueryBuilder.queryBuilderRegistry["SoftDeleteQueryBuilder"](this);
+    }
+    /**
+     * Sets entity's relation with which this query builder gonna work.
+     *
+     * @param entityTargetOrPropertyPath
+     * @param maybePropertyPath
+     */
+    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) {
+            const mainAlias = this.createFromAlias(entityTarget);
+            this.expressionMap.setMainAlias(mainAlias);
+        }
+        if (InstanceChecker_1.InstanceChecker.isRelationQueryBuilder(this))
+            return this;
+        return QueryBuilder.queryBuilderRegistry["RelationQueryBuilder"](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?
+     *
+     * @param target
+     * @param relation
+     */
+    hasRelation(target, relation) {
+        const entityMetadata = this.dataSource.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.
+     *
+     * @param key
+     */
+    hasParameter(key) {
+        return (this.parentQueryBuilder?.hasParameter(key) ||
+            key in this.expressionMap.parameters);
+    }
+    /**
+     * Sets parameter name and its value.
+     *
+     * The key for this parameter may contain numbers, letters, underscores, or periods.
+     *
+     * @param key
+     * @param value
+     */
+    setParameter(key, value) {
+        if (typeof value === "function") {
+            throw new error_1.TypeORMError(`Function parameter isn't supported in the parameters. Please check "${key}" parameter.`);
+        }
+        if (!key.match(/^([A-Za-z0-9_.]+)$/)) {
+            throw new error_1.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.
+     *
+     * @param parameters
+     */
+    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}`;
+    }
+    /**
+     * Gets all parameters.
+     */
+    getParameters() {
+        const parameters = Object.assign({}, this.expressionMap.parameters);
+        // add discriminator column parameter if it exist
+        if (this.expressionMap.mainAlias?.hasMetadata) {
+            const metadata = this.expressionMap.mainAlias.metadata;
+            if (metadata.discriminatorColumn && metadata.parentEntityMetadata) {
+                const values = metadata.childEntityMetadatas
+                    .filter((childMetadata) => childMetadata.discriminatorColumn)
+                    .map((childMetadata) => childMetadata.discriminatorValue);
+                values.push(metadata.discriminatorValue);
+                parameters["discriminatorColumnValues"] = values;
+            }
+        }
+        return parameters;
+    }
+    /**
+     * Gets generated sql that will be executed.
+     * Parameters in the query are escaped for the currently used driver.
+     */
+    getSql() {
+        return this.getQueryAndParameters()[0];
+    }
+    /**
+     * Gets query to be executed with all parameters used in it.
+     */
+    getQueryAndParameters() {
+        const query = this.getQuery();
+        const parameters = this.getParameters();
+        return this.dataSource.driver.escapeQueryWithParameters(query, parameters);
+    }
+    /**
+     * Executes sql generated by query builder and returns raw database results.
+     */
+    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.
+     *
+     * @param queryRunner
+     */
+    createQueryBuilder(queryRunner) {
+        return new this.constructor(this.dataSource, queryRunner ?? 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.
+     */
+    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.
+     *
+     * @param comment
+     */
+    comment(comment) {
+        this.expressionMap.comment = comment;
+        return this;
+    }
+    /**
+     * Disables escaping.
+     */
+    disableEscaping() {
+        this.expressionMap.disableEscaping = false;
+        return this;
+    }
+    /**
+     * Escapes table name, column name or alias name using current database's escaping character.
+     *
+     * @param name
+     */
+    escape(name) {
+        if (!this.expressionMap.disableEscaping)
+            return name;
+        return this.dataSource.driver.escape(name);
+    }
+    /**
+     * Sets or overrides query builder's QueryRunner.
+     *
+     * @param queryRunner
+     */
+    setQueryRunner(queryRunner) {
+        this.queryRunner = queryRunner;
+        return this;
+    }
+    /**
+     * Indicates if listeners and subscribers must be called before and after query execution.
+     * Enabled by default.
+     *
+     * @param enabled
+     */
+    callListeners(enabled) {
+        this.expressionMap.callListeners = enabled;
+        return this;
+    }
+    /**
+     * If set to true the query will be wrapped into a transaction.
+     *
+     * @param enabled
+     */
+    useTransaction(enabled) {
+        this.expressionMap.useTransaction = enabled;
+        return this;
+    }
+    /**
+     * Adds CTE to query
+     *
+     * @param queryBuilder
+     * @param alias
+     * @param options
+     */
+    addCommonTableExpression(queryBuilder, alias, options) {
+        this.expressionMap.commonTableExpressions.push({
+            queryBuilder,
+            alias,
+            options: options ?? {},
+        });
+        return this;
+    }
+    // -------------------------------------------------------------------------
+    // Protected Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Gets escaped table name with schema name if SqlServer driver used with custom
+     * schema name, otherwise returns escaped table name.
+     *
+     * @param tablePath
+     */
+    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(".");
+    }
+    /**
+     * Gets name of the table where insert should be performed.
+     */
+    getMainTableName() {
+        if (!this.expressionMap.mainAlias)
+            throw new error_1.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.
+     *
+     * @param entityTarget
+     * @param aliasName
+     */
+    createFromAlias(entityTarget, aliasName) {
+        // if table has a metadata then find it to properly escape its properties
+        // const metadata = this.dataSource.entityMetadatas.find(metadata => metadata.tableName === tableName);
+        if (this.dataSource.hasMetadata(entityTarget)) {
+            const metadata = this.dataSource.getMetadata(entityTarget);
+            return this.expressionMap.createAlias({
+                type: "from",
+                name: aliasName,
+                metadata: this.dataSource.getMetadata(entityTarget),
+                tablePath: metadata.tablePath,
+            });
+        }
+        else {
+            if (typeof entityTarget === "string") {
+                const isSubquery = entityTarget.startsWith("(") && entityTarget.endsWith(")");
+                return this.expressionMap.createAlias({
+                    type: "from",
+                    name: aliasName,
+                    tablePath: !isSubquery
+                        ? entityTarget
+                        : undefined,
+                    subQuery: isSubquery ? entityTarget : undefined,
+                });
+            }
+            const subQueryBuilder = entityTarget(this.subQuery());
+            this.setParameters(subQueryBuilder.getParameters());
+            const subquery = subQueryBuilder.getQuery();
+            return this.expressionMap.createAlias({
+                type: "from",
+                name: aliasName,
+                subQuery: subquery,
+            });
+        }
+    }
+    /**
+     * Replaces all entity's propertyName to name in the given SQL string.
+     *
+     * @param statement
+     */
+    replacePropertyNamesForTheWholeQuery(statement) {
+        const replacements = {};
+        for (const alias of this.expressionMap.aliases) {
+            if (!alias.hasMetadata)
+                continue;
+            const replaceAliasNamePrefix = this.expressionMap.aliasNamePrefixingEnabled && alias.name
+                ? `${alias.name}.`
+                : "";
+            if (!replacements[replaceAliasNamePrefix]) {
+                replacements[replaceAliasNamePrefix] = {};
+            }
+            // 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 Property Name
+            // * Column Property Path
+            for (const relation of alias.metadata.relations) {
+                if (relation.joinColumns.length > 0)
+                    replacements[replaceAliasNamePrefix][relation.propertyPath] = relation.joinColumns[0].databaseName;
+            }
+            for (const relation of alias.metadata.relations) {
+                const allColumns = [
+                    ...relation.joinColumns,
+                    ...relation.inverseJoinColumns,
+                ];
+                for (const joinColumn of allColumns) {
+                    const propertyKey = `${relation.propertyPath}.${joinColumn.referencedColumn.propertyPath}`;
+                    replacements[replaceAliasNamePrefix][propertyKey] =
+                        joinColumn.databaseName;
+                }
+            }
+            for (const column of alias.metadata.columns) {
+                replacements[replaceAliasNamePrefix][column.databaseName] =
+                    column.databaseName;
+            }
+            for (const column of alias.metadata.columns) {
+                replacements[replaceAliasNamePrefix][column.propertyName] =
+                    column.databaseName;
+            }
+            for (const column of alias.metadata.columns) {
+                replacements[replaceAliasNamePrefix][column.propertyPath] =
+                    column.databaseName;
+            }
+        }
+        const replacementKeys = Object.keys(replacements);
+        const replaceAliasNamePrefixes = replacementKeys
+            .map((key) => (0, escapeRegExp_1.escapeRegExp)(key))
+            .join("|");
+        if (replacementKeys.length > 0) {
+            statement = statement.replaceAll(new RegExp(
+            // Avoid a lookbehind here since it's not well supported
+            `([ =(]|^.{0})` + // any of ' =(' or start of line
+                // followed by our prefix, e.g. 'tablename.' or ''
+                `${replaceAliasNamePrefixes
+                    ? "(" + replaceAliasNamePrefixes + ")"
+                    : ""}([^ =(),]+)` + // a possible property name: sequence of anything but ' =(),'
+                // terminated by ' =),' or end of line
+                `(?=[ =),]|.{0}$)`, "gm"), (...matches) => {
+                let match, pre, p;
+                if (replaceAliasNamePrefixes) {
+                    match = matches[0];
+                    pre = matches[1];
+                    p = matches[3];
+                    if (replacements[matches[2]][p]) {
+                        return `${pre}${this.escape(matches[2].slice(0, -1))}.${this.escape(replacements[matches[2]][p])}`;
+                    }
+                }
+                else {
+                    match = matches[0];
+                    pre = matches[1];
+                    p = matches[2];
+                    if (replacements[""][p]) {
+                        return `${pre}${this.escape(replacements[""][p])}`;
+                    }
+                }
+                return match;
+            });
+        }
+        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.replaceAll("*/", "")} */ `;
+    }
+    /**
+     * Time travel queries for CockroachDB
+     */
+    createTimeTravelQuery() {
+        if (this.expressionMap.queryType === "select" &&
+            this.expressionMap.timeTravel) {
+            return ` AS OF SYSTEM TIME ${this.expressionMap.timeTravel}`;
+        }
+        return "";
+    }
+    /**
+     * Creates "WHERE" expression.
+     */
+    createWhereExpression() {
+        const conditionsArray = [];
+        const whereExpression = this.createWhereClausesExpression(this.expressionMap.wheres);
+        // A write operation whose provided WHERE renders empty ("1=1") would
+        // silently affect every row. Reject it instead of emitting an unfiltered
+        // statement — this also covers criteria that only look non-empty at the
+        // top level but expand to zero predicates (e.g. a relation key whose
+        // value is a keyless object). Build the query without a WHERE to
+        // intentionally affect all rows.
+        if (WRITE_QUERY_TYPES.includes(this.expressionMap.queryType) &&
+            this.expressionMap.wheres.length > 0 &&
+            (whereExpression.length === 0 || whereExpression === "1=1")) {
+            throw new error_1.TypeORMError(`Empty criteria(s) are not allowed for the ${this.expressionMap.queryType} operation. ` +
+                `Provide a WHERE condition, or build the query without one to intentionally affect all rows.`);
+        }
+        if (whereExpression.length > 0 && whereExpression !== "1=1") {
+            conditionsArray.push(whereExpression);
+        }
+        if (this.expressionMap.mainAlias.hasMetadata) {
+            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 = `${column} IS NULL`;
+                conditionsArray.push(condition);
+            }
+            if (metadata.discriminatorColumn && metadata.parentEntityMetadata) {
+                const column = this.expressionMap.aliasNamePrefixingEnabled
+                    ? this.expressionMap.mainAlias.name +
+                        "." +
+                        metadata.discriminatorColumn.databaseName
+                    : metadata.discriminatorColumn.databaseName;
+                const condition = `${column} IN (:...discriminatorColumnValues)`;
+                conditionsArray.push(condition);
+            }
+        }
+        if (this.expressionMap.extraAppendedAndWhereCondition) {
+            conditionsArray.push(this.expressionMap.extraAppendedAndWhereCondition);
+        }
+        let condition = "";
+        // time travel
+        condition += this.createTimeTravelQuery();
+        if (!conditionsArray.length) {
+            condition += "";
+        }
+        else if (conditionsArray.length === 1) {
+            condition += ` WHERE ${conditionsArray[0]}`;
+        }
+        else {
+            condition += ` WHERE ( ${conditionsArray.join(" ) AND ( ")} )`;
+        }
+        return condition;
+    }
+    /**
+     * Creates "RETURNING" / "OUTPUT" expression.
+     *
+     * @param returningType
+     */
+    createReturningExpression(returningType) {
+        const columns = this.getReturningColumns();
+        const driver = this.dataSource.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(returningType)) {
+            columns.push(...this.expressionMap.extraReturningColumns.filter((column) => {
+                return columns.indexOf(column) === -1;
+            }));
+        }
+        if (columns.length) {
+            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);
+                    }
+                }
+                else {
+                    return name;
+                }
+            })
+                .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;
+        }
+        else if (typeof this.expressionMap.returning === "string") {
+            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.
+     */
+    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;
+    }
+    createWhereClausesExpression(clauses) {
+        return clauses
+            .map((clause, index) => {
+            const expression = this.createWhereConditionExpression(clause.condition);
+            switch (clause.type) {
+                case "and":
+                    return ((index > 0 ? "AND " : "") +
+                        `${this.dataSource.options.isolateWhereStatements
+                            ? "("
+                            : ""}${expression}${this.dataSource.options.isolateWhereStatements
+                            ? ")"
+                            : ""}`);
+                case "or":
+                    return ((index > 0 ? "OR " : "") +
+                        `${this.dataSource.options.isolateWhereStatements
+                            ? "("
+                            : ""}${expression}${this.dataSource.options.isolateWhereStatements
+                            ? ")"
+                            : ""}`);
+            }
+            return expression;
+        })
+            .join(" ")
+            .trim();
+    }
+    /**
+     * Computes given where argument - transforms to a where string all forms it can take.
+     *
+     * @param condition
+     * @param alwaysWrap
+     */
+    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.dataSource;
+        switch (condition.operator) {
+            case "lessThan":
+                return `${condition.parameters[0]} < ${condition.parameters[1]}`;
+            case "lessThanOrEqual":
+                return `${condition.parameters[0]} <= ${condition.parameters[1]}`;
+            case "arrayContains":
+                return `${condition.parameters[0]} @> ${condition.parameters[1]}`;
+            case "jsonContains":
+                return `${condition.parameters[0]} ::jsonb @> ${condition.parameters[1]}`;
+            case "arrayContainedBy":
+                return `${condition.parameters[0]} <@ ${condition.parameters[1]}`;
+            case "arrayOverlap":
+                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":
+                if (driver.options.type === "cockroachdb") {
+                    return `${condition.parameters[0]}::STRING = ANY(${condition.parameters[1]}::STRING[])`;
+                }
+                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)}`;
+            case "and":
+                return "(" + condition.parameters.join(" AND ") + ")";
+            case "or":
+                return "(" + condition.parameters.join(" OR ") + ")";
+        }
+        throw new TypeError(`Unsupported FindOperator ${FindOperator_1.FindOperator.constructor.name}`);
+    }
+    createCteExpression() {
+        if (!this.hasCommonTableExpressions()) {
+            return "";
+        }
+        let hasRecursiveCTEs = false;
+        const doesDbRequireRecursiveHint = this.dataSource.driver.cteCapabilities.requiresRecursiveHint;
+        const cteStrings = this.expressionMap.commonTableExpressions.map((cte) => {
+            let cteBodyExpression = typeof cte.queryBuilder === "string" ? cte.queryBuilder : "";
+            if (typeof cte.queryBuilder !== "string") {
+                if (cte.queryBuilder.hasCommonTableExpressions()) {
+                    throw new error_1.TypeORMError(`Nested CTEs aren't supported (CTE: ${cte.alias})`);
+                }
+                cteBodyExpression = cte.queryBuilder.getQuery();
+                if (!this.dataSource.driver.cteCapabilities.writable &&
+                    !InstanceChecker_1.InstanceChecker.isSelectQueryBuilder(cte.queryBuilder)) {
+                    throw new error_1.TypeORMError(`Only select queries are supported in CTEs in ${this.dataSource.options.type} (CTE: ${cte.alias})`);
+                }
+                this.setParameters(cte.queryBuilder.getParameters());
+            }
+            let cteHeader = this.escape(cte.alias);
+            if (cte.options.columnNames) {
+                const escapedColumnNames = cte.options.columnNames.map((column) => this.escape(column));
+                if (InstanceChecker_1.InstanceChecker.isSelectQueryBuilder(cte.queryBuilder)) {
+                    if (cte.queryBuilder.expressionMap.selects.length &&
+                        cte.options.columnNames.length !==
+                            cte.queryBuilder.expressionMap.selects.length) {
+                        throw new error_1.TypeORMError(`cte.options.columnNames length (${cte.options.columnNames.length}) doesn't match subquery select list length ${cte.queryBuilder.expressionMap.selects.length} (CTE: ${cte.alias})`);
+                    }
+                }
+                cteHeader += `(${escapedColumnNames.join(", ")})`;
+            }
+            if (cte.options.recursive) {
+                hasRecursiveCTEs = true;
+            }
+            let materializeClause = "";
+            if (this.dataSource.driver.cteCapabilities.materializedHint &&
+                cte.options.materialized !== undefined) {
+                materializeClause = cte.options.materialized
+                    ? "MATERIALIZED"
+                    : "NOT MATERIALIZED";
+            }
+            return [
+                cteHeader,
+                "AS",
+                materializeClause,
+                `(${cteBodyExpression})`,
+            ]
+                .filter(Boolean)
+                .join(" ");
+        });
+        const recursiveClause = hasRecursiveCTEs && doesDbRequireRecursiveHint ? "RECURSIVE " : "";
+        return "WITH " + recursiveClause + cteStrings.join(", ") + " ";
+    }
+    /**
+     * Creates "WHERE" condition for an in-ids condition.
+     *
+     * @param ids
+     */
+    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) {
+            const primaryColumn = metadata.primaryColumns[0];
+            // getEntityValue will try to transform `In`, it is a bug
+            // todo: remove this transformer check after #2390 is fixed
+            // This also fails for embedded & relation, so until that is fixed skip it.
+            if (!primaryColumn.transformer &&
+                !primaryColumn.relationMetadata &&
+                !primaryColumn.embeddedMetadata) {
+                const values = normalized.map((id) => primaryColumn.getEntityValue(id, false));
+                return {
+                    [primaryColumn.propertyName]: values.length === 1 ? (0, Equal_1.Equal)(values[0]) : (0, In_1.In)(values),
+                };
+            }
+        }
+        return new Brackets_1.Brackets((qb) => {
+            for (const data of normalized) {
+                qb.orWhere(new Brackets_1.Brackets((qb) => qb.where(data)));
+            }
+        });
+    }
+    getExistsCondition(subQuery) {
+        const query = subQuery
+            .clone()
+            .orderBy()
+            .groupBy()
+            .offset(undefined)
+            .limit(undefined)
+            .skip(undefined)
+            .take(undefined)
+            .select("1")
+            .setOption("disable-global-order");
+        return [`EXISTS (${query.getQuery()})`, query.getParameters()];
+    }
+    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?.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?.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_1.EntityPropertyNotFoundError(propertyPath, alias.metadata);
+        }
+        return [alias, root, columns];
+    }
+    /**
+     * Creates a property paths for a given ObjectLiteral.
+     *
+     * @param metadata
+     * @param entity
+     * @param prefix
+     */
+    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_1.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;
+                    }
+                }
+                // 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 {
+            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_1.InstanceChecker.isFindOperator(parameterValue)) {
+            const 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 {
+                    let value = parameterValue.value;
+                    if (parameterValue.type === "jsonContains" &&
+                        value !== null &&
+                        typeof value === "object") {
+                        value = JSON.stringify(value);
+                    }
+                    parameters.push(this.createParameter(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 if (parameterValue.type === "and") {
+                const values = parameterValue.value;
+                return {
+                    operator: parameterValue.type,
+                    parameters: values.map((operator) => this.createWhereConditionExpression(this.getWherePredicateCondition(aliasPath, operator))),
+                };
+            }
+            else if (parameterValue.type === "or") {
+                const values = parameterValue.value;
+                return {
+                    operator: parameterValue.type,
+                    parameters: values.map((operator) => this.createWhereConditionExpression(this.getWherePredicateCondition(aliasPath, operator))),
+                };
+            }
+            else {
+                return {
+                    operator: parameterValue.type,
+                    parameters: [aliasPath, ...parameters],
+                };
+            }
+        }
+        return {
+            operator: "equal",
+            parameters: [aliasPath, this.createParameter(parameterValue)],
+        };
+    }
+    getWhereCondition(where) {
+        if (typeof where === "string") {
+            return where;
+        }
+        if (InstanceChecker_1.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.joinAttributes =
+                this.expressionMap.joinAttributes;
+            whereQueryBuilder.expressionMap.wheres = [];
+            where.whereFactory(whereQueryBuilder);
+            return {
+                operator: InstanceChecker_1.InstanceChecker.isNotBrackets(where)
+                    ? "not"
+                    : "brackets",
+                condition: whereQueryBuilder.expressionMap.wheres,
+            };
+        }
+        if (typeof where === "function") {
+            return where(this);
+        }
+        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),
+                });
+            }
+            clauses.push({ type: "or", condition: conditions });
+        }
+        if (clauses.length === 1) {
+            return clauses[0].condition;
+        }
+        return clauses;
+    }
+    /**
+     * Creates a query builder used to execute sql queries inside this query builder.
+     */
+    obtainQueryRunner() {
+        return this.queryRunner ?? this.dataSource.createQueryRunner();
+    }
+    hasCommonTableExpressions() {
+        return this.expressionMap.commonTableExpressions.length > 0;
+    }
+    validateOrderByCondition(sort) {
+        const validOrders = ["ASC", "DESC"];
+        const validNulls = ["NULLS FIRST", "NULLS LAST"];
+        for (const [key, value] of Object.entries(sort)) {
+            if (typeof value === "string") {
+                if (!validOrders.includes(value))
+                    throw new error_1.TypeORMError(`Invalid order direction "${value}" for "${key}". Allowed values: ${validOrders.join(", ")}.`);
+            }
+            else if (typeof value === "object" && value !== null) {
+                if (!validOrders.includes(value.order))
+                    throw new error_1.TypeORMError(`Invalid order direction "${value.order}" for "${key}". Allowed values: ${validOrders.join(", ")}.`);
+                if (value.nulls !== undefined &&
+                    !validNulls.includes(value.nulls))
+                    throw new error_1.TypeORMError(`Invalid nulls option "${value.nulls}" for "${key}". Allowed values: ${validNulls.join(", ")}.`);
+            }
+            else {
+                throw new error_1.TypeORMError(`Invalid order-by value for "${key}". Expected "ASC", "DESC", or { order, nulls } object.`);
+            }
+        }
+    }
+    normalizeNumber(num) {
+        if (typeof num === "number" || num === undefined || num === null)
+            return num;
+        return Number(num);
+    }
+    /**
+     * Normalizes and validates a numeric query parameter,
+     * throwing if the result is NaN.
+     *
+     * @param label
+     * @param num
+     */
+    validateNumericInput(label, num) {
+        const normalized = this.normalizeNumber(num);
+        if (normalized !== undefined && isNaN(normalized))
+            throw new error_1.TypeORMError(`Provided "${label}" value is not a number. Please provide a numeric value.`);
+        return normalized;
+    }
+}
+exports.QueryBuilder = QueryBuilder;
+//# sourceMappingURL=QueryBuilder.js.map