UNPKG

typeorm

Version:

Data-Mapper ORM for TypeScript and ES2021+. Supports MySQL/MariaDB, PostgreSQL, MS SQL Server, Oracle, SAP HANA, SQLite, MongoDB databases.

945 lines (944 loc) • 105 kB
"use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.SapQueryRunner = void 0; const util_1 = require("util"); const error_1 = require("../../error"); const QueryRunnerAlreadyReleasedError_1 = require("../../error/QueryRunnerAlreadyReleasedError"); const TransactionAlreadyStartedError_1 = require("../../error/TransactionAlreadyStartedError"); const TransactionNotStartedError_1 = require("../../error/TransactionNotStartedError"); const BaseQueryRunner_1 = require("../../query-runner/BaseQueryRunner"); const QueryLock_1 = require("../../query-runner/QueryLock"); const QueryResult_1 = require("../../query-runner/QueryResult"); const Table_1 = require("../../schema-builder/table/Table"); const TableCheck_1 = require("../../schema-builder/table/TableCheck"); const TableColumn_1 = require("../../schema-builder/table/TableColumn"); const TableForeignKey_1 = require("../../schema-builder/table/TableForeignKey"); const TableIndex_1 = require("../../schema-builder/table/TableIndex"); const TableUnique_1 = require("../../schema-builder/table/TableUnique"); const View_1 = require("../../schema-builder/view/View"); const Broadcaster_1 = require("../../subscriber/Broadcaster"); const BroadcasterResult_1 = require("../../subscriber/BroadcasterResult"); const InstanceChecker_1 = require("../../util/InstanceChecker"); const OrmUtils_1 = require("../../util/OrmUtils"); const Query_1 = require("../Query"); const MetadataTableType_1 = require("../types/MetadataTableType"); /** * Runs queries on a single SQL Server database connection. */ class SapQueryRunner extends BaseQueryRunner_1.BaseQueryRunner { // ------------------------------------------------------------------------- // Constructor // ------------------------------------------------------------------------- constructor(driver, mode) { super(); this.lock = new QueryLock_1.QueryLock(); this.driver = driver; this.connection = driver.connection; this.broadcaster = new Broadcaster_1.Broadcaster(this); this.mode = mode; } // ------------------------------------------------------------------------- // Public Methods // ------------------------------------------------------------------------- /** * Creates/uses database connection from the connection pool to perform further operations. * Returns obtained database connection. */ async connect() { if (this.databaseConnection) return this.databaseConnection; this.databaseConnection = await this.driver.obtainMasterConnection(); return this.databaseConnection; } /** * Releases used database connection. * You cannot use query runner methods once its released. */ release() { this.isReleased = true; if (this.databaseConnection) { return this.driver.master.release(this.databaseConnection); } return Promise.resolve(); } /** * Starts transaction. */ async startTransaction(isolationLevel) { if (this.isReleased) throw new QueryRunnerAlreadyReleasedError_1.QueryRunnerAlreadyReleasedError(); if (this.isTransactionActive && this.driver.transactionSupport === "simple") throw new TransactionAlreadyStartedError_1.TransactionAlreadyStartedError(); await this.broadcaster.broadcast("BeforeTransactionStart"); this.isTransactionActive = true; /** * Disable AUTOCOMMIT while running transaction. * Otherwise, COMMIT/ROLLBACK doesn't work in autocommit mode. */ await this.setAutoCommit({ status: "off" }); if (isolationLevel) { await this.query(`SET TRANSACTION ISOLATION LEVEL ${isolationLevel || ""}`); } await this.broadcaster.broadcast("AfterTransactionStart"); } /** * Commits transaction. * Error will be thrown if transaction was not started. */ async commitTransaction() { if (this.isReleased) throw new QueryRunnerAlreadyReleasedError_1.QueryRunnerAlreadyReleasedError(); if (!this.isTransactionActive) throw new TransactionNotStartedError_1.TransactionNotStartedError(); await this.broadcaster.broadcast("BeforeTransactionCommit"); await this.query("COMMIT"); this.isTransactionActive = false; await this.setAutoCommit({ status: "on" }); await this.broadcaster.broadcast("AfterTransactionCommit"); } /** * Rollbacks transaction. * Error will be thrown if transaction was not started. */ async rollbackTransaction() { if (this.isReleased) throw new QueryRunnerAlreadyReleasedError_1.QueryRunnerAlreadyReleasedError(); if (!this.isTransactionActive) throw new TransactionNotStartedError_1.TransactionNotStartedError(); await this.broadcaster.broadcast("BeforeTransactionRollback"); await this.query("ROLLBACK"); this.isTransactionActive = false; await this.setAutoCommit({ status: "on" }); await this.broadcaster.broadcast("AfterTransactionRollback"); } /** * @description Switches on/off AUTOCOMMIT mode * @link https://help.sap.com/docs/HANA_SERVICE_CF/7c78579ce9b14a669c1f3295b0d8ca16/d538d11053bd4f3f847ec5ce817a3d4c.html?locale=en-US */ async setAutoCommit(options) { const connection = await this.connect(); const execute = (0, util_1.promisify)(connection.exec.bind(connection)); connection.setAutoCommit(options.status === "on"); const query = `SET TRANSACTION AUTOCOMMIT DDL ${options.status.toUpperCase()};`; try { await execute(query); } catch (error) { throw new error_1.QueryFailedError(query, [], error); } } /** * Executes a given SQL query. */ async query(query, parameters, useStructuredResult = false) { if (this.isReleased) throw new QueryRunnerAlreadyReleasedError_1.QueryRunnerAlreadyReleasedError(); const release = await this.lock.acquire(); const databaseConnection = await this.connect(); let statement; const result = new QueryResult_1.QueryResult(); this.driver.connection.logger.logQuery(query, parameters, this); await this.broadcaster.broadcast("BeforeQuery", query, parameters); const broadcasterResult = new BroadcasterResult_1.BroadcasterResult(); try { const queryStartTime = Date.now(); const isInsertQuery = query.substr(0, 11) === "INSERT INTO"; if (parameters?.some(Array.isArray)) { statement = await (0, util_1.promisify)(databaseConnection.prepare).call(databaseConnection, query); } let raw; try { raw = statement ? await (0, util_1.promisify)(statement.exec).call(statement, parameters) : await (0, util_1.promisify)(databaseConnection.exec).call(databaseConnection, query, parameters, {}); } catch (err) { throw new error_1.QueryFailedError(query, parameters, err); } // log slow queries if maxQueryExecution time is set const maxQueryExecutionTime = this.driver.connection.options.maxQueryExecutionTime; const queryEndTime = Date.now(); const queryExecutionTime = queryEndTime - queryStartTime; this.broadcaster.broadcastAfterQueryEvent(broadcasterResult, query, parameters, true, queryExecutionTime, raw, undefined); if (maxQueryExecutionTime && queryExecutionTime > maxQueryExecutionTime) { this.driver.connection.logger.logQuerySlow(queryExecutionTime, query, parameters, this); } if (typeof raw === "number") { result.affected = raw; } else if (Array.isArray(raw)) { result.records = raw; } result.raw = raw; if (isInsertQuery) { const lastIdQuery = `SELECT CURRENT_IDENTITY_VALUE() FROM "SYS"."DUMMY"`; this.driver.connection.logger.logQuery(lastIdQuery, [], this); const identityValueResult = await new Promise((ok, fail) => { databaseConnection.exec(lastIdQuery, (err, raw) => err ? fail(new error_1.QueryFailedError(lastIdQuery, [], err)) : ok(raw)); }); result.raw = identityValueResult[0]["CURRENT_IDENTITY_VALUE()"]; result.records = identityValueResult; } } catch (err) { this.driver.connection.logger.logQueryError(err, query, parameters, this); this.broadcaster.broadcastAfterQueryEvent(broadcasterResult, query, parameters, false, undefined, undefined, err); throw err; } finally { // Never forget to drop the statement we reserved if (statement?.drop) { await new Promise((ok) => statement.drop(() => ok())); } await broadcasterResult.wait(); // Always release the lock. release(); } if (useStructuredResult) { return result; } else { return result.raw; } } /** * Returns raw data stream. */ async stream(query, parameters, onEnd, onError) { if (this.isReleased) throw new QueryRunnerAlreadyReleasedError_1.QueryRunnerAlreadyReleasedError(); const release = await this.lock.acquire(); let statement; let resultSet; const cleanup = async () => { if (resultSet) { await (0, util_1.promisify)(resultSet.close).call(resultSet); } if (statement) { await (0, util_1.promisify)(statement.drop).call(statement); } release(); }; try { const databaseConnection = await this.connect(); this.driver.connection.logger.logQuery(query, parameters, this); statement = await (0, util_1.promisify)(databaseConnection.prepare).call(databaseConnection, query); resultSet = await (0, util_1.promisify)(statement.executeQuery).call(statement, parameters); const stream = this.driver.streamClient.createObjectStream(resultSet); stream.on("end", async () => { await cleanup(); onEnd?.(); }); stream.on("error", async (error) => { this.driver.connection.logger.logQueryError(error, query, parameters, this); await cleanup(); onError?.(error); }); return stream; } catch (error) { this.driver.connection.logger.logQueryError(error, query, parameters, this); await cleanup(); throw new error_1.QueryFailedError(query, parameters, error); } } /** * Returns all available database names including system databases. */ async getDatabases() { const results = await this.query(`SELECT DATABASE_NAME FROM "SYS"."M_DATABASES"`); return results.map((result) => result["DATABASE_NAME"]); } /** * Returns all available schema names including system schemas. * If database parameter specified, returns schemas of that database. */ async getSchemas(database) { const query = database ? `SELECT * FROM "${database}"."SYS"."SCHEMAS"` : `SELECT * FROM "SYS"."SCHEMAS"`; const results = await this.query(query); return results.map((result) => result["SCHEMA_NAME"]); } /** * Checks if database with the given name exist. */ async hasDatabase(database) { const databases = await this.getDatabases(); return databases.indexOf(database) !== -1; } /** * Returns current database. */ async getCurrentDatabase() { const currentDBQuery = await this.query(`SELECT "DATABASE_NAME" AS "dbName" FROM "SYS"."M_DATABASE"`); return currentDBQuery[0].dbName; } /** * Returns the database server version. */ async getDatabaseAndVersion() { const currentDBQuery = await this.query(`SELECT "DATABASE_NAME" AS "database", "VERSION" AS "version" FROM "SYS"."M_DATABASE"`); return currentDBQuery[0]; } /** * Checks if schema with the given name exist. */ async hasSchema(schema) { const schemas = await this.getSchemas(); return schemas.indexOf(schema) !== -1; } /** * Returns current schema. */ async getCurrentSchema() { const currentSchemaQuery = await this.query(`SELECT CURRENT_SCHEMA AS "schemaName" FROM "SYS"."DUMMY"`); return currentSchemaQuery[0].schemaName; } /** * Checks if table with the given name exist in the database. */ async hasTable(tableOrName) { const parsedTableName = this.driver.parseTableName(tableOrName); if (!parsedTableName.schema) { parsedTableName.schema = await this.getCurrentSchema(); } const sql = `SELECT COUNT(*) as "hasTable" FROM "SYS"."TABLES" WHERE "SCHEMA_NAME" = '${parsedTableName.schema}' AND "TABLE_NAME" = '${parsedTableName.tableName}'`; const result = await this.query(sql); return result[0].hasTable > 0; } /** * Checks if column with the given name exist in the given table. */ async hasColumn(tableOrName, columnName) { const parsedTableName = this.driver.parseTableName(tableOrName); if (!parsedTableName.schema) { parsedTableName.schema = await this.getCurrentSchema(); } const sql = `SELECT COUNT(*) as "hasColumn" FROM "SYS"."TABLE_COLUMNS" WHERE "SCHEMA_NAME" = '${parsedTableName.schema}' AND "TABLE_NAME" = '${parsedTableName.tableName}' AND "COLUMN_NAME" = '${columnName}'`; const result = await this.query(sql); return result[0].hasColumn > 0; } /** * Creates a new database. */ async createDatabase(database, ifNotExist) { return Promise.resolve(); } /** * Drops database. */ async dropDatabase(database, ifExist) { return Promise.resolve(); } /** * Creates a new table schema. */ async createSchema(schemaPath, ifNotExist) { const schema = schemaPath.indexOf(".") === -1 ? schemaPath : schemaPath.split(".")[1]; let exist = false; if (ifNotExist) { const result = await this.query(`SELECT * FROM "SYS"."SCHEMAS" WHERE "SCHEMA_NAME" = '${schema}'`); exist = !!result.length; } if (!ifNotExist || (ifNotExist && !exist)) { const up = `CREATE SCHEMA "${schema}"`; const down = `DROP SCHEMA "${schema}" CASCADE`; await this.executeQueries(new Query_1.Query(up), new Query_1.Query(down)); } } /** * Drops table schema */ async dropSchema(schemaPath, ifExist, isCascade) { const schema = schemaPath.indexOf(".") === -1 ? schemaPath : schemaPath.split(".")[0]; let exist = false; if (ifExist) { const result = await this.query(`SELECT * FROM "SYS"."SCHEMAS" WHERE "SCHEMA_NAME" = '${schema}'`); exist = !!result.length; } if (!ifExist || (ifExist && exist)) { const up = `DROP SCHEMA "${schema}" ${isCascade ? "CASCADE" : ""}`; const down = `CREATE SCHEMA "${schema}"`; await this.executeQueries(new Query_1.Query(up), new Query_1.Query(down)); } } /** * Creates a new table. */ async createTable(table, ifNotExist = false, createForeignKeys = true, createIndices = true) { if (ifNotExist) { const isTableExist = await this.hasTable(table); if (isTableExist) return Promise.resolve(); } const upQueries = []; const downQueries = []; 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(table, index)); }); } await this.executeQueries(upQueries, downQueries); } /** * Drops the table. */ async dropTable(tableOrName, ifExist, dropForeignKeys = true, dropIndices = true) { if (ifExist) { 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 = dropForeignKeys; const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName) ? tableOrName : await this.getCachedTable(tableOrName); const upQueries = []; const downQueries = []; // 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 (dropIndices) { table.indices.forEach((index) => { upQueries.push(this.dropIndexSql(table, 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)); await this.executeQueries(upQueries, downQueries); } /** * Creates a new view. */ async createView(view, syncWithMetadata = false) { const upQueries = []; const downQueries = []; upQueries.push(this.createViewSql(view)); if (syncWithMetadata) upQueries.push(await this.insertViewDefinitionSql(view)); downQueries.push(this.dropViewSql(view)); if (syncWithMetadata) downQueries.push(await this.deleteViewDefinitionSql(view)); await this.executeQueries(upQueries, downQueries); } /** * Drops the view. */ async dropView(target) { const viewName = InstanceChecker_1.InstanceChecker.isView(target) ? target.name : target; const view = await this.getCachedView(viewName); const upQueries = []; const downQueries = []; upQueries.push(await this.deleteViewDefinitionSql(view)); upQueries.push(this.dropViewSql(view)); downQueries.push(await this.insertViewDefinitionSql(view)); downQueries.push(this.createViewSql(view)); await this.executeQueries(upQueries, downQueries); } /** * Renames a table. */ async renameTable(oldTableOrName, newTableName) { const upQueries = []; const downQueries = []; const oldTable = InstanceChecker_1.InstanceChecker.isTable(oldTableOrName) ? oldTableOrName : await this.getCachedTable(oldTableOrName); const newTable = oldTable.clone(); const { schema: schemaName, tableName: oldTableName } = this.driver.parseTableName(oldTable); newTable.name = schemaName ? `${schemaName}.${newTableName}` : newTableName; // rename table upQueries.push(new Query_1.Query(`RENAME TABLE ${this.escapePath(oldTable)} TO ${this.escapePath(newTable)}`)); downQueries.push(new Query_1.Query(`RENAME TABLE ${this.escapePath(newTable)} TO ${this.escapePath(oldTable)}`)); // drop old FK's. Foreign keys must be dropped before the primary keys are dropped newTable.foreignKeys.forEach((foreignKey) => { upQueries.push(this.dropForeignKeySql(newTable, foreignKey)); downQueries.push(this.createForeignKeySql(newTable, foreignKey)); }); // SAP HANA does not allow to drop PK's which is referenced by foreign keys. // To avoid this, we must drop all referential foreign keys and recreate them later const referencedForeignKeySql = `SELECT * FROM "SYS"."REFERENTIAL_CONSTRAINTS" WHERE "REFERENCED_SCHEMA_NAME" = '${schemaName}' AND "REFERENCED_TABLE_NAME" = '${oldTableName}'`; const dbForeignKeys = await this.query(referencedForeignKeySql); let referencedForeignKeys = []; const referencedForeignKeyTableMapping = []; if (dbForeignKeys.length > 0) { referencedForeignKeys = dbForeignKeys.map((dbForeignKey) => { const foreignKeys = dbForeignKeys.filter((dbFk) => dbFk["CONSTRAINT_NAME"] === dbForeignKey["CONSTRAINT_NAME"]); referencedForeignKeyTableMapping.push({ tableName: `${dbForeignKey["SCHEMA_NAME"]}.${dbForeignKey["TABLE_NAME"]}`, fkName: dbForeignKey["CONSTRAINT_NAME"], }); return new TableForeignKey_1.TableForeignKey({ name: dbForeignKey["CONSTRAINT_NAME"], columnNames: foreignKeys.map((dbFk) => dbFk["COLUMN_NAME"]), referencedDatabase: newTable.database, referencedSchema: newTable.schema, referencedTableName: newTable.name, // we use renamed table name referencedColumnNames: foreignKeys.map((dbFk) => dbFk["REFERENCED_COLUMN_NAME"]), onDelete: dbForeignKey["DELETE_RULE"] === "RESTRICT" ? "NO ACTION" : dbForeignKey["DELETE_RULE"], onUpdate: dbForeignKey["UPDATE_RULE"] === "RESTRICT" ? "NO ACTION" : dbForeignKey["UPDATE_RULE"], deferrable: dbForeignKey["CHECK_TIME"].replace("_", " "), // "CHECK_TIME" is "INITIALLY_IMMEDIATE" or "INITIALLY DEFERRED" }); }); // drop referenced foreign keys referencedForeignKeys.forEach((foreignKey) => { const mapping = referencedForeignKeyTableMapping.find((it) => it.fkName === foreignKey.name); upQueries.push(this.dropForeignKeySql(mapping.tableName, foreignKey)); downQueries.push(this.createForeignKeySql(mapping.tableName, foreignKey)); }); } // rename primary key constraint if (newTable.primaryColumns.length > 0) { const columnNames = newTable.primaryColumns.map((column) => column.name); const columnNamesString = columnNames .map((columnName) => `"${columnName}"`) .join(", "); const oldPkName = this.connection.namingStrategy.primaryKeyName(oldTable, columnNames); const newPkName = this.connection.namingStrategy.primaryKeyName(newTable, columnNames); // drop old PK upQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(newTable)} DROP CONSTRAINT "${oldPkName}"`)); downQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(newTable)} ADD CONSTRAINT "${oldPkName}" PRIMARY KEY (${columnNamesString})`)); // create new PK upQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(newTable)} ADD CONSTRAINT "${newPkName}" PRIMARY KEY (${columnNamesString})`)); downQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(newTable)} DROP CONSTRAINT "${newPkName}"`)); } // recreate foreign keys with new constraint names newTable.foreignKeys.forEach((foreignKey) => { // replace constraint name foreignKey.name = this.connection.namingStrategy.foreignKeyName(newTable, foreignKey.columnNames, this.getTablePath(foreignKey), foreignKey.referencedColumnNames); // create new FK's upQueries.push(this.createForeignKeySql(newTable, foreignKey)); downQueries.push(this.dropForeignKeySql(newTable, foreignKey)); }); // restore referenced foreign keys referencedForeignKeys.forEach((foreignKey) => { const mapping = referencedForeignKeyTableMapping.find((it) => it.fkName === foreignKey.name); upQueries.push(this.createForeignKeySql(mapping.tableName, foreignKey)); downQueries.push(this.dropForeignKeySql(mapping.tableName, foreignKey)); }); // rename index constraints newTable.indices.forEach((index) => { // build new constraint name const newIndexName = this.connection.namingStrategy.indexName(newTable, index.columnNames, index.where); // drop old index upQueries.push(this.dropIndexSql(newTable, index)); downQueries.push(this.createIndexSql(newTable, index)); // replace constraint name index.name = newIndexName; // create new index upQueries.push(this.createIndexSql(newTable, index)); downQueries.push(this.dropIndexSql(newTable, index)); }); await this.executeQueries(upQueries, downQueries); // rename old table and replace it in cached tabled; oldTable.name = newTable.name; this.replaceCachedTable(oldTable, newTable); } /** * Creates a new column from the column in the table. */ async addColumn(tableOrName, column) { const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName) ? tableOrName : await this.getCachedTable(tableOrName); const parsedTableName = this.driver.parseTableName(table); if (!parsedTableName.schema) { parsedTableName.schema = await this.getCurrentSchema(); } const clonedTable = table.clone(); const upQueries = []; const downQueries = []; upQueries.push(new Query_1.Query(this.addColumnSql(table, column))); downQueries.push(new Query_1.Query(this.dropColumnSql(table, column))); // create or update primary key constraint if (column.isPrimary) { const primaryColumns = clonedTable.primaryColumns; // if table already have primary key, me must drop it and recreate again if (primaryColumns.length > 0) { // SAP HANA does not allow to drop PK's which is referenced by foreign keys. // To avoid this, we must drop all referential foreign keys and recreate them later const referencedForeignKeySql = `SELECT * FROM "SYS"."REFERENTIAL_CONSTRAINTS" WHERE "REFERENCED_SCHEMA_NAME" = '${parsedTableName.schema}' AND "REFERENCED_TABLE_NAME" = '${parsedTableName.tableName}'`; const dbForeignKeys = await this.query(referencedForeignKeySql); let referencedForeignKeys = []; const referencedForeignKeyTableMapping = []; if (dbForeignKeys.length > 0) { referencedForeignKeys = dbForeignKeys.map((dbForeignKey) => { const foreignKeys = dbForeignKeys.filter((dbFk) => dbFk["CONSTRAINT_NAME"] === dbForeignKey["CONSTRAINT_NAME"]); referencedForeignKeyTableMapping.push({ tableName: `${dbForeignKey["SCHEMA_NAME"]}.${dbForeignKey["TABLE_NAME"]}`, fkName: dbForeignKey["CONSTRAINT_NAME"], }); return new TableForeignKey_1.TableForeignKey({ name: dbForeignKey["CONSTRAINT_NAME"], columnNames: foreignKeys.map((dbFk) => dbFk["COLUMN_NAME"]), referencedDatabase: table.database, referencedSchema: table.schema, referencedTableName: table.name, referencedColumnNames: foreignKeys.map((dbFk) => dbFk["REFERENCED_COLUMN_NAME"]), onDelete: dbForeignKey["DELETE_RULE"] === "RESTRICT" ? "NO ACTION" : dbForeignKey["DELETE_RULE"], onUpdate: dbForeignKey["UPDATE_RULE"] === "RESTRICT" ? "NO ACTION" : dbForeignKey["UPDATE_RULE"], deferrable: dbForeignKey["CHECK_TIME"].replace("_", " "), }); }); // drop referenced foreign keys referencedForeignKeys.forEach((foreignKey) => { const mapping = referencedForeignKeyTableMapping.find((it) => it.fkName === foreignKey.name); upQueries.push(this.dropForeignKeySql(mapping.tableName, foreignKey)); downQueries.push(this.createForeignKeySql(mapping.tableName, foreignKey)); }); } const pkName = this.connection.namingStrategy.primaryKeyName(clonedTable, primaryColumns.map((column) => column.name)); const columnNames = primaryColumns .map((column) => `"${column.name}"`) .join(", "); upQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(table)} DROP CONSTRAINT "${pkName}"`)); downQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(table)} ADD CONSTRAINT "${pkName}" PRIMARY KEY (${columnNames})`)); // restore referenced foreign keys referencedForeignKeys.forEach((foreignKey) => { const mapping = referencedForeignKeyTableMapping.find((it) => it.fkName === foreignKey.name); upQueries.push(this.createForeignKeySql(mapping.tableName, foreignKey)); downQueries.push(this.dropForeignKeySql(mapping.tableName, foreignKey)); }); } primaryColumns.push(column); const pkName = this.connection.namingStrategy.primaryKeyName(clonedTable, primaryColumns.map((column) => column.name)); const columnNames = primaryColumns .map((column) => `"${column.name}"`) .join(", "); upQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(table)} ADD CONSTRAINT "${pkName}" PRIMARY KEY (${columnNames})`)); downQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(table)} DROP CONSTRAINT "${pkName}"`)); } // create column index const columnIndex = clonedTable.indices.find((index) => index.columnNames.length === 1 && index.columnNames[0] === column.name); if (columnIndex) { upQueries.push(this.createIndexSql(table, columnIndex)); downQueries.push(this.dropIndexSql(table, columnIndex)); } else if (column.isUnique) { const uniqueIndex = new TableIndex_1.TableIndex({ name: this.connection.namingStrategy.indexName(table, [ column.name, ]), columnNames: [column.name], isUnique: true, }); clonedTable.indices.push(uniqueIndex); clonedTable.uniques.push(new TableUnique_1.TableUnique({ name: uniqueIndex.name, columnNames: uniqueIndex.columnNames, })); upQueries.push(this.createIndexSql(table, uniqueIndex)); downQueries.push(this.dropIndexSql(table, uniqueIndex)); } await this.executeQueries(upQueries, downQueries); clonedTable.addColumn(column); this.replaceCachedTable(table, clonedTable); } /** * Creates a new columns from the column in the table. */ async addColumns(tableOrName, columns) { for (const column of columns) { await this.addColumn(tableOrName, column); } } /** * Renames column in the given table. */ async renameColumn(tableOrName, oldTableColumnOrName, newTableColumnOrName) { const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName) ? tableOrName : await this.getCachedTable(tableOrName); const oldColumn = InstanceChecker_1.InstanceChecker.isTableColumn(oldTableColumnOrName) ? oldTableColumnOrName : table.columns.find((c) => c.name === oldTableColumnOrName); if (!oldColumn) throw new error_1.TypeORMError(`Column "${oldTableColumnOrName}" was not found in the "${table.name}" table.`); let newColumn = undefined; if (InstanceChecker_1.InstanceChecker.isTableColumn(newTableColumnOrName)) { newColumn = newTableColumnOrName; } else { newColumn = oldColumn.clone(); newColumn.name = newTableColumnOrName; } await this.changeColumn(table, oldColumn, newColumn); } /** * Changes a column in the table. */ async changeColumn(tableOrName, oldTableColumnOrName, newColumn) { const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName) ? tableOrName : await this.getCachedTable(tableOrName); let clonedTable = table.clone(); const upQueries = []; const downQueries = []; const oldColumn = InstanceChecker_1.InstanceChecker.isTableColumn(oldTableColumnOrName) ? oldTableColumnOrName : table.columns.find((column) => column.name === oldTableColumnOrName); if (!oldColumn) throw new error_1.TypeORMError(`Column "${oldTableColumnOrName}" was not found in the "${table.name}" table.`); if ((newColumn.isGenerated !== oldColumn.isGenerated && newColumn.generationStrategy !== "uuid") || newColumn.type !== oldColumn.type || newColumn.length !== oldColumn.length) { // SQL Server does not support changing of IDENTITY column, so we must drop column and recreate it again. // Also, we recreate column if column type changed await this.dropColumn(table, oldColumn); await this.addColumn(table, newColumn); // update cloned table clonedTable = table.clone(); } else { if (newColumn.name !== oldColumn.name) { // rename column upQueries.push(new Query_1.Query(`RENAME COLUMN ${this.escapePath(table)}."${oldColumn.name}" TO "${newColumn.name}"`)); downQueries.push(new Query_1.Query(`RENAME COLUMN ${this.escapePath(table)}."${newColumn.name}" TO "${oldColumn.name}"`)); if (oldColumn.isPrimary === true) { const primaryColumns = clonedTable.primaryColumns; // build old primary constraint name const columnNames = primaryColumns.map((column) => column.name); const oldPkName = this.connection.namingStrategy.primaryKeyName(clonedTable, columnNames); // replace old column name with new column name columnNames.splice(columnNames.indexOf(oldColumn.name), 1); columnNames.push(newColumn.name); const columnNamesString = columnNames .map((columnName) => `"${columnName}"`) .join(", "); // drop old PK upQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(clonedTable)} DROP CONSTRAINT "${oldPkName}"`)); downQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(clonedTable)} ADD CONSTRAINT "${oldPkName}" PRIMARY KEY (${columnNamesString})`)); // build new primary constraint name const newPkName = this.connection.namingStrategy.primaryKeyName(clonedTable, columnNames); // create new PK upQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(clonedTable)} ADD CONSTRAINT "${newPkName}" PRIMARY KEY (${columnNamesString})`)); downQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(clonedTable)} DROP CONSTRAINT "${newPkName}"`)); } // rename index constraints clonedTable.findColumnIndices(oldColumn).forEach((index) => { // build new constraint name index.columnNames.splice(index.columnNames.indexOf(oldColumn.name), 1); index.columnNames.push(newColumn.name); const newIndexName = this.connection.namingStrategy.indexName(clonedTable, index.columnNames, index.where); // drop old index upQueries.push(this.dropIndexSql(clonedTable, index)); downQueries.push(this.createIndexSql(clonedTable, index)); // replace constraint name index.name = newIndexName; // create new index upQueries.push(this.createIndexSql(clonedTable, index)); downQueries.push(this.dropIndexSql(clonedTable, index)); }); // rename foreign key constraints clonedTable .findColumnForeignKeys(oldColumn) .forEach((foreignKey) => { // build new constraint name foreignKey.columnNames.splice(foreignKey.columnNames.indexOf(oldColumn.name), 1); foreignKey.columnNames.push(newColumn.name); const newForeignKeyName = this.connection.namingStrategy.foreignKeyName(clonedTable, foreignKey.columnNames, this.getTablePath(foreignKey), foreignKey.referencedColumnNames); upQueries.push(this.dropForeignKeySql(clonedTable, foreignKey)); downQueries.push(this.createForeignKeySql(clonedTable, foreignKey)); // replace constraint name foreignKey.name = newForeignKeyName; // create new FK's upQueries.push(this.createForeignKeySql(clonedTable, foreignKey)); downQueries.push(this.dropForeignKeySql(clonedTable, foreignKey)); }); // rename check constraints clonedTable.findColumnChecks(oldColumn).forEach((check) => { // build new constraint name check.columnNames.splice(check.columnNames.indexOf(oldColumn.name), 1); check.columnNames.push(newColumn.name); const newCheckName = this.connection.namingStrategy.checkConstraintName(clonedTable, check.expression); upQueries.push(this.dropCheckConstraintSql(clonedTable, check)); downQueries.push(this.createCheckConstraintSql(clonedTable, check)); // replace constraint name check.name = newCheckName; upQueries.push(this.createCheckConstraintSql(clonedTable, check)); downQueries.push(this.dropCheckConstraintSql(clonedTable, check)); }); // rename old column in the Table object const oldTableColumn = clonedTable.columns.find((column) => column.name === oldColumn.name); clonedTable.columns[clonedTable.columns.indexOf(oldTableColumn)].name = newColumn.name; oldColumn.name = newColumn.name; } if (this.isColumnChanged(oldColumn, newColumn, true)) { upQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(table)} ALTER (${this.buildCreateColumnSql(newColumn, !(oldColumn.default === null || oldColumn.default === undefined), !oldColumn.isNullable)})`)); downQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(table)} ALTER (${this.buildCreateColumnSql(oldColumn, !(newColumn.default === null || newColumn.default === undefined), !newColumn.isNullable)})`)); } else if (oldColumn.comment !== newColumn.comment) { upQueries.push(new Query_1.Query(`COMMENT ON COLUMN ${this.escapePath(table)}."${oldColumn.name}" IS ${this.escapeComment(newColumn.comment)}`)); downQueries.push(new Query_1.Query(`COMMENT ON COLUMN ${this.escapePath(table)}."${newColumn.name}" IS ${this.escapeComment(oldColumn.comment)}`)); } if (newColumn.isPrimary !== oldColumn.isPrimary) { const primaryColumns = clonedTable.primaryColumns; // if primary column state changed, we must always drop existed constraint. if (primaryColumns.length > 0) { const pkName = this.connection.namingStrategy.primaryKeyName(clonedTable, primaryColumns.map((column) => column.name)); const columnNames = primaryColumns .map((column) => `"${column.name}"`) .join(", "); upQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(table)} DROP CONSTRAINT "${pkName}"`)); downQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(table)} ADD CONSTRAINT "${pkName}" PRIMARY KEY (${columnNames})`)); } if (newColumn.isPrimary === true) { primaryColumns.push(newColumn); // update column in table const column = clonedTable.columns.find((column) => column.name === newColumn.name); column.isPrimary = true; const pkName = this.connection.namingStrategy.primaryKeyName(clonedTable, primaryColumns.map((column) => column.name)); const columnNames = primaryColumns .map((column) => `"${column.name}"`) .join(", "); upQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(table)} ADD CONSTRAINT "${pkName}" PRIMARY KEY (${columnNames})`)); downQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(table)} DROP CONSTRAINT "${pkName}"`)); } else { const primaryColumn = primaryColumns.find((c) => c.name === newColumn.name); primaryColumns.splice(primaryColumns.indexOf(primaryColumn), 1); // update column in table const column = clonedTable.columns.find((column) => column.name === newColumn.name); column.isPrimary = false; // if we have another primary keys, we must recreate constraint. if (primaryColumns.length > 0) { const pkName = this.connection.namingStrategy.primaryKeyName(clonedTable, primaryColumns.map((column) => column.name)); const columnNames = primaryColumns .map((column) => `"${column.name}"`) .join(", "); upQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(table)} ADD CONSTRAINT "${pkName}" PRIMARY KEY (${columnNames})`)); downQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(table)} DROP CONSTRAINT "${pkName}"`)); } } } if (newColumn.isUnique !== oldColumn.isUnique) { if (newColumn.isUnique === true) { const uniqueIndex = new TableIndex_1.TableIndex({ name: this.connection.namingStrategy.indexName(table, [ newColumn.name, ]), columnNames: [newColumn.name], isUnique: true, }); clonedTable.indices.push(uniqueIndex); clonedTable.uniques.push(new TableUnique_1.TableUnique({ name: uniqueIndex.name, columnNames: uniqueIndex.columnNames, })); upQueries.push(this.createIndexSql(table, uniqueIndex)); downQueries.push(this.dropIndexSql(table, uniqueIndex)); } else { const uniqueIndex = clonedTable.indices.find((index) => { return (index.columnNames.length === 1 && index.isUnique === true && !!index.columnNames.find((columnName) => columnName === newColumn.name)); }); clonedTable.indices.splice(clonedTable.indices.indexOf(uniqueIndex), 1); const tableUnique = clonedTable.uniques.find((unique) => unique.name === uniqueIndex.name); clonedTable.uniques.splice(clonedTable.uniques.indexOf(tableUnique), 1); upQueries.push(this.dropIndexSql(table, uniqueIndex)); downQueries.push(this.createIndexSql(table, uniqueIndex)); } } await this.executeQueries(upQueries, downQueries); this.replaceCachedTable(table, clonedTable); } } /** * Changes a column in the table. */ async changeColumns(tableOrName, changedColumns) { for (const { oldColumn, newColumn } of changedColumns) { await this.changeColumn(tableOrName, oldColumn, newColumn); } } /** * Drops column in the table. */ async dropColumn(tableOrName, columnOrName) { const table = InstanceChecker_1.InstanceChecker.isTable(tableOrName) ? tableOrName : await this.getCachedTable(tableOrName); const parsedTableName = this.driver.parseTableName(table); if (!parsedTableName.schema) { parsedTableName.schema = await this.getCurrentSchema(); } const column = InstanceChecker_1.InstanceChecker.isTableColumn(columnOrName) ? columnOrName : table.findColumnByName(columnOrName); if (!column) throw new error_1.TypeORMError(`Column "${columnOrName}" was not found in table "${table.name}"`); const clonedTable = table.clone(); const upQueries = []; const downQueries = []; // drop primary key constraint if (column.isPrimary) { // SAP HANA does not allow to drop PK's which is referenced by foreign keys. // To avoid this, we must drop all referential foreign keys and recreate them later const referencedForeignKeySql = `SELECT * FROM "SYS"."REFERENTIAL_CONSTRAINTS" WHERE "REFERENCED_SCHEMA_NAME" = '${parsedTableName.schema}' AND "REFERENCED_TABLE_NAME" = '${parsedTableName.tableName}'`; const dbForeignKeys = await this.query(referencedForeignKeySql); let referencedForeignKeys = []; const referencedForeignKeyTableMapping = []; if (dbForeignKeys.length > 0) { referencedForeignKeys = dbForeignKeys.map((dbForeignKey) => { const foreignKeys = dbForeignKeys.filter((dbFk) => dbFk["CONSTRAINT_NAME"] === dbForeignKey["CONSTRAINT_NAME"]); referencedForeignKeyTableMapping.push({ tableName: `${dbForeignKey["SCHEMA_NAME"]}.${dbForeignKey["TABLE_NAME"]}`, fkName: dbForeignKey["CONSTRAINT_NAME"], }); return new TableForeignKey_1.TableForeignKey({ name: dbForeignKey["CONSTRAINT_NAME"], columnNames: foreignKeys.map((dbFk) => dbFk["COLUMN_NAME"]), referencedDatabase: table.database, referencedSchema: table.schema, referencedTableName: table.name, referencedColumnNames: foreignKeys.map((dbFk) => dbFk["REFERENCED_COLUMN_NAME"]), onDelete: dbForeignKey["DELETE_RULE"] === "RESTRICT" ? "NO ACTION" : dbForeignKey["DELETE_RULE"], onUpdate: dbForeignKey["UPDATE_RULE"] === "RESTRICT" ? "NO ACTION" : dbForeignKey["UPDATE_RULE"], deferrable: dbForeignKey["CHECK_TIME"].replace("_", " "),