typeorm 0.3.5 → 0.3.6-dev.0418ebc

package/browser/driver/sqlite-abstract/AbstractSqliteQueryRunner.js

@@ -177,7 +177,7 @@ export class AbstractSqliteQueryRunner extends BaseQueryRunner {
         const tableName = 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);
     }
@@ -227,6 +227,23 @@ export class AbstractSqliteQueryRunner extends 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.GENERATED_COLUMN,
+                name: column.name,
+                value: column.asExpression,
+            });
+            const deleteQuery = this.deleteTypeormMetadataSql({
+                table: table.name,
+                type: MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+            });
+            upQueries.push(insertQuery);
+            downQueries.push(deleteQuery);
+        }
         await this.executeQueries(upQueries, downQueries);
     }
     /**
@@ -253,6 +270,23 @@ export class AbstractSqliteQueryRunner extends 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.GENERATED_COLUMN,
+                name: column.name,
+            });
+            const insertQuery = this.insertTypeormMetadataSql({
+                table: table.name,
+                type: MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+                value: column.asExpression,
+            });
+            upQueries.push(deleteQuery);
+            downQueries.push(insertQuery);
+        }
         await this.executeQueries(upQueries, downQueries);
     }
     /**
@@ -825,7 +859,7 @@ export class AbstractSqliteQueryRunner extends 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`),
             ]);
@@ -857,7 +891,7 @@ export class AbstractSqliteQueryRunner extends 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();
                 tableColumn.name = dbColumn["name"];
                 tableColumn.type = dbColumn["type"].toLowerCase();
@@ -875,6 +909,23 @@ export class AbstractSqliteQueryRunner extends 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.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('"(' +
@@ -914,7 +965,7 @@ export class AbstractSqliteQueryRunner extends BaseQueryRunner {
                     }
                 }
                 return tableColumn;
-            });
+            }));
             // build foreign keys
             const tableForeignKeyConstraints = OrmUtils.uniq(dbForeignKeys, (dbForeignKey) => dbForeignKey["id"]);
             table.foreignKeys = tableForeignKeyConstraints.map((foreignKey) => {
@@ -1208,8 +1259,13 @@ export class AbstractSqliteQueryRunner extends 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) {
@@ -1230,29 +1286,31 @@ export class AbstractSqliteQueryRunner extends 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(`INSERT INTO ${this.escapePath(newTable.name)}(${newColumnNames}) SELECT ${oldColumnNames} FROM ${this.escapePath(oldTable.name)}`));
-            downQueries.push(new Query(`INSERT INTO ${this.escapePath(oldTable.name)}(${oldColumnNames}) SELECT ${newColumnNames} FROM ${this.escapePath(newTable.name)}`));
+            upQueries.push(new Query(`INSERT INTO ${this.escapePath(newTable.name)}(${newColumnNames.join(", ")}) SELECT ${oldColumnNames.join(", ")} FROM ${this.escapePath(oldTable.name)}`));
+            downQueries.push(new 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));
@@ -1269,6 +1327,93 @@ export class AbstractSqliteQueryRunner extends 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.GENERATED_COLUMN,
+                name: column.name,
+            });
+            const insertQuery = this.insertTypeormMetadataSql({
+                table: oldTable.name,
+                type: 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.GENERATED_COLUMN,
+                name: column.name,
+                value: column.asExpression,
+            });
+            const deleteQuery = this.deleteTypeormMetadataSql({
+                table: newTable.name,
+                type: 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.GENERATED_COLUMN,
+                name: oldColumn.name,
+            });
+            const insertQuery = this.insertTypeormMetadataSql({
+                table: newTable.name,
+                type: 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.GENERATED_COLUMN,
+                name: oldColumn.name,
+                value: oldColumn.asExpression,
+            });
+            const revertDeleteQuery = this.deleteTypeormMetadataSql({
+                table: oldTable.name,
+                type: MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+            });
+            downQueries.push(revertInsertQuery);
+            downQueries.push(revertDeleteQuery);
+        });
         await this.executeQueries(upQueries, downQueries);
         this.replaceCachedTable(oldTable, newTable);
     }