typeorm 0.3.6-dev.62518ae → 0.3.6-dev.78df84c

package/driver/sqlite-abstract/AbstractSqliteQueryRunner.js

@@ -180,7 +180,7 @@ class AbstractSqliteQueryRunner extends BaseQueryRunner_1.BaseQueryRunner {
         const tableName = InstanceChecker_1.InstanceChecker.isTable(tableOrName)
             ? tableOrName.name
             : tableOrName;
-        const sql = `PRAGMA table_info(${this.escapePath(tableName)})`;
+        const sql = `PRAGMA table_xinfo(${this.escapePath(tableName)})`;
         const columns = await this.query(sql);
         return !!columns.find((column) => column["name"] === columnName);
     }
@@ -230,6 +230,23 @@ class AbstractSqliteQueryRunner extends BaseQueryRunner_1.BaseQueryRunner {
                 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_1.MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+                value: column.asExpression,
+            });
+            const deleteQuery = this.deleteTypeormMetadataSql({
+                table: table.name,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+            });
+            upQueries.push(insertQuery);
+            downQueries.push(deleteQuery);
+        }
         await this.executeQueries(upQueries, downQueries);
     }
     /**
@@ -256,6 +273,23 @@ class AbstractSqliteQueryRunner extends BaseQueryRunner_1.BaseQueryRunner {
         }
         upQueries.push(this.dropTableSql(table, ifExist));
         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_1.MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+            });
+            const insertQuery = this.insertTypeormMetadataSql({
+                table: table.name,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+                value: column.asExpression,
+            });
+            upQueries.push(deleteQuery);
+            downQueries.push(insertQuery);
+        }
         await this.executeQueries(upQueries, downQueries);
     }
     /**
@@ -297,20 +331,32 @@ class AbstractSqliteQueryRunner extends BaseQueryRunner_1.BaseQueryRunner {
         const up = new Query_1.Query(`ALTER TABLE ${this.escapePath(oldTable.name)} RENAME TO ${this.escapePath(newTableName)}`);
         const down = new Query_1.Query(`ALTER TABLE ${this.escapePath(newTableName)} RENAME TO ${this.escapePath(oldTable.name)}`);
         await this.executeQueries(up, down);
-        // rename old table;
-        oldTable.name = newTable.name;
         // 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;
             unique.name = this.connection.namingStrategy.uniqueConstraintName(newTable, unique.columnNames);
         });
         // 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;
             foreignKey.name = this.connection.namingStrategy.foreignKeyName(newTable, foreignKey.columnNames, this.getTablePath(foreignKey), foreignKey.referencedColumnNames);
         });
         // rename indices
         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;
             index.name = this.connection.namingStrategy.indexName(newTable, index.columnNames, index.where);
         });
+        // rename old table;
+        oldTable.name = newTable.name;
         // recreate table with new constraint names
         await this.recreateTable(newTable, oldTable);
     }
@@ -385,24 +431,38 @@ class AbstractSqliteQueryRunner extends BaseQueryRunner_1.BaseQueryRunner {
                 changedTable
                     .findColumnUniques(changedColumnSet.oldColumn)
                     .forEach((unique) => {
+                    const uniqueName = this.connection.namingStrategy.uniqueConstraintName(table, unique.columnNames);
                     unique.columnNames.splice(unique.columnNames.indexOf(changedColumnSet.oldColumn.name), 1);
                     unique.columnNames.push(changedColumnSet.newColumn.name);
-                    unique.name =
-                        this.connection.namingStrategy.uniqueConstraintName(changedTable, unique.columnNames);
+                    // rename Unique only if it has default constraint name
+                    if (unique.name === uniqueName) {
+                        unique.name =
+                            this.connection.namingStrategy.uniqueConstraintName(changedTable, unique.columnNames);
+                    }
                 });
                 changedTable
                     .findColumnForeignKeys(changedColumnSet.oldColumn)
-                    .forEach((fk) => {
-                    fk.columnNames.splice(fk.columnNames.indexOf(changedColumnSet.oldColumn.name), 1);
-                    fk.columnNames.push(changedColumnSet.newColumn.name);
-                    fk.name = this.connection.namingStrategy.foreignKeyName(changedTable, fk.columnNames, this.getTablePath(fk), fk.referencedColumnNames);
+                    .forEach((foreignKey) => {
+                    const foreignKeyName = this.connection.namingStrategy.foreignKeyName(table, foreignKey.columnNames, this.getTablePath(foreignKey), foreignKey.referencedColumnNames);
+                    foreignKey.columnNames.splice(foreignKey.columnNames.indexOf(changedColumnSet.oldColumn.name), 1);
+                    foreignKey.columnNames.push(changedColumnSet.newColumn.name);
+                    // rename FK only if it has default constraint name
+                    if (foreignKey.name === foreignKeyName) {
+                        foreignKey.name =
+                            this.connection.namingStrategy.foreignKeyName(changedTable, foreignKey.columnNames, this.getTablePath(foreignKey), foreignKey.referencedColumnNames);
+                    }
                 });
                 changedTable
                     .findColumnIndices(changedColumnSet.oldColumn)
                     .forEach((index) => {
+                    const indexName = this.connection.namingStrategy.indexName(table, index.columnNames, index.where);
                     index.columnNames.splice(index.columnNames.indexOf(changedColumnSet.oldColumn.name), 1);
                     index.columnNames.push(changedColumnSet.newColumn.name);
-                    index.name = this.connection.namingStrategy.indexName(changedTable, index.columnNames, index.where);
+                    // rename Index only if it has default constraint name
+                    if (index.name === indexName) {
+                        index.name =
+                            this.connection.namingStrategy.indexName(changedTable, index.columnNames, index.where);
+                    }
                 });
             }
             const originalColumn = changedTable.columns.find((column) => column.name === changedColumnSet.oldColumn.name);
@@ -828,7 +888,7 @@ class AbstractSqliteQueryRunner extends BaseQueryRunner_1.BaseQueryRunner {
             const sql = dbTable["sql"];
             // load columns and indices
             const [dbColumns, dbIndices, dbForeignKeys] = await Promise.all([
-                this.loadPragmaRecords(tablePath, `table_info`),
+                this.loadPragmaRecords(tablePath, `table_xinfo`),
                 this.loadPragmaRecords(tablePath, `index_list`),
                 this.loadPragmaRecords(tablePath, `foreign_key_list`),
             ]);
@@ -860,7 +920,7 @@ class AbstractSqliteQueryRunner extends BaseQueryRunner_1.BaseQueryRunner {
                 }
             }
             // create columns from the loaded columns
-            table.columns = dbColumns.map((dbColumn) => {
+            table.columns = await Promise.all(dbColumns.map(async (dbColumn) => {
                 const tableColumn = new TableColumn_1.TableColumn();
                 tableColumn.name = dbColumn["name"];
                 tableColumn.type = dbColumn["type"].toLowerCase();
@@ -878,6 +938,23 @@ class AbstractSqliteQueryRunner extends BaseQueryRunner_1.BaseQueryRunner {
                 if (tableColumn.isGenerated) {
                     tableColumn.generationStrategy = "increment";
                 }
+                if (dbColumn["hidden"] === 2 ||
+                    dbColumn["hidden"] === 3) {
+                    tableColumn.generatedType =
+                        dbColumn["hidden"] === 2 ? "VIRTUAL" : "STORED";
+                    const asExpressionQuery = await this.selectTypeormMetadataSql({
+                        table: table.name,
+                        type: MetadataTableType_1.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 = "";
+                    }
+                }
                 if (tableColumn.type === "varchar") {
                     // Check if this is an enum
                     const enumMatch = sql.match(new RegExp('"(' +
@@ -917,7 +994,20 @@ class AbstractSqliteQueryRunner extends BaseQueryRunner_1.BaseQueryRunner {
                     }
                 }
                 return tableColumn;
-            });
+            }));
+            // find unique constraints from CREATE TABLE sql
+            let fkResult;
+            const fkMappings = [];
+            const fkRegex = /CONSTRAINT "([^"]*)" FOREIGN KEY \((.*?)\) REFERENCES "([^"]*)" /g;
+            while ((fkResult = fkRegex.exec(sql)) !== null) {
+                fkMappings.push({
+                    name: fkResult[1],
+                    columns: fkResult[2]
+                        .substr(1, fkResult[2].length - 2)
+                        .split(`", "`),
+                    referencedTableName: fkResult[3],
+                });
+            }
             // build foreign keys
             const tableForeignKeyConstraints = OrmUtils_1.OrmUtils.uniq(dbForeignKeys, (dbForeignKey) => dbForeignKey["id"]);
             table.foreignKeys = tableForeignKeyConstraints.map((foreignKey) => {
@@ -925,10 +1015,12 @@ class AbstractSqliteQueryRunner extends BaseQueryRunner_1.BaseQueryRunner {
                     dbForeignKey["table"] === foreignKey["table"]);
                 const columnNames = ownForeignKeys.map((dbForeignKey) => dbForeignKey["from"]);
                 const referencedColumnNames = ownForeignKeys.map((dbForeignKey) => dbForeignKey["to"]);
-                // build foreign key name, because we can not get it directly.
-                const fkName = this.connection.namingStrategy.foreignKeyName(table, columnNames, foreignKey.referencedTableName, foreignKey.referencedColumnNames);
+                // find related foreign key mapping
+                const fkMapping = fkMappings.find((it) => it.referencedTableName ===
+                    foreignKey["table"] &&
+                    it.columns.every((column) => columnNames.indexOf(column) !== -1));
                 return new TableForeignKey_1.TableForeignKey({
-                    name: fkName,
+                    name: fkMapping.name,
                     columnNames: columnNames,
                     referencedTableName: foreignKey["table"],
                     referencedColumnNames: referencedColumnNames,
@@ -1211,8 +1303,13 @@ class AbstractSqliteQueryRunner extends BaseQueryRunner_1.BaseQueryRunner {
             c += " COLLATE " + column.collation;
         if (column.isNullable !== true)
             c += " NOT NULL";
-        if (column.default !== undefined && column.default !== null)
-            c += " DEFAULT (" + column.default + ")";
+        if (column.asExpression) {
+            c += ` AS (${column.asExpression}) ${column.generatedType ? column.generatedType : "VIRTUAL"}`;
+        }
+        else {
+            if (column.default !== undefined && column.default !== null)
+                c += " DEFAULT (" + column.default + ")";
+        }
         return c;
     }
     async recreateTable(newTable, oldTable, migrateData = true) {
@@ -1233,29 +1330,31 @@ class AbstractSqliteQueryRunner extends BaseQueryRunner_1.BaseQueryRunner {
         // migrate all data from the old table into new table
         if (migrateData) {
             let newColumnNames = newTable.columns
-                .map((column) => `"${column.name}"`)
-                .join(", ");
+                .filter((column) => !column.generatedType)
+                .map((column) => `"${column.name}"`);
             let oldColumnNames = oldTable.columns
-                .map((column) => `"${column.name}"`)
-                .join(", ");
-            if (oldTable.columns.length < newTable.columns.length) {
+                .filter((column) => !column.generatedType)
+                .map((column) => `"${column.name}"`);
+            if (oldColumnNames.length < newColumnNames.length) {
                 newColumnNames = newTable.columns
                     .filter((column) => {
-                    return oldTable.columns.find((c) => c.name === column.name);
+                    const oldColumn = oldTable.columns.find((c) => c.name === column.name);
+                    if (oldColumn && oldColumn.generatedType)
+                        return false;
+                    return !column.generatedType && oldColumn;
                 })
-                    .map((column) => `"${column.name}"`)
-                    .join(", ");
+                    .map((column) => `"${column.name}"`);
             }
-            else if (oldTable.columns.length > newTable.columns.length) {
+            else if (oldColumnNames.length > newColumnNames.length) {
                 oldColumnNames = oldTable.columns
                     .filter((column) => {
-                    return newTable.columns.find((c) => c.name === column.name);
+                    return (!column.generatedType &&
+                        newTable.columns.find((c) => c.name === column.name));
                 })
-                    .map((column) => `"${column.name}"`)
-                    .join(", ");
+                    .map((column) => `"${column.name}"`);
             }
-            upQueries.push(new Query_1.Query(`INSERT INTO ${this.escapePath(newTable.name)}(${newColumnNames}) SELECT ${oldColumnNames} FROM ${this.escapePath(oldTable.name)}`));
-            downQueries.push(new Query_1.Query(`INSERT INTO ${this.escapePath(oldTable.name)}(${oldColumnNames}) SELECT ${newColumnNames} FROM ${this.escapePath(newTable.name)}`));
+            upQueries.push(new Query_1.Query(`INSERT INTO ${this.escapePath(newTable.name)}(${newColumnNames.join(", ")}) SELECT ${oldColumnNames.join(", ")} FROM ${this.escapePath(oldTable.name)}`));
+            downQueries.push(new Query_1.Query(`INSERT INTO ${this.escapePath(oldTable.name)}(${oldColumnNames.join(", ")}) SELECT ${newColumnNames.join(", ")} FROM ${this.escapePath(newTable.name)}`));
         }
         // drop old table
         upQueries.push(this.dropTableSql(oldTable));
@@ -1272,6 +1371,93 @@ class AbstractSqliteQueryRunner extends BaseQueryRunner_1.BaseQueryRunner {
             upQueries.push(this.createIndexSql(newTable, index));
             downQueries.push(this.dropIndexSql(index));
         });
+        // update generated columns in "typeorm_metadata" table
+        // Step 1: clear data for removed generated columns
+        oldTable.columns
+            .filter((column) => {
+            const newTableColumn = newTable.columns.find((c) => c.name === column.name);
+            // we should delete record from "typeorm_metadata" if generated column was removed
+            // or it was changed to non-generated
+            return (column.generatedType &&
+                column.asExpression &&
+                (!newTableColumn ||
+                    (!newTableColumn.generatedType &&
+                        !newTableColumn.asExpression)));
+        })
+            .forEach((column) => {
+            const deleteQuery = this.deleteTypeormMetadataSql({
+                table: oldTable.name,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+            });
+            const insertQuery = this.insertTypeormMetadataSql({
+                table: oldTable.name,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+                value: column.asExpression,
+            });
+            upQueries.push(deleteQuery);
+            downQueries.push(insertQuery);
+        });
+        // Step 2: add data for new generated columns
+        newTable.columns
+            .filter((column) => column.generatedType &&
+            column.asExpression &&
+            !oldTable.columns.some((c) => c.name === column.name))
+            .forEach((column) => {
+            const insertQuery = this.insertTypeormMetadataSql({
+                table: newTable.name,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+                value: column.asExpression,
+            });
+            const deleteQuery = this.deleteTypeormMetadataSql({
+                table: newTable.name,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+            });
+            upQueries.push(insertQuery);
+            downQueries.push(deleteQuery);
+        });
+        // Step 3: update changed expressions
+        newTable.columns
+            .filter((column) => column.generatedType && column.asExpression)
+            .forEach((column) => {
+            const oldColumn = oldTable.columns.find((c) => c.name === column.name &&
+                c.generatedType &&
+                column.generatedType &&
+                c.asExpression !== column.asExpression);
+            if (!oldColumn)
+                return;
+            // update expression
+            const deleteQuery = this.deleteTypeormMetadataSql({
+                table: oldTable.name,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                name: oldColumn.name,
+            });
+            const insertQuery = this.insertTypeormMetadataSql({
+                table: newTable.name,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+                value: column.asExpression,
+            });
+            upQueries.push(deleteQuery);
+            upQueries.push(insertQuery);
+            // revert update
+            const revertInsertQuery = this.insertTypeormMetadataSql({
+                table: newTable.name,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                name: oldColumn.name,
+                value: oldColumn.asExpression,
+            });
+            const revertDeleteQuery = this.deleteTypeormMetadataSql({
+                table: oldTable.name,
+                type: MetadataTableType_1.MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+            });
+            downQueries.push(revertInsertQuery);
+            downQueries.push(revertDeleteQuery);
+        });
         await this.executeQueries(upQueries, downQueries);
         this.replaceCachedTable(oldTable, newTable);
     }