typeorm 0.3.6-dev.9d331b1 → 0.3.6-dev.bbdc20f

package/browser/driver/mysql/MysqlQueryRunner.js

@@ -315,6 +315,26 @@ export class MysqlQueryRunner extends BaseQueryRunner {
         // 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 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);
+        for (const column of generatedColumns) {
+            const currentDatabase = await this.getCurrentDatabase();
+            const insertQuery = this.insertTypeormMetadataSql({
+                schema: currentDatabase,
+                table: table.name,
+                type: MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+                value: column.asExpression,
+            });
+            const deleteQuery = this.deleteTypeormMetadataSql({
+                schema: currentDatabase,
+                table: table.name,
+                type: MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+            });
+            upQueries.push(insertQuery);
+            downQueries.push(deleteQuery);
+        }
         return this.executeQueries(upQueries, downQueries);
     }
     /**
@@ -339,6 +359,26 @@ export class MysqlQueryRunner extends BaseQueryRunner {
         table.indices.forEach((index) => upQueries.push(this.dropIndexSql(table, index)));
         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 currentDatabase = await this.getCurrentDatabase();
+            const deleteQuery = this.deleteTypeormMetadataSql({
+                schema: currentDatabase,
+                table: table.name,
+                type: MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+            });
+            const insertQuery = this.insertTypeormMetadataSql({
+                schema: currentDatabase,
+                table: table.name,
+                type: MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+                value: column.asExpression,
+            });
+            upQueries.push(deleteQuery);
+            downQueries.push(insertQuery);
+        }
         await this.executeQueries(upQueries, downQueries);
     }
     /**
@@ -384,6 +424,10 @@ export class MysqlQueryRunner extends BaseQueryRunner {
         downQueries.push(new Query(`RENAME TABLE ${this.escapePath(newTable)} TO ${this.escapePath(oldTable)}`));
         // rename index constraints
         newTable.indices.forEach((index) => {
+            const oldIndexName = this.connection.namingStrategy.indexName(oldTable, index.columnNames);
+            // Skip renaming if Index has user defined constraint name
+            if (index.name !== oldIndexName)
+                return;
             // build new constraint name
             const columnNames = index.columnNames
                 .map((column) => `\`${column}\``)
@@ -407,6 +451,10 @@ export class MysqlQueryRunner extends BaseQueryRunner {
         });
         // rename foreign key constraint
         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 columnNames = foreignKey.columnNames
                 .map((column) => `\`${column}\``)
@@ -484,6 +532,24 @@ export class MysqlQueryRunner extends BaseQueryRunner {
                 downQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} CHANGE \`${column.name}\` ${this.buildCreateColumnSql(nonGeneratedColumn, true)}`));
             }
         }
+        if (column.generatedType && column.asExpression) {
+            const currentDatabase = await this.getCurrentDatabase();
+            const insertQuery = this.insertTypeormMetadataSql({
+                schema: currentDatabase,
+                table: table.name,
+                type: MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+                value: column.asExpression,
+            });
+            const deleteQuery = this.deleteTypeormMetadataSql({
+                schema: currentDatabase,
+                table: table.name,
+                type: MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+            });
+            upQueries.push(insertQuery);
+            downQueries.push(deleteQuery);
+        }
         // create column index
         const columnIndex = clonedTable.indices.find((index) => index.columnNames.length === 1 &&
             index.columnNames[0] === column.name);
@@ -560,7 +626,12 @@ export class MysqlQueryRunner extends BaseQueryRunner {
             newColumn.generationStrategy !== "uuid") ||
             oldColumn.type !== newColumn.type ||
             oldColumn.length !== newColumn.length ||
-            oldColumn.generatedType !== newColumn.generatedType) {
+            (oldColumn.generatedType &&
+                newColumn.generatedType &&
+                oldColumn.generatedType !== newColumn.generatedType) ||
+            (!oldColumn.generatedType &&
+                newColumn.generatedType === "VIRTUAL") ||
+            (oldColumn.generatedType === "VIRTUAL" && !newColumn.generatedType)) {
             await this.dropColumn(table, oldColumn);
             await this.addColumn(table, newColumn);
             // update cloned table
@@ -573,6 +644,10 @@ export class MysqlQueryRunner extends BaseQueryRunner {
                 downQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} CHANGE \`${newColumn.name}\` \`${oldColumn.name}\` ${this.buildCreateColumnSql(oldColumn, true, true)}`));
                 // rename index constraints
                 clonedTable.findColumnIndices(oldColumn).forEach((index) => {
+                    const oldUniqueName = this.connection.namingStrategy.indexName(clonedTable, index.columnNames);
+                    // Skip renaming if Index has user defined constraint name
+                    if (index.name !== oldUniqueName)
+                        return;
                     // build new constraint name
                     index.columnNames.splice(index.columnNames.indexOf(oldColumn.name), 1);
                     index.columnNames.push(newColumn.name);
@@ -600,6 +675,10 @@ export class MysqlQueryRunner extends BaseQueryRunner {
                 clonedTable
                     .findColumnForeignKeys(oldColumn)
                     .forEach((foreignKey) => {
+                    const foreignKeyName = this.connection.namingStrategy.foreignKeyName(clonedTable, foreignKey.columnNames, this.getTablePath(foreignKey), foreignKey.referencedColumnNames);
+                    // Skip renaming if foreign key has user defined constraint name
+                    if (foreignKey.name !== foreignKeyName)
+                        return;
                     // build new constraint name
                     foreignKey.columnNames.splice(foreignKey.columnNames.indexOf(oldColumn.name), 1);
                     foreignKey.columnNames.push(newColumn.name);
@@ -636,6 +715,77 @@ export class MysqlQueryRunner extends BaseQueryRunner {
             if (this.isColumnChanged(oldColumn, newColumn, true, true)) {
                 upQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} CHANGE \`${oldColumn.name}\` ${this.buildCreateColumnSql(newColumn, true)}`));
                 downQueries.push(new 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();
+                    const deleteQuery = this.deleteTypeormMetadataSql({
+                        schema: currentDatabase,
+                        table: table.name,
+                        type: MetadataTableType.GENERATED_COLUMN,
+                        name: oldColumn.name,
+                    });
+                    const insertQuery = this.insertTypeormMetadataSql({
+                        schema: currentDatabase,
+                        table: table.name,
+                        type: MetadataTableType.GENERATED_COLUMN,
+                        name: oldColumn.name,
+                        value: oldColumn.asExpression,
+                    });
+                    upQueries.push(deleteQuery);
+                    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.GENERATED_COLUMN,
+                        name: newColumn.name,
+                        value: newColumn.asExpression,
+                    });
+                    const deleteQuery = this.deleteTypeormMetadataSql({
+                        schema: currentDatabase,
+                        table: table.name,
+                        type: 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.connection
+                        .createQueryBuilder()
+                        .update(this.getTypeormMetadataTableName())
+                        .set({ value: newColumn.asExpression })
+                        .where("`type` = :type", {
+                        type: MetadataTableType.GENERATED_COLUMN,
+                    })
+                        .andWhere("`name` = :name", { name: oldColumn.name })
+                        .andWhere("`schema` = :schema", {
+                        schema: currentDatabase,
+                    })
+                        .andWhere("`table` = :table", { table: table.name })
+                        .getQueryAndParameters();
+                    const revertUpdateQuery = this.connection
+                        .createQueryBuilder()
+                        .update(this.getTypeormMetadataTableName())
+                        .set({ value: oldColumn.asExpression })
+                        .where("`type` = :type", {
+                        type: 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(updateQuery[0], updateQuery[1]));
+                    downQueries.push(new Query(revertUpdateQuery[0], revertUpdateQuery[1]));
+                }
             }
             if (newColumn.isPrimary !== oldColumn.isPrimary) {
                 // if table have generated column, we must drop AUTO_INCREMENT before changing primary constraints.
@@ -814,6 +964,24 @@ export class MysqlQueryRunner extends BaseQueryRunner {
         }
         upQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} DROP COLUMN \`${column.name}\``));
         downQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} ADD ${this.buildCreateColumnSql(column, true)}`));
+        if (column.generatedType && column.asExpression) {
+            const currentDatabase = await this.getCurrentDatabase();
+            const deleteQuery = this.deleteTypeormMetadataSql({
+                schema: currentDatabase,
+                table: table.name,
+                type: MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+            });
+            const insertQuery = this.insertTypeormMetadataSql({
+                schema: currentDatabase,
+                table: table.name,
+                type: MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+                value: column.asExpression,
+            });
+            upQueries.push(deleteQuery);
+            downQueries.push(insertQuery);
+        }
         await this.executeQueries(upQueries, downQueries);
         clonedTable.removeColumn(column);
         this.replaceCachedTable(table, clonedTable);
@@ -1349,11 +1517,12 @@ export class MysqlQueryRunner extends BaseQueryRunner {
             table.database = dbTable["TABLE_SCHEMA"];
             table.name = this.driver.buildTableName(dbTable["TABLE_NAME"], undefined, db);
             // create columns from the loaded columns
-            table.columns = dbColumns
-                .filter((dbColumn) => dbColumn["TABLE_NAME"] === dbTable["TABLE_NAME"] &&
+            table.columns = await Promise.all(dbColumns
+                .filter((dbColumn) => dbColumn["TABLE_NAME"] ===
+                dbTable["TABLE_NAME"] &&
                 dbColumn["TABLE_SCHEMA"] ===
                     dbTable["TABLE_SCHEMA"])
-                .map((dbColumn) => {
+                .map(async (dbColumn) => {
                 const columnUniqueIndices = dbIndices.filter((dbIndex) => {
                     return (dbIndex["TABLE_NAME"] ===
                         dbTable["TABLE_NAME"] &&
@@ -1361,7 +1530,8 @@ export class MysqlQueryRunner extends BaseQueryRunner {
                             dbTable["TABLE_SCHEMA"] &&
                         dbIndex["COLUMN_NAME"] ===
                             dbColumn["COLUMN_NAME"] &&
-                        parseInt(dbIndex["NON_UNIQUE"], 10) === 0);
+                        parseInt(dbIndex["NON_UNIQUE"], 10) ===
+                            0);
                 });
                 const tableMetadata = this.connection.entityMetadatas.find((metadata) => this.getTablePath(table) ===
                     this.getTablePath(metadata));
@@ -1382,9 +1552,11 @@ export class MysqlQueryRunner extends BaseQueryRunner {
                 });
                 const tableColumn = new TableColumn();
                 tableColumn.name = dbColumn["COLUMN_NAME"];
-                tableColumn.type = dbColumn["DATA_TYPE"].toLowerCase();
+                tableColumn.type =
+                    dbColumn["DATA_TYPE"].toLowerCase();
                 tableColumn.zerofill =
-                    dbColumn["COLUMN_TYPE"].indexOf("zerofill") !== -1;
+                    dbColumn["COLUMN_TYPE"].indexOf("zerofill") !==
+                        -1;
                 tableColumn.unsigned = tableColumn.zerofill
                     ? true
                     : dbColumn["COLUMN_TYPE"].indexOf("unsigned") !== -1;
@@ -1398,7 +1570,8 @@ export class MysqlQueryRunner extends BaseQueryRunner {
                 }
                 if (dbColumn["COLUMN_DEFAULT"] === null ||
                     dbColumn["COLUMN_DEFAULT"] === undefined ||
-                    (isMariaDb && dbColumn["COLUMN_DEFAULT"] === "NULL")) {
+                    (isMariaDb &&
+                        dbColumn["COLUMN_DEFAULT"] === "NULL")) {
                     tableColumn.default = undefined;
                 }
                 else if (/^CURRENT_TIMESTAMP(\([0-9]*\))?$/i.test(dbColumn["COLUMN_DEFAULT"])) {
@@ -1420,23 +1593,41 @@ export class MysqlQueryRunner extends BaseQueryRunner {
                     // New versions of MariaDB return expressions in lowercase.  We need to set it in
                     // uppercase so the comparison in MysqlDriver#compareExtraValues does not fail.
                     tableColumn.onUpdate = dbColumn["EXTRA"]
-                        .substring(dbColumn["EXTRA"].indexOf("on update") + 10)
+                        .substring(dbColumn["EXTRA"].indexOf("on update") +
+                        10)
                         .toUpperCase();
                 }
                 if (dbColumn["GENERATION_EXPRESSION"]) {
-                    tableColumn.asExpression =
-                        dbColumn["GENERATION_EXPRESSION"];
                     tableColumn.generatedType =
                         dbColumn["EXTRA"].indexOf("VIRTUAL") !== -1
                             ? "VIRTUAL"
                             : "STORED";
+                    // We cannot relay on information_schema.columns.generation_expression, because it is formatted different.
+                    const asExpressionQuery = await this.selectTypeormMetadataSql({
+                        schema: dbTable["TABLE_SCHEMA"],
+                        table: dbTable["TABLE_NAME"],
+                        type: MetadataTableType.GENERATED_COLUMN,
+                        name: tableColumn.name,
+                    });
+                    const results = await this.query(asExpressionQuery.query, asExpressionQuery.parameters);
+                    if (results[0] && results[0].value) {
+                        tableColumn.asExpression = results[0].value;
+                    }
+                    else {
+                        tableColumn.asExpression = "";
+                    }
                 }
                 tableColumn.isUnique =
                     columnUniqueIndices.length > 0 &&
                         !hasIgnoredIndex &&
                         !isConstraintComposite;
-                tableColumn.isNullable =
-                    dbColumn["IS_NULLABLE"] === "YES";
+                if (isMariaDb && tableColumn.generatedType) {
+                    // do nothing - MariaDB does not support NULL/NOT NULL expressions for generated columns
+                }
+                else {
+                    tableColumn.isNullable =
+                        dbColumn["IS_NULLABLE"] === "YES";
+                }
                 tableColumn.isPrimary = dbPrimaryKeys.some((dbPrimaryKey) => {
                     return (dbPrimaryKey["TABLE_NAME"] ===
                         dbColumn["TABLE_NAME"] &&
@@ -1446,11 +1637,13 @@ export class MysqlQueryRunner extends BaseQueryRunner {
                             dbColumn["COLUMN_NAME"]);
                 });
                 tableColumn.isGenerated =
-                    dbColumn["EXTRA"].indexOf("auto_increment") !== -1;
+                    dbColumn["EXTRA"].indexOf("auto_increment") !==
+                        -1;
                 if (tableColumn.isGenerated)
                     tableColumn.generationStrategy = "increment";
                 tableColumn.comment =
-                    typeof dbColumn["COLUMN_COMMENT"] === "string" &&
+                    typeof dbColumn["COLUMN_COMMENT"] ===
+                        "string" &&
                         dbColumn["COLUMN_COMMENT"].length === 0
                         ? undefined
                         : dbColumn["COLUMN_COMMENT"];
@@ -1462,16 +1655,18 @@ export class MysqlQueryRunner extends BaseQueryRunner {
                             : dbColumn["CHARACTER_SET_NAME"];
                 if (dbColumn["COLLATION_NAME"])
                     tableColumn.collation =
-                        dbColumn["COLLATION_NAME"] === defaultCollation
+                        dbColumn["COLLATION_NAME"] ===
+                            defaultCollation
                             ? undefined
                             : dbColumn["COLLATION_NAME"];
                 // check only columns that have length property
                 if (this.driver.withLengthColumnTypes.indexOf(tableColumn.type) !== -1 &&
                     dbColumn["CHARACTER_MAXIMUM_LENGTH"]) {
                     const length = dbColumn["CHARACTER_MAXIMUM_LENGTH"].toString();
-                    tableColumn.length = !this.isDefaultColumnLength(table, tableColumn, length)
-                        ? length
-                        : "";
+                    tableColumn.length =
+                        !this.isDefaultColumnLength(table, tableColumn, length)
+                            ? length
+                            : "";
                 }
                 if (tableColumn.type === "decimal" ||
                     tableColumn.type === "double" ||
@@ -1504,7 +1699,7 @@ export class MysqlQueryRunner extends BaseQueryRunner {
                     tableColumn.precision = parseInt(dbColumn["DATETIME_PRECISION"]);
                 }
                 return tableColumn;
-            });
+            }));
             // find foreign key constraints of table, group them by constraint name and build TableForeignKey.
             const tableForeignKeyConstraints = OrmUtils.uniq(dbForeignKeys.filter((dbForeignKey) => {
                 return (dbForeignKey["TABLE_NAME"] ===
@@ -1801,6 +1996,10 @@ export class MysqlQueryRunner extends BaseQueryRunner {
         else {
             c = `\`${column.name}\` ${this.connection.driver.createFullType(column)}`;
         }
+        if (column.charset)
+            c += ` CHARACTER SET "${column.charset}"`;
+        if (column.collation)
+            c += ` COLLATE "${column.collation}"`;
         if (column.asExpression)
             c += ` AS (${column.asExpression}) ${column.generatedType ? column.generatedType : "VIRTUAL"}`;
         // if you specify ZEROFILL for a numeric column, MySQL automatically adds the UNSIGNED attribute to that column.
@@ -1814,10 +2013,6 @@ export class MysqlQueryRunner extends BaseQueryRunner {
             c += ` (${column.enum
                 .map((value) => "'" + value.replace(/'/g, "''") + "'")
                 .join(", ")})`;
-        if (column.charset)
-            c += ` CHARACTER SET "${column.charset}"`;
-        if (column.collation)
-            c += ` COLLATE "${column.collation}"`;
         const isMariaDb = this.driver.options.type === "mariadb";
         if (isMariaDb &&
             column.asExpression &&