for (const orderCriteria of Object.keys(
    this.expressionMap.allOrderBys,
)) {
    if (orderCriteria.indexOf(".") !== -1) {
        const criteriaParts = orderCriteria.split(".")
        const aliasName = criteriaParts[0]
        const propertyPath = criteriaParts.slice(1).join(".")
        const alias = this.expressionMap.findAliasByName(aliasName)
        if (!alias.hasMetadata) {
            const columnAlias = DriverUtils.buildAlias(
                this.connection.driver,
                undefined,
                aliasName,
                propertyPath,
            )
            originalQuery.expressionMap.selects.push({
                selection: `${aliasName}.${propertyPath}`,
                aliasName: columnAlias,
            })
        }
    }
}

if (orderCriteria.indexOf(".") !== -1) {
    const criteriaParts = orderCriteria.split(".")
    const aliasName = criteriaParts[0]
    const propertyPath = criteriaParts.slice(1).join(".")
    const alias = this.expressionMap.findAliasByName(aliasName)
    if (!alias.hasMetadata) {
        const columnAlias = DriverUtils.buildAlias(
            this.connection.driver,
            undefined,
            aliasName,
            propertyPath,
        )
        originalQuery.expressionMap.selects.push({
            selection: `${aliasName}.${propertyPath}`,
            aliasName: columnAlias,
        })
    }

protected replacePropertyNamesForTheWholeQuery(statement: string) {
    const replacements: { [key: string]: { [key: string]: string } } = {}
    const noMetadataAliasPrefixes = new Set<string>()

    for (const alias of this.expressionMap.aliases) {
        const replaceAliasNamePrefix =
            this.expressionMap.aliasNamePrefixingEnabled && alias.name
                ? `${alias.name}.`
                : ""

        if (!alias.hasMetadata) {
            if (replaceAliasNamePrefix) {
                noMetadataAliasPrefixes.add(replaceAliasNamePrefix)
            }
            continue
        }

        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 allPrefixKeys = [...replacementKeys, ...noMetadataAliasPrefixes]
    const replaceAliasNamePrefixes = allPrefixKeys
        .map((key) => escapeRegExp(key))
        .join("|")

    if (allPrefixKeys.length > 0) {
        statement = statement.replace(
            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: string, pre: string, p: string
                if (replaceAliasNamePrefixes) {
                    match = matches[0]
                    pre = matches[1]
                    p = matches[3]

                    if (
                        replacements[matches[2]] &&
                        replacements[matches[2]][p]
                    ) {
                        return `${pre}${this.escape(
                            matches[2].substring(0, matches[2].length - 1),
                        )}.${this.escape(replacements[matches[2]][p])}`
                    }

                    // For non-metadata aliases (e.g. subquery joins),
                    // escape both the alias name and property path as-is
                    if (noMetadataAliasPrefixes.has(matches[2])) {
                        return `${pre}${this.escape(
                            matches[2].substring(0, matches[2].length - 1),
                        )}.${this.escape(p)}`
                    }