typeorm 1.1.1 → 1.1.2

package/driver/mysql/MysqlQueryRunner.js

@@ -374,18 +374,19 @@ class MysqlQueryRunner extends BaseQueryRunner_1.BaseQueryRunner {
         // if table has column with generated type, we must add the expression to the metadata table
         const generatedColumns = table.columns.filter((column) => column.generatedType && column.asExpression);
         if (generatedColumns.length > 0) {
-            const currentDatabase = await this.getCurrentDatabase();
+            let { database, tableName } = this.driver.parseTableName(table);
+            database ??= await this.getCurrentDatabase();
             for (const column of generatedColumns) {
                 const insertQuery = this.insertTypeormMetadataSql({
-                    schema: currentDatabase,
-                    table: table.name,
+                    schema: database,
+                    table: tableName,
                     type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
                     name: column.name,
                     value: column.asExpression,
                 });
                 const deleteQuery = this.deleteTypeormMetadataSql({
-                    schema: currentDatabase,
-                    table: table.name,
+                    schema: database,
+                    table: tableName,
                     type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
                     name: column.name,
                 });
@@ -422,25 +423,28 @@ class MysqlQueryRunner extends BaseQueryRunner_1.BaseQueryRunner {
         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);
+        const generatedColumns = table.columns.filter((column) => column.generatedType);
         if (generatedColumns.length > 0) {
-            const currentDatabase = await this.getCurrentDatabase();
+            let { database, tableName } = this.driver.parseTableName(table);
+            database ??= await this.getCurrentDatabase();
             for (const column of generatedColumns) {
                 const deleteQuery = this.deleteTypeormMetadataSql({
-                    schema: currentDatabase,
-                    table: table.name,
+                    schema: database,
+                    table: tableName,
                     type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
                     name: column.name,
                 });
-                const insertQuery = this.insertTypeormMetadataSql({
-                    schema: currentDatabase,
-                    table: table.name,
-                    type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
-                    name: column.name,
-                    value: column.asExpression,
-                });
                 upQueries.push(deleteQuery);
-                downQueries.push(insertQuery);
+                if (column.asExpression) {
+                    const insertQuery = this.insertTypeormMetadataSql({
+                        schema: database,
+                        table: tableName,
+                        type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                        name: column.name,
+                        value: column.asExpression,
+                    });
+                    downQueries.push(insertQuery);
+                }
             }
         }
         await this.executeQueries(upQueries, downQueries);
@@ -497,11 +501,29 @@ class MysqlQueryRunner extends BaseQueryRunner_1.BaseQueryRunner {
             ? oldTableOrName
             : await this.getCachedTable(oldTableOrName);
         const newTable = oldTable.clone();
-        const { database } = this.driver.parseTableName(oldTable);
+        let { database, tableName: oldTableName } = this.driver.parseTableName(oldTable);
+        database ??= await this.getCurrentDatabase();
         newTable.name = database ? `${database}.${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)}`));
+        const hasGeneratedColumns = newTable.columns.some((col) => col.generatedType);
+        if (hasGeneratedColumns) {
+            const updateQuery = this.updateTypeormMetadataSql({
+                schema: database,
+                table: oldTableName,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                valueToSet: { table: newTableName },
+            });
+            const revertUpdateQuery = this.updateTypeormMetadataSql({
+                schema: database,
+                table: newTableName,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                valueToSet: { table: oldTableName },
+            });
+            upQueries.push(updateQuery);
+            downQueries.push(revertUpdateQuery);
+        }
         // rename index constraints
         newTable.indices.forEach((index) => {
             const oldIndexName = this.dataSource.namingStrategy.indexName(oldTable, index.columnNames);
@@ -642,17 +664,18 @@ class MysqlQueryRunner extends BaseQueryRunner_1.BaseQueryRunner {
             }
         }
         if (column.generatedType && column.asExpression) {
-            const currentDatabase = await this.getCurrentDatabase();
+            let { database, tableName } = this.driver.parseTableName(table);
+            database ??= await this.getCurrentDatabase();
             const insertQuery = this.insertTypeormMetadataSql({
-                schema: currentDatabase,
-                table: table.name,
+                schema: database,
+                table: tableName,
                 type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
                 name: column.name,
                 value: column.asExpression,
             });
             const deleteQuery = this.deleteTypeormMetadataSql({
-                schema: currentDatabase,
-                table: table.name,
+                schema: database,
+                table: tableName,
                 type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
                 name: column.name,
             });
@@ -762,6 +785,26 @@ class MysqlQueryRunner extends BaseQueryRunner_1.BaseQueryRunner {
                 // We don't change any column properties, just rename it.
                 upQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(table)} CHANGE \`${oldColumn.name}\` \`${newColumn.name}\` ${this.buildCreateColumnSql(oldColumn, true, true)}`));
                 downQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(table)} CHANGE \`${newColumn.name}\` \`${oldColumn.name}\` ${this.buildCreateColumnSql(oldColumn, true, true)}`));
