typeorm 0.3.5 → 0.3.6-dev.2d8afbe

package/browser/driver/sqlserver/SqlServerQueryRunner.js

@@ -454,6 +454,31 @@ export class SqlServerQueryRunner extends BaseQueryRunner {
                 downQueries.push(this.dropIndexSql(table, 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 parsedTableName = this.driver.parseTableName(table);
+            if (!parsedTableName.schema) {
+                parsedTableName.schema = await this.getCurrentSchema();
+            }
+            const insertQuery = this.insertTypeormMetadataSql({
+                database: parsedTableName.database,
+                schema: parsedTableName.schema,
+                table: parsedTableName.tableName,
+                type: MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+                value: column.asExpression,
+            });
+            const deleteQuery = this.deleteTypeormMetadataSql({
+                database: parsedTableName.database,
+                schema: parsedTableName.schema,
+                table: parsedTableName.tableName,
+                type: MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+            });
+            upQueries.push(insertQuery);
+            downQueries.push(deleteQuery);
+        }
         await this.executeQueries(upQueries, downQueries);
     }
     /**
@@ -486,6 +511,31 @@ export class SqlServerQueryRunner extends BaseQueryRunner {
             table.foreignKeys.forEach((foreignKey) => upQueries.push(this.dropForeignKeySql(table, foreignKey)));
         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 parsedTableName = this.driver.parseTableName(table);
+            if (!parsedTableName.schema) {
+                parsedTableName.schema = await this.getCurrentSchema();
+            }
+            const deleteQuery = this.deleteTypeormMetadataSql({
+                database: parsedTableName.database,
+                schema: parsedTableName.schema,
+                table: parsedTableName.tableName,
+                type: MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+            });
+            const insertQuery = this.insertTypeormMetadataSql({
+                database: parsedTableName.database,
+                schema: parsedTableName.schema,
+                table: parsedTableName.tableName,
+                type: MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+                value: column.asExpression,
+            });
+            upQueries.push(deleteQuery);
+            downQueries.push(insertQuery);
+        }
         await this.executeQueries(upQueries, downQueries);
     }
     /**
@@ -653,6 +703,29 @@ export class SqlServerQueryRunner extends BaseQueryRunner {
             const defaultName = this.connection.namingStrategy.defaultConstraintName(table, column.name);
             downQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} DROP CONSTRAINT "${defaultName}"`));
         }
+        if (column.generatedType && column.asExpression) {
+            const parsedTableName = this.driver.parseTableName(table);
+            if (!parsedTableName.schema) {
+                parsedTableName.schema = await this.getCurrentSchema();
+            }
+            const insertQuery = this.insertTypeormMetadataSql({
+                database: parsedTableName.database,
+                schema: parsedTableName.schema,
+                table: parsedTableName.tableName,
+                type: MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+                value: column.asExpression,
+            });
+            const deleteQuery = this.deleteTypeormMetadataSql({
+                database: parsedTableName.database,
+                schema: parsedTableName.schema,
+                table: parsedTableName.tableName,
+                type: MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+            });
+            upQueries.push(insertQuery);
+            downQueries.push(deleteQuery);
+        }
         await this.executeQueries(upQueries, downQueries);
         clonedTable.addColumn(column);
         this.replaceCachedTable(table, clonedTable);
@@ -705,7 +778,9 @@ export class SqlServerQueryRunner extends BaseQueryRunner {
         if ((newColumn.isGenerated !== oldColumn.isGenerated &&
             newColumn.generationStrategy !== "uuid") ||
             newColumn.type !== oldColumn.type ||
-            newColumn.length !== oldColumn.length) {
+            newColumn.length !== oldColumn.length ||
+            newColumn.asExpression !== oldColumn.asExpression ||
+            newColumn.generatedType !== oldColumn.generatedType) {
             // 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);
@@ -979,6 +1054,29 @@ export class SqlServerQueryRunner extends BaseQueryRunner {
             upQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} DROP CONSTRAINT "${defaultName}"`));
             downQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} ADD CONSTRAINT "${defaultName}" DEFAULT ${column.default} FOR "${column.name}"`));
         }
+        if (column.generatedType && column.asExpression) {
+            const parsedTableName = this.driver.parseTableName(table);
+            if (!parsedTableName.schema) {
+                parsedTableName.schema = await this.getCurrentSchema();
+            }
+            const deleteQuery = this.deleteTypeormMetadataSql({
+                database: parsedTableName.database,
+                schema: parsedTableName.schema,
+                table: parsedTableName.tableName,
+                type: MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+            });
+            const insertQuery = this.insertTypeormMetadataSql({
+                database: parsedTableName.database,
+                schema: parsedTableName.schema,
+                table: parsedTableName.tableName,
+                type: MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+                value: column.asExpression,
+            });
+            upQueries.push(deleteQuery);
+            downQueries.push(insertQuery);
+        }
         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(table, column, false, false)}`));
         await this.executeQueries(upQueries, downQueries);
@@ -1427,12 +1525,9 @@ export class SqlServerQueryRunner extends BaseQueryRunner {
         const currentDatabase = await this.getCurrentDatabase();
         const dbTables = [];
         if (!tableNames) {
-            const databasesSql = `
-                SELECT DISTINCT
-                    "name"
-                FROM "master"."dbo"."sysdatabases"
-                WHERE "name" NOT IN ('master', 'model', 'msdb')
-            `;
+            const databasesSql = `SELECT DISTINCT "name" ` +
+                `FROM "master"."dbo"."sysdatabases" ` +
+                `WHERE "name" NOT IN ('master', 'model', 'msdb')`;
             const dbDatabases = await this.query(databasesSql);
             const tablesSql = dbDatabases
                 .map(({ name }) => {
@@ -1497,7 +1592,10 @@ export class SqlServerQueryRunner extends BaseQueryRunner {
             const condition = tables
                 .map(({ TABLE_SCHEMA, TABLE_NAME }) => `("TABLE_SCHEMA" = '${TABLE_SCHEMA}' AND "TABLE_NAME" = '${TABLE_NAME}')`)
                 .join("OR");
-            return `SELECT * FROM "${TABLE_CATALOG}"."INFORMATION_SCHEMA"."COLUMNS" WHERE (${condition})`;
+            return (`SELECT "COLUMNS".*, "cc"."is_persisted", "cc"."definition" ` +
+                `FROM "${TABLE_CATALOG}"."INFORMATION_SCHEMA"."COLUMNS" ` +
+                `LEFT JOIN "sys"."computed_columns" "cc" ON COL_NAME("cc"."object_id", "cc"."column_id") = "column_name" ` +
+                `WHERE (${condition})`);
         })
             .join(" UNION ALL ");
         const constraintsSql = Object.entries(dbTablesByCatalog)
@@ -1597,13 +1695,14 @@ export class SqlServerQueryRunner extends BaseQueryRunner {
             table.name = this.driver.buildTableName(dbTable["TABLE_NAME"], schema, db);
             const defaultCollation = dbCollations.find((dbCollation) => dbCollation["NAME"] === dbTable["TABLE_CATALOG"]);
             // 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"] &&
                 dbColumn["TABLE_CATALOG"] ===
                     dbTable["TABLE_CATALOG"])
-                .map((dbColumn) => {
+                .map(async (dbColumn) => {
                 const columnConstraints = dbConstraints.filter((dbConstraint) => dbConstraint["TABLE_NAME"] ===
                     dbColumn["TABLE_NAME"] &&
                     dbConstraint["TABLE_SCHEMA"] ===
@@ -1625,7 +1724,8 @@ export class SqlServerQueryRunner extends BaseQueryRunner {
                         dbConstraint["COLUMN_NAME"] !==
                             dbColumn["COLUMN_NAME"]);
                 });
-                const isPrimary = !!columnConstraints.find((constraint) => constraint["CONSTRAINT_TYPE"] === "PRIMARY KEY");
+                const isPrimary = !!columnConstraints.find((constraint) => constraint["CONSTRAINT_TYPE"] ===
+                    "PRIMARY KEY");
                 const isGenerated = !!dbIdentityColumns.find((column) => column["TABLE_NAME"] ===
                     dbColumn["TABLE_NAME"] &&
                     column["TABLE_SCHEMA"] ===
@@ -1636,7 +1736,8 @@ export class SqlServerQueryRunner extends BaseQueryRunner {
                         dbColumn["COLUMN_NAME"]);
                 const tableColumn = new TableColumn();
                 tableColumn.name = dbColumn["COLUMN_NAME"];
-                tableColumn.type = dbColumn["DATA_TYPE"].toLowerCase();
+                tableColumn.type =
+                    dbColumn["DATA_TYPE"].toLowerCase();
                 // check only columns that have length property
                 if (this.driver.withLengthColumnTypes.indexOf(tableColumn.type) !== -1 &&
                     dbColumn["CHARACTER_MAXIMUM_LENGTH"]) {
@@ -1659,7 +1760,8 @@ export class SqlServerQueryRunner extends BaseQueryRunner {
                             dbColumn["NUMERIC_PRECISION"];
                     if (dbColumn["NUMERIC_SCALE"] !== null &&
                         !this.isDefaultColumnScale(table, tableColumn, dbColumn["NUMERIC_SCALE"]))
-                        tableColumn.scale = dbColumn["NUMERIC_SCALE"];
+                        tableColumn.scale =
+                            dbColumn["NUMERIC_SCALE"];
                 }
                 if (tableColumn.type === "nvarchar") {
                     // Check if this is an enum
@@ -1719,8 +1821,31 @@ export class SqlServerQueryRunner extends BaseQueryRunner {
                             ? dbColumn["DATETIME_PRECISION"]
                             : undefined;
                 }
+                if (dbColumn["is_persisted"] !== null &&
+                    dbColumn["is_persisted"] !== undefined &&
+                    dbColumn["definition"]) {
+                    tableColumn.generatedType =
+                        dbColumn["is_persisted"] === true
+                            ? "STORED"
+                            : "VIRTUAL";
+                    // We cannot relay on information_schema.columns.generation_expression, because it is formatted different.
+                    const asExpressionQuery = await this.selectTypeormMetadataSql({
+                        database: dbTable["TABLE_CATALOG"],
+                        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 = "";
+                    }
+                }
                 return tableColumn;
-            });
+            }));
             // find unique constraints of table, group them by constraint name and build TableUnique.
             const tableUniqueConstraints = OrmUtils.uniq(dbConstraints.filter((dbConstraint) => dbConstraint["TABLE_NAME"] ===
                 dbTable["TABLE_NAME"] &&
@@ -2097,8 +2222,19 @@ export class SqlServerQueryRunner extends BaseQueryRunner {
         }
         if (column.collation)
             c += " COLLATE " + column.collation;
-        if (column.isNullable !== true)
-            c += " NOT NULL";
+        if (column.asExpression) {
+            c += ` AS (${column.asExpression})`;
+            if (column.generatedType === "STORED") {
+                c += ` PERSISTED`;
+                // NOT NULL can be specified for computed columns only if PERSISTED is also specified
+                if (column.isNullable !== true)
+                    c += " NOT NULL";
+            }
+        }
+        else {
+            if (column.isNullable !== true)
+                c += " NOT NULL";
+        }
         if (column.isGenerated === true &&
             column.generationStrategy === "increment" &&
             !skipIdentity)