typeorm / typeorm / 23191639722

import type { ObjectLiteral } from "../../common/ObjectLiteral"

import { TypeORMError } from "../../error"

import { QueryFailedError } from "../../error/QueryFailedError"

import { QueryRunnerAlreadyReleasedError } from "../../error/QueryRunnerAlreadyReleasedError"

import { TransactionNotStartedError } from "../../error/TransactionNotStartedError"

import type { ReadStream } from "../../platform/PlatformTools"

import { BaseQueryRunner } from "../../query-runner/BaseQueryRunner"

import { QueryResult } from "../../query-runner/QueryResult"

import type { QueryRunner } from "../../query-runner/QueryRunner"

import { Table } from "../../schema-builder/table/Table"

import { TableCheck } from "../../schema-builder/table/TableCheck"

import { TableColumn } from "../../schema-builder/table/TableColumn"

import type { TableExclusion } from "../../schema-builder/table/TableExclusion"

import { TableForeignKey } from "../../schema-builder/table/TableForeignKey"

import { TableIndex } from "../../schema-builder/table/TableIndex"

import { TableUnique } from "../../schema-builder/table/TableUnique"

import { View } from "../../schema-builder/view/View"

import { Broadcaster } from "../../subscriber/Broadcaster"

import { BroadcasterResult } from "../../subscriber/BroadcasterResult"

import { InstanceChecker } from "../../util/InstanceChecker"

import { OrmUtils } from "../../util/OrmUtils"

import { Query } from "../Query"

import type { ColumnType } from "../types/ColumnTypes"

import type { IsolationLevel } from "../types/IsolationLevel"

import { MetadataTableType } from "../types/MetadataTableType"

import type { ReplicationMode } from "../types/ReplicationMode"

import type { OracleDriver } from "./OracleDriver"

/**

 * Runs queries on a single oracle database connection.

 */

export class OracleQueryRunner extends BaseQueryRunner implements QueryRunner {

    // -------------------------------------------------------------------------

    // Public Implemented Properties

    // -------------------------------------------------------------------------

    /**

     * Database driver used by connection.

     */

    driver: OracleDriver

    // -------------------------------------------------------------------------

    // Protected Properties

    // -------------------------------------------------------------------------

    /**

     * Promise used to obtain a database connection for a first time.

     */

    protected databaseConnectionPromise: Promise<any>

    // -------------------------------------------------------------------------

    // Constructor

    // -------------------------------------------------------------------------

    constructor(driver: OracleDriver, mode: ReplicationMode) {

        super()

        this.driver = driver

        this.connection = driver.connection

        this.broadcaster = new Broadcaster(this)

        this.mode = mode

    }

    // -------------------------------------------------------------------------

    // Public Methods

    // -------------------------------------------------------------------------

    /**

     * Creates/uses database connection from the connection pool to perform further operations.

     * Returns obtained database connection.

     */

    connect(): Promise<any> {

        if (this.databaseConnection)

            return Promise.resolve(this.databaseConnection)

        if (this.databaseConnectionPromise)

            return this.databaseConnectionPromise

        } else {

            // master

            this.databaseConnectionPromise = this.driver

                .obtainMasterConnection()

                .then((connection) => {

                    this.databaseConnection = connection

                    return this.databaseConnection

                })

        }