+                if (oldColumn.generatedType) {
+                    let { database, tableName } = this.driver.parseTableName(table);
+                    database ??= await this.getCurrentDatabase();
+                    const updateQuery = this.updateTypeormMetadataSql({
+                        schema: database,
+                        table: tableName,
+                        name: oldColumn.name,
+                        type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                        valueToSet: { name: newColumn.name },
+                    });
+                    const revertUpdateQuery = this.updateTypeormMetadataSql({
+                        schema: database,
+                        table: tableName,
+                        name: newColumn.name,
+                        type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                        valueToSet: { name: oldColumn.name },
+                    });
+                    upQueries.push(updateQuery);
+                    downQueries.push(revertUpdateQuery);
+                }
                 // rename index constraints
                 clonedTable.findColumnIndices(oldColumn).forEach((index) => {
                     const oldUniqueName = this.dataSource.namingStrategy.indexName(clonedTable, index.columnNames);
@@ -837,74 +880,69 @@ class MysqlQueryRunner extends BaseQueryRunner_1.BaseQueryRunner {
                 downQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(table)} CHANGE \`${newColumn.name}\` ${this.buildCreateColumnSql(oldColumn, true)}`));
                 if (oldColumn.generatedType && !newColumn.generatedType) {
                     // if column changed from generated to non-generated, delete record from typeorm metadata
-                    const currentDatabase = await this.getCurrentDatabase();
+                    let { database, tableName } = this.driver.parseTableName(table);
+                    database ??= await this.getCurrentDatabase();
                     const deleteQuery = this.deleteTypeormMetadataSql({
-                        schema: currentDatabase,
-                        table: table.name,
-                        type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
-                        name: oldColumn.name,
-                    });
-                    const insertQuery = this.insertTypeormMetadataSql({
-                        schema: currentDatabase,
-                        table: table.name,
+                        schema: database,
+                        table: tableName,
                         type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
                         name: oldColumn.name,
-                        value: oldColumn.asExpression,
                     });
                     upQueries.push(deleteQuery);
-                    downQueries.push(insertQuery);
+                    if (oldColumn.asExpression) {
+                        const insertQuery = this.insertTypeormMetadataSql({
+                            schema: database,
+                            table: tableName,
+                            type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                            name: oldColumn.name,
+                            value: oldColumn.asExpression,
+                        });
+                        downQueries.push(insertQuery);
+                    }
                 }
                 else if (!oldColumn.generatedType &&
                     newColumn.generatedType) {
                     // if column changed from non-generated to generated, insert record into typeorm metadata
-                    const currentDatabase = await this.getCurrentDatabase();
-                    const insertQuery = this.insertTypeormMetadataSql({
-                        schema: currentDatabase,
-                        table: table.name,
-                        type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
-                        name: newColumn.name,
-                        value: newColumn.asExpression,
-                    });
+                    let { database, tableName } = this.driver.parseTableName(table);
+                    database ??= await this.getCurrentDatabase();
+                    if (newColumn.asExpression) {
+                        const insertQuery = this.insertTypeormMetadataSql({
+                            schema: database,
+                            table: tableName,
+                            type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                            name: newColumn.name,
+                            value: newColumn.asExpression,
+                        });
+                        upQueries.push(insertQuery);
+                    }
                     const deleteQuery = this.deleteTypeormMetadataSql({
-                        schema: currentDatabase,
-                        table: table.name,
+                        schema: database,
+                        table: tableName,
                         type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
                         name: newColumn.name,
                     });
-                    upQueries.push(insertQuery);
                     downQueries.push(deleteQuery);
                 }
                 else if (oldColumn.asExpression !== newColumn.asExpression) {
                     // if only expression changed, just update it in typeorm_metadata table
-                    const currentDatabase = await this.getCurrentDatabase();
-                    const updateQuery = this.dataSource
-                        .createQueryBuilder()
-                        .update(this.getTypeormMetadataTableName())
-                        .set({ value: newColumn.asExpression })
-                        .where("`type` = :type", {
+                    let { database, tableName } = this.driver.parseTableName(table);
+                    database ??= await this.getCurrentDatabase();
+                    const updateQuery = this.updateTypeormMetadataSql({
+                        schema: database,
+                        table: tableName,
                         type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
-                    })
-                        .andWhere("`name` = :name", { name: oldColumn.name })
-                        .andWhere("`schema` = :schema", {
-                        schema: currentDatabase,
-                    })
-                        .andWhere("`table` = :table", { table: table.name })
-                        .getQueryAndParameters();
-                    const revertUpdateQuery = this.dataSource
-                        .createQueryBuilder()
-                        .update(this.getTypeormMetadataTableName())
-                        .set({ value: oldColumn.asExpression })
-                        .where("`type` = :type", {
+                        name: oldColumn.name,
+                        valueToSet: { value: newColumn.asExpression },
+                    });
+                    const revertUpdateQuery = this.updateTypeormMetadataSql({
+                        schema: database,
+                        table: tableName,
                         type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
-                    })
-                        .andWhere("`name` = :name", { name: newColumn.name })
-                        .andWhere("`schema` = :schema", {
-                        schema: currentDatabase,
-                    })
-                        .andWhere("`table` = :table", { table: table.name })
-                        .getQueryAndParameters();
-                    upQueries.push(new Query_1.Query(updateQuery[0], updateQuery[1]));
-                    downQueries.push(new Query_1.Query(revertUpdateQuery[0], revertUpdateQuery[1]));
+                        name: newColumn.name,
+                        valueToSet: { value: oldColumn.asExpression },
+                    });
+                    upQueries.push(updateQuery);
+                    downQueries.push(revertUpdateQuery);
                 }
             }
             if (newColumn.isPrimary !== oldColumn.isPrimary) {
@@ -1094,23 +1132,26 @@ class MysqlQueryRunner extends BaseQueryRunner_1.BaseQueryRunner {
         }
         upQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(table)} DROP COLUMN \`${column.name}\``));
         downQueries.push(new Query_1.Query(`ALTER TABLE ${this.escapePath(table)} ADD ${this.buildCreateColumnSql(column, true)}`));
