typeorm 0.3.12-dev.ae91c05 → 0.3.12-dev.defb409

package/browser/driver/cockroachdb/CockroachQueryRunner.js

@@ -17,6 +17,7 @@ import { TableExclusion } from "../../schema-builder/table/TableExclusion";
 import { TypeORMError } from "../../error";
 import { MetadataTableType } from "../types/MetadataTableType";
 import { InstanceChecker } from "../../util/InstanceChecker";
+import { VersionUtils } from "../../util/VersionUtils.js";
 /**
  * Runs queries on a single postgres database connection.
  */
@@ -79,6 +80,9 @@ export class CockroachQueryRunner extends BaseQueryRunner {
      * You cannot use query runner methods once its released.
      */
     release() {
+        if (this.isReleased) {
+            return Promise.resolve();
+        }
         this.isReleased = true;
         if (this.releaseCallback)
             this.releaseCallback();
@@ -356,6 +360,20 @@ export class CockroachQueryRunner extends BaseQueryRunner {
         }
         const upQueries = [];
         const downQueries = [];
+        // if table have column with ENUM type, we must create this type in postgres.
+        const enumColumns = table.columns.filter((column) => column.type === "enum" || column.type === "simple-enum");
+        const createdEnumTypes = [];
+        for (const column of enumColumns) {
+            // TODO: Should also check if values of existing type matches expected ones
+            const hasEnum = await this.hasEnumType(table, column);
+            const enumName = this.buildEnumName(table, column);
+            // if enum with the same "enumName" is defined more then once, me must prevent double creation
+            if (!hasEnum && createdEnumTypes.indexOf(enumName) === -1) {
+                createdEnumTypes.push(enumName);
+                upQueries.push(this.createEnumTypeSql(table, column, enumName));
+                downQueries.push(this.dropEnumTypeSql(table, column, enumName));
+            }
+        }
         table.columns
             .filter((column) => column.isGenerated &&
             column.generationStrategy === "increment")
@@ -569,6 +587,16 @@ export class CockroachQueryRunner extends BaseQueryRunner {
             // replace constraint name
             foreignKey.name = newForeignKeyName;
         });
+        // rename ENUM types
+        const enumColumns = newTable.columns.filter((column) => column.type === "enum" || column.type === "simple-enum");
+        for (let column of enumColumns) {
+            // skip renaming for user-defined enum name
+            if (column.enumName)
+                continue;
+            const oldEnumType = await this.getUserDefinedTypeName(oldTable, column);
+            upQueries.push(new Query(`ALTER TYPE "${oldEnumType.schema}"."${oldEnumType.name}" RENAME TO ${this.buildEnumName(newTable, column, false)}`));
+            downQueries.push(new Query(`ALTER TYPE ${this.buildEnumName(newTable, column)} RENAME TO "${oldEnumType.name}"`));
+        }
         await this.executeQueries(upQueries, downQueries);
     }
     /**
@@ -584,6 +612,13 @@ export class CockroachQueryRunner extends BaseQueryRunner {
         if (column.generationStrategy === "increment") {
             throw new TypeORMError(`Adding sequential generated columns into existing table is not supported`);
         }
+        if (column.type === "enum" || column.type === "simple-enum") {
+            const hasEnum = await this.hasEnumType(table, column);
+            if (!hasEnum) {
+                upQueries.push(this.createEnumTypeSql(table, column));
+                downQueries.push(this.dropEnumTypeSql(table, column));
+            }
+        }
         upQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} ADD ${this.buildCreateColumnSql(table, column)}`));
         downQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} DROP COLUMN "${column.name}"`));
         // create or update primary key constraint
@@ -711,6 +746,7 @@ export class CockroachQueryRunner extends BaseQueryRunner {
         let clonedTable = table.clone();
         const upQueries = [];
         const downQueries = [];
+        let defaultValueChanged = false;
         const oldColumn = InstanceChecker.isTableColumn(oldTableColumnOrName)
             ? oldTableColumnOrName
             : table.columns.find((column) => column.name === oldTableColumnOrName);
@@ -718,6 +754,7 @@ export class CockroachQueryRunner extends BaseQueryRunner {
             throw new TypeORMError(`Column "${oldTableColumnOrName}" was not found in the "${table.name}" table.`);
         if (oldColumn.type !== newColumn.type ||
             oldColumn.length !== newColumn.length ||
+            newColumn.isArray !== oldColumn.isArray ||
             oldColumn.generatedType !== newColumn.generatedType ||
             oldColumn.asExpression !== newColumn.asExpression) {
             // To avoid data conversion, we just recreate column
@@ -731,6 +768,13 @@ export class CockroachQueryRunner extends BaseQueryRunner {
                 // rename column
                 upQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} RENAME COLUMN "${oldColumn.name}" TO "${newColumn.name}"`));
                 downQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} RENAME COLUMN "${newColumn.name}" TO "${oldColumn.name}"`));
+                // rename ENUM type
+                if (oldColumn.type === "enum" ||
+                    oldColumn.type === "simple-enum") {
+                    const oldEnumType = await this.getUserDefinedTypeName(table, oldColumn);
+                    upQueries.push(new Query(`ALTER TYPE "${oldEnumType.schema}"."${oldEnumType.name}" RENAME TO ${this.buildEnumName(table, newColumn, false)}`));
+                    downQueries.push(new Query(`ALTER TYPE ${this.buildEnumName(table, newColumn)} RENAME TO "${oldEnumType.name}"`));
+                }
                 // rename column primary key constraint
                 if (oldColumn.isPrimary === true &&
                     !oldColumn.primaryKeyConstraintName) {
@@ -898,6 +942,57 @@ export class CockroachQueryRunner extends BaseQueryRunner {
                     downQueries.push(this.createUniqueConstraintSql(table, uniqueConstraint));
                 }
             }
+            if ((newColumn.type === "enum" ||
+                newColumn.type === "simple-enum") &&
+                (oldColumn.type === "enum" ||
+                    oldColumn.type === "simple-enum") &&
+                (!OrmUtils.isArraysEqual(newColumn.enum, oldColumn.enum) ||
+                    newColumn.enumName !== oldColumn.enumName)) {
+                const arraySuffix = newColumn.isArray ? "[]" : "";
+                // "public"."new_enum"
+                const newEnumName = this.buildEnumName(table, newColumn);
+                // "public"."old_enum"
+                const oldEnumName = this.buildEnumName(table, oldColumn);
+                // "old_enum"
+                const oldEnumNameWithoutSchema = this.buildEnumName(table, oldColumn, false);
+                //"public"."old_enum_old"
+                const oldEnumNameWithSchema_old = this.buildEnumName(table, oldColumn, true, false, true);
+                //"old_enum_old"
+                const oldEnumNameWithoutSchema_old = this.buildEnumName(table, oldColumn, false, false, true);
+                // rename old ENUM
+                upQueries.push(new Query(`ALTER TYPE ${oldEnumName} RENAME TO ${oldEnumNameWithoutSchema_old}`));
+                downQueries.push(new Query(`ALTER TYPE ${oldEnumNameWithSchema_old} RENAME TO ${oldEnumNameWithoutSchema}`));
+                // create new ENUM
+                upQueries.push(this.createEnumTypeSql(table, newColumn, newEnumName));
+                downQueries.push(this.dropEnumTypeSql(table, newColumn, newEnumName));
+                // if column have default value, we must drop it to avoid issues with type casting
+                if (oldColumn.default !== null &&
+                    oldColumn.default !== undefined) {
+                    // mark default as changed to prevent double update
+                    defaultValueChanged = true;
+                    upQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} ALTER COLUMN "${oldColumn.name}" DROP DEFAULT`));
+                    downQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} ALTER COLUMN "${oldColumn.name}" SET DEFAULT ${oldColumn.default}`));
+                }
+                // build column types
+                const upType = `${newEnumName}${arraySuffix} USING "${newColumn.name}"::"text"::${newEnumName}${arraySuffix}`;
+                const downType = `${oldEnumNameWithSchema_old}${arraySuffix} USING "${newColumn.name}"::"text"::${oldEnumNameWithSchema_old}${arraySuffix}`;
+                upQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} ALTER COLUMN "${newColumn.name}" TYPE ${upType}`));
+                // we add a delay here since for some reason cockroachdb fails with
+                // "cannot drop type because other objects still depend on it" error
+                // if we are trying to drop type right after we altered it.
+                upQueries.push(new Query(`SELECT pg_sleep(0.1)`));
+                downQueries.push(new Query(`SELECT pg_sleep(0.1)`));
+                downQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} ALTER COLUMN "${newColumn.name}" TYPE ${downType}`));
+                // restore column default or create new one
+                if (newColumn.default !== null &&
+                    newColumn.default !== undefined) {
+                    upQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} ALTER COLUMN "${newColumn.name}" SET DEFAULT ${newColumn.default}`));
+                    downQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} ALTER COLUMN "${newColumn.name}" DROP DEFAULT`));
+                }
+                // remove old ENUM
+                upQueries.push(this.dropEnumTypeSql(table, oldColumn, oldEnumNameWithSchema_old));
+                downQueries.push(this.createEnumTypeSql(table, oldColumn, oldEnumNameWithSchema_old));
+            }
             if (oldColumn.isGenerated !== newColumn.isGenerated &&
                 newColumn.generationStrategy !== "uuid") {
                 if (newColumn.isGenerated) {
@@ -914,7 +1009,8 @@ export class CockroachQueryRunner extends BaseQueryRunner {
                     downQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} ALTER COLUMN "${newColumn.name}" SET DEFAULT unique_rowid()`));
                 }
             }
-            if (newColumn.default !== oldColumn.default) {
+            if (newColumn.default !== oldColumn.default &&
+                !defaultValueChanged) {
                 if (newColumn.default !== null &&
                     newColumn.default !== undefined) {
                     upQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} ALTER COLUMN "${newColumn.name}" SET DEFAULT ${newColumn.default}`));
@@ -933,6 +1029,12 @@ export class CockroachQueryRunner extends BaseQueryRunner {
                 }
             }
         }
+        if ((newColumn.spatialFeatureType || "").toLowerCase() !==
+            (oldColumn.spatialFeatureType || "").toLowerCase() ||
+            newColumn.srid !== oldColumn.srid) {
+            upQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} ALTER COLUMN "${newColumn.name}" TYPE ${this.driver.createFullType(newColumn)}`));
+            downQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} ALTER COLUMN "${newColumn.name}" TYPE ${this.driver.createFullType(oldColumn)}`));
+        }
         await this.executeQueries(upQueries, downQueries);
         this.replaceCachedTable(table, clonedTable);
     }
@@ -1039,6 +1141,16 @@ export class CockroachQueryRunner extends BaseQueryRunner {
             upQueries.push(deleteQuery);
             downQueries.push(insertQuery);
         }
+        // drop enum type
+        if (column.type === "enum" || column.type === "simple-enum") {
+            const hasEnum = await this.hasEnumType(table, column);
+            if (hasEnum) {
+                const enumType = await this.getUserDefinedTypeName(table, column);
+                const escapedEnumName = `"${enumType.schema}"."${enumType.name}"`;
+                upQueries.push(this.dropEnumTypeSql(table, column, escapedEnumName));
+                downQueries.push(this.createEnumTypeSql(table, column, escapedEnumName));
+            }
+        }
         await this.executeQueries(upQueries, downQueries);
         clonedTable.removeColumn(column);
         this.replaceCachedTable(table, clonedTable);
@@ -1388,6 +1500,7 @@ export class CockroachQueryRunner extends BaseQueryRunner {
         if (!isAnotherTransactionActive)
             await this.startTransaction();
         try {
+            const version = await this.getVersion();
             const selectViewDropsQuery = `SELECT 'DROP VIEW IF EXISTS "' || schemaname || '"."' || viewname || '" CASCADE;' as "query" ` +
                 `FROM "pg_views" WHERE "schemaname" IN (${schemaNamesString})`;
             const dropViewQueries = await this.query(selectViewDropsQuery);
@@ -1398,6 +1511,10 @@ export class CockroachQueryRunner extends BaseQueryRunner {
             const selectSequenceDropsQuery = `SELECT 'DROP SEQUENCE "' || sequence_schema || '"."' || sequence_name || '";' as "query" FROM "information_schema"."sequences" WHERE "sequence_schema" IN (${schemaNamesString})`;
             const sequenceDropQueries = await this.query(selectSequenceDropsQuery);
             await Promise.all(sequenceDropQueries.map((q) => this.query(q["query"])));
+            // drop enum types. Supported starting from v20.2.19.
+            if (VersionUtils.isGreaterOrEqual(version, "20.2.19")) {
+                await this.dropEnumTypes(schemaNamesString);
+            }
             if (!isAnotherTransactionActive)
                 await this.commitTransaction();
         }
@@ -1532,11 +1649,21 @@ export class CockroachQueryRunner extends BaseQueryRunner {
             `INNER JOIN "pg_class" "cl" ON "cl"."oid" = "con"."confrelid" ` +
             `INNER JOIN "pg_namespace" "ns" ON "cl"."relnamespace" = "ns"."oid" ` +
             `INNER JOIN "pg_attribute" "att2" ON "att2"."attrelid" = "con"."conrelid" AND "att2"."attnum" = "con"."parent"`;
-        const [dbColumns, dbConstraints, dbIndices, dbForeignKeys,] = await Promise.all([
+        const tableSchemas = dbTables
+            .map((dbTable) => `'${dbTable.table_schema}'`)
+            .join(", ");
+        const enumsSql = `SELECT "t"."typname" AS "name", string_agg("e"."enumlabel", '|') AS "value" ` +
+            `FROM "pg_enum" "e" ` +
+            `INNER JOIN "pg_type" "t" ON "t"."oid" = "e"."enumtypid" ` +
+            `INNER JOIN "pg_namespace" "n" ON "n"."oid" = "t"."typnamespace" ` +
+            `WHERE "n"."nspname" IN (${tableSchemas}) ` +
+            `GROUP BY "t"."typname"`;
+        const [dbColumns, dbConstraints, dbIndices, dbForeignKeys, dbEnums,] = await Promise.all([
             this.query(columnsSql),
             this.query(constraintsSql),
             this.query(indicesSql),
             this.query(foreignKeysSql),
+            this.query(enumsSql),
         ]);
         // create tables for loaded tables
         return Promise.all(dbTables.map(async (dbTable) => {
@@ -1600,15 +1727,39 @@ export class CockroachQueryRunner extends BaseQueryRunner {
                         tableColumn.scale = undefined;
                     }
                 }
+                // docs: https://www.postgresql.org/docs/current/xtypes.html
+                // When you define a new base type, PostgreSQL automatically provides support for arrays of that type.
+                // The array type typically has the same name as the base type with the underscore character (_) prepended.
+                // ----
+                // so, we must remove this underscore character from enum type name
+                let udtName = dbColumn["udt_name"];
+                if (udtName.indexOf("_") === 0) {
+                    udtName = udtName.substr(1, udtName.length);
+                }
+                const enumType = dbEnums.find((dbEnum) => {
+                    return dbEnum["name"] === udtName;
+                });
+                if (enumType) {
+                    // check if `enumName` is specified by user
+                    const builtEnumName = this.buildEnumName(table, tableColumn, false, true);
+                    const enumName = builtEnumName !== enumType["name"]
+                        ? enumType["name"]
+                        : undefined;
+                    tableColumn.type = "enum";
+                    tableColumn.enum = enumType["value"].split("|");
+                    tableColumn.enumName = enumName;
+                }
                 if (dbColumn["data_type"].toLowerCase() === "array") {
                     tableColumn.isArray = true;
-                    const type = dbColumn["crdb_sql_type"]
-                        .replace("[]", "")
-                        .toLowerCase();
-                    tableColumn.type =
-                        this.connection.driver.normalizeType({
-                            type: type,
-                        });
+                    if (!enumType) {
+                        const type = dbColumn["crdb_sql_type"]
+                            .replace("[]", "")
+                            .toLowerCase();
+                        tableColumn.type =
+                            this.connection.driver.normalizeType({
+                                type: type,
+                            });
+                    }
                 }
                 // check only columns that have length property
                 if (this.driver.withLengthColumnTypes.indexOf(tableColumn.type) !== -1 &&
@@ -1677,6 +1828,10 @@ export class CockroachQueryRunner extends BaseQueryRunner {
                         tableColumn.default = dbColumn["column_default"].replace(/:::[\w\s\[\]\"]+/g, "");
                         tableColumn.default =
                             tableColumn.default.replace(/^(-?[\d\.]+)$/, "($1)");
+                        if (enumType) {
+                            tableColumn.default =
+                                tableColumn.default.replace(`.${enumType["name"]}`, "");
+                        }
                     }
                 }
                 if (dbColumn["is_generated"] === "YES" &&
@@ -1707,6 +1862,25 @@ export class CockroachQueryRunner extends BaseQueryRunner {
                 if (dbColumn["character_set_name"])
                     tableColumn.charset =
                         dbColumn["character_set_name"];
+                if (tableColumn.type === "geometry" ||
+                    tableColumn.type === "geography") {
+                    const sql = `SELECT * FROM (` +
+                        `SELECT "f_table_schema" "table_schema", "f_table_name" "table_name", ` +
+                        `"f_${tableColumn.type}_column" "column_name", "srid", "type" ` +
+                        `FROM "${tableColumn.type}_columns"` +
+                        `) AS _ ` +
+                        `WHERE "column_name" = '${dbColumn["column_name"]}' AND ` +
+                        `"table_schema" = '${dbColumn["table_schema"]}' AND ` +
+                        `"table_name" = '${dbColumn["table_name"]}'`;
+                    const results = await this.query(sql);
+                    if (results.length > 0) {
+                        tableColumn.spatialFeatureType =
+                            results[0].type;
+                        tableColumn.srid = results[0].srid
+                            ? parseInt(results[0].srid)
+                            : undefined;
+                    }
+                }
                 return tableColumn;
             }));
             // find unique constraints of table, group them by constraint name and build TableUnique.
@@ -1889,6 +2063,13 @@ export class CockroachQueryRunner extends BaseQueryRunner {
             .forEach((it) => (sql += `; COMMENT ON COLUMN ${this.escapePath(table)}."${it.name}" IS ${this.escapeComment(it.comment)}`));
         return new Query(sql);
     }
+    /**
+     * Loads Cockroachdb version.
+     */
+    async getVersion() {
+        const result = await this.query(`SELECT version()`);
+        return result[0]["version"].replace(/^CockroachDB CCL v([\d\.]+) .*$/, "$1");
+    }
     /**
      * Builds drop table sql.
      */