        return this.databaseConnectionPromise

    }

    /**

     * Releases used database connection.

     * You cannot use query runner methods once its released.

     */

    async release(): Promise<void> {

        this.isReleased = true

        if (!this.databaseConnection) {

            return

        }

        await this.databaseConnection.close()

    }

    /**

     * Starts transaction.

     * @param isolationLevel

     */

    async startTransaction(

        isolationLevel: IsolationLevel = "READ COMMITTED",

    ): Promise<void> {

        // await this.query("START TRANSACTION");

        if (

            isolationLevel !== "SERIALIZABLE" &&

            isolationLevel !== "READ COMMITTED"

        this.isTransactionActive = true

        try {

            await this.broadcaster.broadcast("BeforeTransactionStart")

        if (this.transactionDepth === 0) {

            await this.query(

                "SET TRANSACTION ISOLATION LEVEL " + isolationLevel,

            )

        } else {

            await this.query(`SAVEPOINT typeorm_${this.transactionDepth}`)

        }

        this.transactionDepth += 1

        await this.broadcaster.broadcast("AfterTransactionStart")

    }

    /**

     * Commits transaction.

     * Error will be thrown if transaction was not started.

     */

    async commitTransaction(): Promise<void> {

        await this.broadcaster.broadcast("BeforeTransactionCommit")

        if (this.transactionDepth === 1) {

            await this.query("COMMIT")

            this.isTransactionActive = false

        }

        this.transactionDepth -= 1

        await this.broadcaster.broadcast("AfterTransactionCommit")

    }

    /**

     * Rollbacks transaction.

     * Error will be thrown if transaction was not started.

     */

    async rollbackTransaction(): Promise<void> {

        await this.broadcaster.broadcast("BeforeTransactionRollback")

        if (this.transactionDepth > 1) {

            await this.query(

                `ROLLBACK TO SAVEPOINT typeorm_${this.transactionDepth - 1}`,

            )

        } else {

            await this.query("ROLLBACK")

            this.isTransactionActive = false

        }

        this.transactionDepth -= 1

        await this.broadcaster.broadcast("AfterTransactionRollback")

    }

    /**

     * Executes a given SQL query.

     * @param query

     * @param parameters

     * @param useStructuredResult

     */

    async query(

        query: string,

        parameters?: any[],

        useStructuredResult = false,

    ): Promise<any> {

        const databaseConnection = await this.connect()

        this.driver.connection.logger.logQuery(query, parameters, this)

        await this.broadcaster.broadcast("BeforeQuery", query, parameters)

        const broadcasterResult = new BroadcasterResult()

        const queryStartTime = Date.now()

        try {

            const executionOptions = {

                autoCommit: !this.isTransactionActive,

                outFormat: this.driver.oracle.OUT_FORMAT_OBJECT,

            }

            const raw = await databaseConnection.execute(

                query,

                parameters || {},

                executionOptions,

            )

            // log slow queries if maxQueryExecution time is set

            const maxQueryExecutionTime =

                this.driver.options.maxQueryExecutionTime

            const queryEndTime = Date.now()

            const queryExecutionTime = queryEndTime - queryStartTime

            this.broadcaster.broadcastAfterQueryEvent(

                broadcasterResult,

                query,

                parameters,

                true,

                queryExecutionTime,

                raw,

                undefined,

            )

            if (

            )

            const result = new QueryResult()

            result.raw =

                raw.rows ||

                raw.outBinds ||

                raw.rowsAffected ||

                raw.implicitResults

            if (raw?.hasOwnProperty("rows") && Array.isArray(raw.rows)) {

                result.records = raw.rows

            }

            if (

                raw?.hasOwnProperty("outBinds") &&

                Array.isArray(raw.outBinds)

            ) {

                result.records = raw.outBinds

            }

            if (

                raw?.hasOwnProperty("implicitResults") &&

                Array.isArray(raw.implicitResults)

            ) {

                result.records = raw.implicitResults

            }

            if (raw?.hasOwnProperty("rowsAffected")) {

                result.affected = raw.rowsAffected

            }

            if (useStructuredResult) {

                return result

            } else {

                return result.raw

            }

        } catch (err) {

            this.driver.connection.logger.logQueryError(

                err,

                query,

                parameters,

                this,

            )

            this.broadcaster.broadcastAfterQueryEvent(

                broadcasterResult,

                query,

                parameters,

                false,

                undefined,

                undefined,

                err,

            )

            throw new QueryFailedError(query, parameters, err)

            await broadcasterResult.wait()

        }

    }

    /**

     * Returns raw data stream.

     * @param query

     * @param parameters

     * @param onEnd

     * @param onError

     */

    async stream(

        query: string,

        parameters?: any[],

        onEnd?: Function,

        onError?: Function,

    ): Promise<ReadStream> {

        const executionOptions = {

            autoCommit: !this.isTransactionActive,

            outFormat: this.driver.oracle.OUT_FORMAT_OBJECT,

        }

        const databaseConnection = await this.connect()

        this.driver.connection.logger.logQuery(query, parameters, this)

        try {

            const stream = databaseConnection.queryStream(

                query,

                parameters,

                executionOptions,

            )

            return stream

    }

    /**

     * Returns all available database names including system databases.

     */

    async getDatabases(): Promise<string[]> {

    /**

     * Returns all available schema names including system schemas.

     * If database parameter specified, returns schemas of that database.

     * @param database

     */

    async getSchemas(database?: string): Promise<string[]> {

    /**

     * Checks if database with the given name exist.

     * @param database

     */

    async hasDatabase(database: string): Promise<boolean> {

        try {

            const query = await this.query(

                `SELECT 1 AS "exists" FROM global_name@${this.driver.escape(database)}`,

            )

        } catch (e) {

            return false

        }

    }

    /**

     * Loads currently using database

     */

    async getCurrentDatabase(): Promise<undefined> {

        const query = await this.query(

            `SELECT SYS_CONTEXT('USERENV','DB_NAME') AS "db_name" FROM dual`,

        )

        return query[0]["db_name"]

    }

    /**

     * Checks if schema with the given name exist.

     * @param schema

     */

    async hasSchema(schema: string): Promise<boolean> {

        return Promise.resolve(false)

    }

    /**

     * Loads currently using database schema

     */

    async getCurrentSchema(): Promise<string> {

        const query = await this.query(

            `SELECT SYS_CONTEXT('USERENV','CURRENT_SCHEMA') AS "schema_name" FROM dual`,

        )

        return query[0]["schema_name"]

    }

    /**

     * Checks if table with the given name exist in the database.

     * @param tableOrName

     */

    async hasTable(tableOrName: Table | string): Promise<boolean> {

        const { tableName } = this.driver.parseTableName(tableOrName)

        const sql = `SELECT "TABLE_NAME" FROM "USER_TABLES" WHERE "TABLE_NAME" = :1`

        const result = await this.query(sql, [tableName])

        return result.length ? true : false

    }

    /**

     * Checks if column with the given name exist in the given table.

     * @param tableOrName

     * @param columnName

     */

    async hasColumn(

        tableOrName: Table | string,

        columnName: string,

    ): Promise<boolean> {

        const { tableName } = this.driver.parseTableName(tableOrName)

        const sql = `SELECT "COLUMN_NAME" FROM "USER_TAB_COLS" WHERE "TABLE_NAME" = :1 AND "COLUMN_NAME" = :2`

        const result = await this.query(sql, [tableName, columnName])

        return result.length ? true : false

    }

    /**

     * Creates a new database.

     * @param database

     * @param ifNotExists

     */

    async createDatabase(

        database: string,

        ifNotExists?: boolean,

    ): Promise<void> {

        // Even with `IF NOT EXISTS` we get:

        //   ORA-01501: CREATE DATABASE failed

        //   ORA-01100: database already mounted

        if (ifNotExists) {

            try {

                await this.query(

                    `CREATE DATABASE IF NOT EXISTS ${this.driver.escape(database)};`,

                )

                // if (e instanceof QueryFailedError) {

                if (e.message.includes("ORA-01100: database already mounted")) {

                    return

                }

    }

    /**

     * Drops database.

     * @param database

     * @param ifExists

     */

    async dropDatabase(database: string, ifExists?: boolean): Promise<void> {

        return Promise.resolve()

    }

    /**

     * Creates a new table schema.

     * @param schemaPath

     * @param ifNotExists

     */

    async createSchema(

        schemaPath: string,

        ifNotExists?: boolean,

    ): Promise<void> {

        throw new TypeORMError(

            `Schema create queries are not supported by Oracle driver.`,

        )

    }

    /**

     * Drops table schema.

     * @param schemaPath

     * @param ifExists

     */

    async dropSchema(schemaPath: string, ifExists?: boolean): Promise<void> {

        throw new TypeORMError(

            `Schema drop queries are not supported by Oracle driver.`,

        )

    }

    /**

     * Creates a new table.

     * @param table

     * @param ifNotExists

     * @param createForeignKeys

     * @param createIndices

     */

    async createTable(

        table: Table,

        ifNotExists: boolean = false,

        createForeignKeys: boolean = true,

        createIndices: boolean = true,

    ): Promise<void> {

        if (ifNotExists) {

            const isTableExist = await this.hasTable(table)

            if (isTableExist) return Promise.resolve()

        }

        const upQueries: Query[] = []

        const downQueries: Query[] = []

        upQueries.push(this.createTableSql(table, createForeignKeys))

        downQueries.push(this.dropTableSql(table))

        // if createForeignKeys is true, we must drop created foreign keys in down query.

        // createTable does not need separate method to create foreign keys, because it create fk's in the same query with table creation.

        if (createForeignKeys)

            table.foreignKeys.forEach((foreignKey) =>

                downQueries.push(this.dropForeignKeySql(table, foreignKey)),

            )

        if (createIndices) {

            table.indices.forEach((index) => {

                // new index may be passed without name. In this case we generate index name manually.

                if (!index.name)

                    index.name = this.connection.namingStrategy.indexName(

                        table,

                        index.columnNames,

                        index.where,

                    )

                upQueries.push(this.createIndexSql(table, index))

                downQueries.push(this.dropIndexSql(index))

            })

        }

        // if table have column with generated type, we must add the expression to the metadata table

        const generatedColumns = table.columns.filter(

            (column) => column.generatedType && column.asExpression,

        )

        for (const column of generatedColumns) {

            const insertQuery = this.insertTypeormMetadataSql({

                table: table.name,

                type: MetadataTableType.GENERATED_COLUMN,

                name: column.name,

                value: column.asExpression,

            })

            const deleteQuery = this.deleteTypeormMetadataSql({

                table: table.name,

                type: MetadataTableType.GENERATED_COLUMN,

                name: column.name,

            })

            upQueries.push(insertQuery)

            downQueries.push(deleteQuery)

        }

        await this.executeQueries(upQueries, downQueries)

    }

    /**

     * Drops the table.

     * @param tableOrName

     * @param ifExists

     * @param dropForeignKeys

     * @param dropIndices

     */

    async dropTable(

        tableOrName: Table | string,

        ifExists?: boolean,

        dropForeignKeys: boolean = true,

        dropIndices: boolean = true,

    ): Promise<void> {

        // It needs because if table does not exist and dropForeignKeys or dropIndices is true, we don't need

        // to perform drop queries for foreign keys and indices.

        if (ifExists) {

            const isTableExist = await this.hasTable(tableOrName)

            if (!isTableExist) return Promise.resolve()

        }

        // if dropTable called with dropForeignKeys = true, we must create foreign keys in down query.

        const createForeignKeys: boolean = dropForeignKeys

        const table = InstanceChecker.isTable(tableOrName)

            ? tableOrName

            : await this.getCachedTable(tableOrName)

        const upQueries: Query[] = []

        const downQueries: Query[] = []

        if (dropIndices) {

            table.indices.forEach((index) => {

                upQueries.push(this.dropIndexSql(index))

                downQueries.push(this.createIndexSql(table, index))

            })

        }

        // if dropForeignKeys is true, we just drop the table, otherwise we also drop table foreign keys.

        // createTable does not need separate method to create foreign keys, because it create fk's in the same query with table creation.

        if (dropForeignKeys)

            table.foreignKeys.forEach((foreignKey) =>

                upQueries.push(this.dropForeignKeySql(table, foreignKey)),

            )

        upQueries.push(this.dropTableSql(table))

        downQueries.push(this.createTableSql(table, createForeignKeys))

        // if table had columns with generated type, we must remove the expression from the metadata table

        const generatedColumns = table.columns.filter(

            (column) => column.generatedType && column.asExpression,

        )

        for (const column of generatedColumns) {

            const deleteQuery = this.deleteTypeormMetadataSql({

                table: table.name,

                type: MetadataTableType.GENERATED_COLUMN,

                name: column.name,

            })

            const insertQuery = this.insertTypeormMetadataSql({

                table: table.name,

                type: MetadataTableType.GENERATED_COLUMN,

                name: column.name,

                value: column.asExpression,

            })

            upQueries.push(deleteQuery)

            downQueries.push(insertQuery)

        }

        await this.executeQueries(upQueries, downQueries)

    }

    /**

     * Creates a new view.

     * @param view

     * @param syncWithMetadata

     */

    async createView(

        view: View,

        syncWithMetadata: boolean = false,

    ): Promise<void> {

        const upQueries: Query[] = []

        const downQueries: Query[] = []

        upQueries.push(this.createViewSql(view))

        if (syncWithMetadata) upQueries.push(this.insertViewDefinitionSql(view))

        downQueries.push(this.dropViewSql(view))

        if (syncWithMetadata)

            downQueries.push(this.deleteViewDefinitionSql(view))

        await this.executeQueries(upQueries, downQueries)

    }

    /**

     * Drops the view.

     * @param target

     * @param ifExists

     */

    async dropView(target: View | string, ifExists?: boolean): Promise<void> {

        const viewName = InstanceChecker.isView(target) ? target.name : target

        const view = ifExists

            ? await this.getCachedView(viewName).catch(() => undefined)

            : await this.getCachedView(viewName)

        if (!view) return

        const upQueries: Query[] = []

        const downQueries: Query[] = []

        upQueries.push(this.deleteViewDefinitionSql(view))

        upQueries.push(this.dropViewSql(view))

        downQueries.push(this.insertViewDefinitionSql(view))

        downQueries.push(this.createViewSql(view))

        await this.executeQueries(upQueries, downQueries)

    }

    /**

     * Renames the given table.

     * @param oldTableOrName

     * @param newTableName

     */

    async renameTable(

        oldTableOrName: Table | string,

        newTableName: string,

    ): Promise<void> {

        const upQueries: Query[] = []

        const downQueries: Query[] = []

        const oldTable = InstanceChecker.isTable(oldTableOrName)

            ? oldTableOrName

            : await this.getCachedTable(oldTableOrName)

        const newTable = oldTable.clone()

        const { database: dbName, tableName: oldTableName } =

            this.driver.parseTableName(oldTable)

        // rename table

        upQueries.push(

            new Query(

                `ALTER TABLE ${this.escapePath(

                    oldTable,

                )} RENAME TO "${newTableName}"`,

            ),

        )

        downQueries.push(

            new Query(

                `ALTER TABLE ${this.escapePath(

                    newTable,

                )} RENAME TO "${oldTableName}"`,

            ),

        )

        // rename primary key constraint

        if (

            newTable.primaryColumns.length > 0 &&

            !newTable.primaryColumns[0].primaryKeyConstraintName

        ) {

            const columnNames = newTable.primaryColumns.map(

                (column) => column.name,

            )

            const oldPkName = this.connection.namingStrategy.primaryKeyName(

                oldTable,

                columnNames,

            )

            const newPkName = this.connection.namingStrategy.primaryKeyName(

                newTable,

                columnNames,

            )

            // build queries

            upQueries.push(

                new Query(

                    `ALTER TABLE ${this.escapePath(

                        newTable,

                    )} RENAME CONSTRAINT "${oldPkName}" TO "${newPkName}"`,

                ),

            )

            downQueries.push(

                new Query(

                    `ALTER TABLE ${this.escapePath(

                        newTable,

                    )} RENAME CONSTRAINT "${newPkName}" TO "${oldPkName}"`,

                ),

            )

        }

        // rename unique constraints

        newTable.uniques.forEach((unique) => {

            const oldUniqueName =

                this.connection.namingStrategy.uniqueConstraintName(

                    oldTable,

                    unique.columnNames,

                )

            // Skip renaming if Unique has user defined constraint name

            if (unique.name !== oldUniqueName) return

            // build new constraint name

            const newUniqueName =

                this.connection.namingStrategy.uniqueConstraintName(

                    newTable,

                    unique.columnNames,

                )

            // build queries

            upQueries.push(

                new Query(

                    `ALTER TABLE ${this.escapePath(

                        newTable,

                    )} RENAME CONSTRAINT "${

                        unique.name

                    }" TO "${newUniqueName}"`,

                ),

            )

            downQueries.push(

                new Query(

                    `ALTER TABLE ${this.escapePath(

                        newTable,

                    )} RENAME CONSTRAINT "${newUniqueName}" TO "${

                        unique.name

                    }"`,

                ),

            )

            // replace constraint name

            unique.name = newUniqueName

        })

        // rename index constraints

        newTable.indices.forEach((index) => {

            const oldIndexName = this.connection.namingStrategy.indexName(

                oldTable,

                index.columnNames,

                index.where,

            )

            // Skip renaming if Index has user defined constraint name

            if (index.name !== oldIndexName) return

            // build new constraint name

            const newIndexName = this.connection.namingStrategy.indexName(

                newTable,

                index.columnNames,

                index.where,

            )

            // build queries

            upQueries.push(

                new Query(

                    `ALTER INDEX "${index.name}" RENAME TO "${newIndexName}"`,

                ),

            )

            downQueries.push(

                new Query(

                    `ALTER INDEX "${newIndexName}" RENAME TO "${index.name}"`,

                ),

            )

            // replace constraint name

            index.name = newIndexName

        })

        // rename foreign key constraints

        newTable.foreignKeys.forEach((foreignKey) => {

            const oldForeignKeyName =

                this.connection.namingStrategy.foreignKeyName(

                    oldTable,

                    foreignKey.columnNames,

                    this.getTablePath(foreignKey),

                    foreignKey.referencedColumnNames,

                )

            // Skip renaming if foreign key has user defined constraint name

            if (foreignKey.name !== oldForeignKeyName) return

            // build new constraint name

            const newForeignKeyName =

                this.connection.namingStrategy.foreignKeyName(

                    newTable,

                    foreignKey.columnNames,

                    this.getTablePath(foreignKey),

                    foreignKey.referencedColumnNames,

                )

            // build queries

            upQueries.push(

                new Query(

                    `ALTER TABLE ${this.escapePath(

                        newTable,

                    )} RENAME CONSTRAINT "${

                        foreignKey.name

                    }" TO "${newForeignKeyName}"`,

                ),

            )

            downQueries.push(

                new Query(