-        if (column.generatedType && column.asExpression) {
-            const currentDatabase = await this.getCurrentDatabase();
+        if (column.generatedType) {
+            let { database, tableName } = this.driver.parseTableName(table);
+            database ??= await this.getCurrentDatabase();
             const deleteQuery = this.deleteTypeormMetadataSql({
-                schema: currentDatabase,
-                table: table.name,
+                schema: database,
+                table: tableName,
                 type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
                 name: column.name,
             });
-            const insertQuery = this.insertTypeormMetadataSql({
-                schema: currentDatabase,
-                table: table.name,
-                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
-                name: column.name,
-                value: column.asExpression,
-            });
             upQueries.push(deleteQuery);
-            downQueries.push(insertQuery);
+            if (column.asExpression) {
+                const insertQuery = this.insertTypeormMetadataSql({
+                    schema: database,
+                    table: tableName,
+                    type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                    name: column.name,
+                    value: column.asExpression,
+                });
+                downQueries.push(insertQuery);
+            }
         }
         await this.executeQueries(upQueries, downQueries);
         clonedTable.removeColumn(column);
@@ -1521,6 +1562,13 @@ class MysqlQueryRunner extends BaseQueryRunner_1.BaseQueryRunner {
             const dropQueries = await this.query(dropTablesQuery, [dbName]);
             await Promise.all(dropQueries.map((query) => this.query(query["query"])));
             await this.query(enableForeignKeysCheckQuery);
+            if (database) {
+                const metadataTableName = this.getTypeormMetadataTableName();
+                const hasMetadataTable = await this.hasTable(metadataTableName);
+                if (hasMetadataTable) {
+                    await this.query(`DELETE FROM ${this.escapePath(metadataTableName)} WHERE \`schema\` = ?`, [database]);
+                }
+            }
             if (!isAnotherTransactionActive)
                 await this.commitTransaction();
         }