@@ -1942,6 +2123,51 @@ export class CockroachQueryRunner extends BaseQueryRunner {
             name,
         });
     }
+    /**
+     * Drops ENUM type from given schemas.
+     */
+    async dropEnumTypes(schemaNames) {
+        const selectDropsQuery = `SELECT 'DROP TYPE IF EXISTS "' || n.nspname || '"."' || t.typname || '";' as "query" FROM "pg_type" "t" ` +
+            `INNER JOIN "pg_enum" "e" ON "e"."enumtypid" = "t"."oid" ` +
+            `INNER JOIN "pg_namespace" "n" ON "n"."oid" = "t"."typnamespace" ` +
+            `WHERE "n"."nspname" IN (${schemaNames}) GROUP BY "n"."nspname", "t"."typname"`;
+        const dropQueries = await this.query(selectDropsQuery);
+        await Promise.all(dropQueries.map((q) => this.query(q["query"])));
+    }
+    /**
+     * Checks if enum with the given name exist in the database.
+     */
+    async hasEnumType(table, column) {
+        let { schema } = this.driver.parseTableName(table);
+        if (!schema) {
+            schema = await this.getCurrentSchema();
+        }
+        const enumName = this.buildEnumName(table, column, false, true);
+        const sql = `SELECT "n"."nspname", "t"."typname" FROM "pg_type" "t" ` +
+            `INNER JOIN "pg_namespace" "n" ON "n"."oid" = "t"."typnamespace" ` +
+            `WHERE "n"."nspname" = '${schema}' AND "t"."typname" = '${enumName}'`;
+        const result = await this.query(sql);
+        return result.length ? true : false;
+    }
+    /**
+     * Builds create ENUM type sql.
+     */
+    createEnumTypeSql(table, column, enumName) {
+        if (!enumName)
+            enumName = this.buildEnumName(table, column);
+        const enumValues = column
+            .enum.map((value) => `'${value.replace("'", "''")}'`)
+            .join(", ");
+        return new Query(`CREATE TYPE ${enumName} AS ENUM(${enumValues})`);
+    }
+    /**
+     * Builds create ENUM type sql.
+     */
+    dropEnumTypeSql(table, column, enumName) {
+        if (!enumName)
+            enumName = this.buildEnumName(table, column);
+        return new Query(`DROP TYPE ${enumName}`);
+    }
     /**
      * Builds create index sql.
      * UNIQUE indices creates as UNIQUE constraints.
@@ -1950,7 +2176,7 @@ export class CockroachQueryRunner extends BaseQueryRunner {
         const columns = index.columnNames
             .map((columnName) => `"${columnName}"`)
             .join(", ");
-        return new Query(`CREATE INDEX "${index.name}" ON ${this.escapePath(table)} (${columns}) ${index.where ? "WHERE " + index.where : ""}`);
+        return new Query(`CREATE ${index.isUnique ? "UNIQUE " : ""}INDEX "${index.name}" ON ${this.escapePath(table)} ${index.isSpatial ? "USING GiST " : ""}(${columns}) ${index.where ? "WHERE " + index.where : ""}`);
     }
     /**
      * Builds drop index sql.
@@ -2063,6 +2289,46 @@ export class CockroachQueryRunner extends BaseQueryRunner {
             ? `${schema}.${this.buildSequenceName(table, columnOrName)}`
             : this.buildSequenceName(table, columnOrName);
     }
+    /**
+     * Builds ENUM type name from given table and column.
+     */
+    buildEnumName(table, column, withSchema = true, disableEscape, toOld) {
+        const { schema, tableName } = this.driver.parseTableName(table);
+        let enumName = column.enumName
+            ? column.enumName
+            : `${tableName}_${column.name.toLowerCase()}_enum`;
+        if (schema && withSchema)
+            enumName = `${schema}.${enumName}`;
+        if (toOld)
+            enumName = enumName + "_old";
+        return enumName
+            .split(".")
+            .map((i) => {
+            return disableEscape ? i : `"${i}"`;
+        })
+            .join(".");
+    }
+    async getUserDefinedTypeName(table, column) {
+        let { schema, tableName: name } = this.driver.parseTableName(table);
+        if (!schema) {
+            schema = await this.getCurrentSchema();
+        }
+        const result = await this.query(`SELECT "udt_schema", "udt_name" ` +
+            `FROM "information_schema"."columns" WHERE "table_schema" = '${schema}' AND "table_name" = '${name}' AND "column_name"='${column.name}'`);
+        // docs: https://www.postgresql.org/docs/current/xtypes.html
+        // When you define a new base type, PostgreSQL automatically provides support for arrays of that type.
+        // The array type typically has the same name as the base type with the underscore character (_) prepended.
+        // ----
+        // so, we must remove this underscore character from enum type name
+        let udtName = result[0]["udt_name"];
+        if (udtName.indexOf("_") === 0) {
+            udtName = udtName.substr(1, udtName.length);
+        }
+        return {
+            schema: result[0]["udt_schema"],
+            name: udtName,
+        };
+    }
     /**
      * Escapes a given comment so it's safe to include in a query.
      */
@@ -2099,8 +2365,14 @@ export class CockroachQueryRunner extends BaseQueryRunner {
                 c += " UUID DEFAULT gen_random_uuid()";
             }
         }
-        if (!column.isGenerated)
+        if (column.type === "enum" || column.type === "simple-enum") {
+            c += " " + this.buildEnumName(table, column);
+            if (column.isArray)
+                c += " array";
+        }
+        else if (!column.isGenerated) {
             c += " " + this.connection.driver.createFullType(column);
+        }
         if (column.asExpression) {
             c += ` AS (${column.asExpression}) ${column.generatedType ? column.generatedType : "VIRTUAL"}`;
         }