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

package/browser/driver/postgres/PostgresQueryRunner.js

@@ -386,7 +386,6 @@ export class PostgresQueryRunner extends BaseQueryRunner {
                 type: MetadataTableType.GENERATED_COLUMN,
                 name: column.name,
             });
-            upQueries.push(deleteQuery);
             upQueries.push(insertQuery);
             downQueries.push(deleteQuery);
         }
@@ -434,6 +433,30 @@ export class PostgresQueryRunner 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 tableNameWithSchema = (await this.getTableNameWithSchema(table.name)).split(".");
+            const tableName = tableNameWithSchema[1];
+            const schema = tableNameWithSchema[0];
+            const deleteQuery = this.deleteTypeormMetadataSql({
+                database: this.driver.database,
+                schema,
+                table: tableName,
+                type: MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+            });
+            const insertQuery = this.insertTypeormMetadataSql({
+                database: this.driver.database,
+                schema,
+                table: tableName,
+                type: MetadataTableType.GENERATED_COLUMN,
+                name: column.name,
+                value: column.asExpression,
+            });
+            upQueries.push(deleteQuery);
+            downQueries.push(insertQuery);
+        }
         await this.executeQueries(upQueries, downQueries);
     }
     /**
@@ -478,8 +501,9 @@ export class PostgresQueryRunner extends BaseQueryRunner {
             : newTableName;
         upQueries.push(new Query(`ALTER TABLE ${this.escapePath(oldTable)} RENAME TO "${newTableName}"`));
         downQueries.push(new Query(`ALTER TABLE ${this.escapePath(newTable)} RENAME TO "${oldTableName}"`));
-        // rename column primary key constraint
-        if (newTable.primaryColumns.length > 0) {
+        // rename column primary key constraint if it has default constraint name
+        if (newTable.primaryColumns.length > 0 &&
+            !newTable.primaryColumns[0].primaryKeyConstraintName) {
             const columnNames = newTable.primaryColumns.map((column) => column.name);
             const oldPkName = this.connection.namingStrategy.primaryKeyName(oldTable, columnNames);
             const newPkName = this.connection.namingStrategy.primaryKeyName(newTable, columnNames);
@@ -501,6 +525,10 @@ export class PostgresQueryRunner extends BaseQueryRunner {
         });
         // 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;
             // build new constraint name
             const newUniqueName = this.connection.namingStrategy.uniqueConstraintName(newTable, unique.columnNames);
             // build queries
@@ -511,6 +539,10 @@ export class PostgresQueryRunner extends BaseQueryRunner {
         });
         // rename index constraints
         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;
             // build new constraint name
             const { schema } = this.driver.parseTableName(newTable);
             const newIndexName = this.connection.namingStrategy.indexName(newTable, index.columnNames, index.where);
@@ -528,6 +560,10 @@ export class PostgresQueryRunner extends BaseQueryRunner {
         });
         // 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;
             // build new constraint name
             const newForeignKeyName = this.connection.namingStrategy.foreignKeyName(newTable, foreignKey.columnNames, this.getTablePath(foreignKey), foreignKey.referencedColumnNames);
             // build queries
@@ -572,7 +608,9 @@ export class PostgresQueryRunner extends BaseQueryRunner {
             const primaryColumns = clonedTable.primaryColumns;
             // if table already have primary key, me must drop it and recreate again
             if (primaryColumns.length > 0) {
-                const pkName = this.connection.namingStrategy.primaryKeyName(clonedTable, primaryColumns.map((column) => column.name));
+                const pkName = primaryColumns[0].primaryKeyConstraintName
+                    ? primaryColumns[0].primaryKeyConstraintName
+                    : this.connection.namingStrategy.primaryKeyName(clonedTable, primaryColumns.map((column) => column.name));
                 const columnNames = primaryColumns
                     .map((column) => `"${column.name}"`)
                     .join(", ");
@@ -580,7 +618,9 @@ export class PostgresQueryRunner extends BaseQueryRunner {
                 downQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} ADD CONSTRAINT "${pkName}" PRIMARY KEY (${columnNames})`));
             }
             primaryColumns.push(column);
-            const pkName = this.connection.namingStrategy.primaryKeyName(clonedTable, primaryColumns.map((column) => column.name));
+            const pkName = primaryColumns[0].primaryKeyConstraintName
+                ? primaryColumns[0].primaryKeyConstraintName
+                : this.connection.namingStrategy.primaryKeyName(clonedTable, primaryColumns.map((column) => column.name));
             const columnNames = primaryColumns
                 .map((column) => `"${column.name}"`)
                 .join(", ");
@@ -623,7 +663,6 @@ export class PostgresQueryRunner extends BaseQueryRunner {
                 type: MetadataTableType.GENERATED_COLUMN,
                 name: column.name,
             });
-            upQueries.push(deleteQuery);
             upQueries.push(insertQuery);
             downQueries.push(deleteQuery);
         }
@@ -708,7 +747,8 @@ export class PostgresQueryRunner extends BaseQueryRunner {
                     downQueries.push(new Query(`ALTER TYPE ${this.buildEnumName(table, newColumn)} RENAME TO "${oldEnumType.name}"`));
                 }
                 // rename column primary key constraint
-                if (oldColumn.isPrimary === true) {
+                if (oldColumn.isPrimary === true &&
+                    !oldColumn.primaryKeyConstraintName) {
                     const primaryColumns = clonedTable.primaryColumns;
                     // build old primary constraint name
                     const columnNames = primaryColumns.map((column) => column.name);
@@ -735,6 +775,10 @@ export class PostgresQueryRunner extends BaseQueryRunner {
                 }
                 // rename unique constraints
                 clonedTable.findColumnUniques(oldColumn).forEach((unique) => {
+                    const oldUniqueName = this.connection.namingStrategy.uniqueConstraintName(clonedTable, unique.columnNames);
+                    // Skip renaming if Unique has user defined constraint name
+                    if (unique.name !== oldUniqueName)
+                        return;
                     // build new constraint name
                     unique.columnNames.splice(unique.columnNames.indexOf(oldColumn.name), 1);
                     unique.columnNames.push(newColumn.name);
@@ -747,6 +791,10 @@ export class PostgresQueryRunner extends BaseQueryRunner {
                 });
                 // rename index constraints
                 clonedTable.findColumnIndices(oldColumn).forEach((index) => {
+                    const oldIndexName = this.connection.namingStrategy.indexName(clonedTable, index.columnNames, index.where);
+                    // Skip renaming if Index has user defined constraint name
+                    if (index.name !== oldIndexName)
+                        return;
                     // build new constraint name
                     index.columnNames.splice(index.columnNames.indexOf(oldColumn.name), 1);
                     index.columnNames.push(newColumn.name);
@@ -768,6 +816,10 @@ export class PostgresQueryRunner 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);
@@ -853,7 +905,9 @@ export class PostgresQueryRunner extends BaseQueryRunner {
                 const primaryColumns = clonedTable.primaryColumns;
                 // if primary column state changed, we must always drop existed constraint.
                 if (primaryColumns.length > 0) {
-                    const pkName = this.connection.namingStrategy.primaryKeyName(clonedTable, primaryColumns.map((column) => column.name));
+                    const pkName = primaryColumns[0].primaryKeyConstraintName
+                        ? primaryColumns[0].primaryKeyConstraintName
+                        : this.connection.namingStrategy.primaryKeyName(clonedTable, primaryColumns.map((column) => column.name));
                     const columnNames = primaryColumns
                         .map((column) => `"${column.name}"`)
                         .join(", ");
@@ -865,7 +919,9 @@ export class PostgresQueryRunner extends BaseQueryRunner {
                     // update column in table
                     const column = clonedTable.columns.find((column) => column.name === newColumn.name);
                     column.isPrimary = true;
-                    const pkName = this.connection.namingStrategy.primaryKeyName(clonedTable, primaryColumns.map((column) => column.name));
+                    const pkName = primaryColumns[0].primaryKeyConstraintName
+                        ? primaryColumns[0].primaryKeyConstraintName
+                        : this.connection.namingStrategy.primaryKeyName(clonedTable, primaryColumns.map((column) => column.name));
                     const columnNames = primaryColumns
                         .map((column) => `"${column.name}"`)
                         .join(", ");
@@ -880,7 +936,10 @@ export class PostgresQueryRunner extends BaseQueryRunner {
                     column.isPrimary = false;
                     // if we have another primary keys, we must recreate constraint.
                     if (primaryColumns.length > 0) {
-                        const pkName = this.connection.namingStrategy.primaryKeyName(clonedTable, primaryColumns.map((column) => column.name));
+                        const pkName = primaryColumns[0]
+                            .primaryKeyConstraintName
+                            ? primaryColumns[0].primaryKeyConstraintName
+                            : this.connection.namingStrategy.primaryKeyName(clonedTable, primaryColumns.map((column) => column.name));
                         const columnNames = primaryColumns
                             .map((column) => `"${column.name}"`)
                             .join(", ");
@@ -994,15 +1053,6 @@ export class PostgresQueryRunner extends BaseQueryRunner {
                         name: oldColumn.name,
                     }));
                     // However, we can't copy it back on downgrade. It needs to regenerate.
-                    downQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} DROP COLUMN "${newColumn.name}"`));
-                    downQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} ADD ${this.buildCreateColumnSql(table, oldColumn)}`));
-                    downQueries.push(this.deleteTypeormMetadataSql({
-                        database: this.driver.database,
-                        schema,
-                        table: tableName,
-                        type: MetadataTableType.GENERATED_COLUMN,
-                        name: newColumn.name,
-                    }));
                     downQueries.push(this.insertTypeormMetadataSql({
                         database: this.driver.database,
                         schema,
@@ -1011,6 +1061,17 @@ export class PostgresQueryRunner extends BaseQueryRunner {
                         name: oldColumn.name,
                         value: oldColumn.asExpression,
                     }));
+                    downQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} ADD ${this.buildCreateColumnSql(table, oldColumn)}`));
+                    downQueries.push(new Query(`ALTER TABLE ${this.escapePath(table)} DROP COLUMN "${newColumn.name}"`));
+                    // downQueries.push(
+                    //     this.deleteTypeormMetadataSql({
+                    //         database: this.driver.database,
+                    //         schema,
+                    //         table: tableName,
+                    //         type: MetadataTableType.GENERATED_COLUMN,
+                    //         name: newColumn.name,
+                    //     }),
+                    // )
                 }
             }
         }
@@ -1042,7 +1103,9 @@ export class PostgresQueryRunner extends BaseQueryRunner {
         const downQueries = [];
         // drop primary key constraint
         if (column.isPrimary) {
-            const pkName = this.connection.namingStrategy.primaryKeyName(clonedTable, clonedTable.primaryColumns.map((column) => column.name));
+            const pkName = column.primaryKeyConstraintName
+                ? column.primaryKeyConstraintName
+                : this.connection.namingStrategy.primaryKeyName(clonedTable, clonedTable.primaryColumns.map((column) => column.name));
             const columnNames = clonedTable.primaryColumns
                 .map((primaryColumn) => `"${primaryColumn.name}"`)
                 .join(", ");
@@ -1053,7 +1116,10 @@ export class PostgresQueryRunner extends BaseQueryRunner {
             tableColumn.isPrimary = false;
             // if primary key have multiple columns, we must recreate it without dropped column
             if (clonedTable.primaryColumns.length > 0) {
-                const pkName = this.connection.namingStrategy.primaryKeyName(clonedTable, clonedTable.primaryColumns.map((column) => column.name));
+                const pkName = clonedTable.primaryColumns[0]
+                    .primaryKeyConstraintName
+                    ? clonedTable.primaryColumns[0].primaryKeyConstraintName
+                    : this.connection.namingStrategy.primaryKeyName(clonedTable, clonedTable.primaryColumns.map((column) => column.name));
                 const columnNames = clonedTable.primaryColumns
                     .map((primaryColumn) => `"${primaryColumn.name}"`)
                     .join(", ");
@@ -1102,14 +1168,14 @@ export class PostgresQueryRunner extends BaseQueryRunner {
             const tableNameWithSchema = (await this.getTableNameWithSchema(table.name)).split(".");
             const tableName = tableNameWithSchema[1];
             const schema = tableNameWithSchema[0];
-            const insertQuery = this.deleteTypeormMetadataSql({
+            const deleteQuery = this.deleteTypeormMetadataSql({
                 database: this.driver.database,
                 schema,
                 table: tableName,
                 type: MetadataTableType.GENERATED_COLUMN,
                 name: column.name,
             });
-            const deleteQuery = this.insertTypeormMetadataSql({
+            const insertQuery = this.insertTypeormMetadataSql({
                 database: this.driver.database,
                 schema,
                 table: tableName,
@@ -1117,8 +1183,8 @@ export class PostgresQueryRunner extends BaseQueryRunner {
                 name: column.name,
                 value: column.asExpression,
             });
-            upQueries.push(insertQuery);
-            downQueries.push(deleteQuery);
+            upQueries.push(deleteQuery);
+            downQueries.push(insertQuery);
         }
         await this.executeQueries(upQueries, downQueries);
         clonedTable.removeColumn(column);
@@ -1135,12 +1201,12 @@ export class PostgresQueryRunner extends BaseQueryRunner {
     /**
      * Creates a new primary key.
      */
-    async createPrimaryKey(tableOrName, columnNames) {
+    async createPrimaryKey(tableOrName, columnNames, constraintName) {
         const table = InstanceChecker.isTable(tableOrName)
             ? tableOrName
             : await this.getCachedTable(tableOrName);
         const clonedTable = table.clone();
-        const up = this.createPrimaryKeySql(table, columnNames);
+        const up = this.createPrimaryKeySql(table, columnNames, constraintName);
         // mark columns as primary, because dropPrimaryKeySql build constraint name from table primary column names.
         clonedTable.columns.forEach((column) => {
             if (columnNames.find((columnName) => columnName === column.name))
@@ -1164,7 +1230,9 @@ export class PostgresQueryRunner extends BaseQueryRunner {
         // if table already have primary columns, we must drop them.
         const primaryColumns = clonedTable.primaryColumns;
         if (primaryColumns.length > 0) {
-            const pkName = this.connection.namingStrategy.primaryKeyName(clonedTable, primaryColumns.map((column) => column.name));
+            const pkName = primaryColumns[0].primaryKeyConstraintName
+                ? primaryColumns[0].primaryKeyConstraintName
+                : this.connection.namingStrategy.primaryKeyName(clonedTable, primaryColumns.map((column) => column.name));
             const columnNamesString = primaryColumns
                 .map((column) => `"${column.name}"`)
                 .join(", ");
@@ -1175,7 +1243,9 @@ export class PostgresQueryRunner extends BaseQueryRunner {
         clonedTable.columns
             .filter((column) => columnNames.indexOf(column.name) !== -1)
             .forEach((column) => (column.isPrimary = true));
-        const pkName = this.connection.namingStrategy.primaryKeyName(clonedTable, columnNames);
+        const pkName = primaryColumns[0].primaryKeyConstraintName
+            ? primaryColumns[0].primaryKeyConstraintName
+            : this.connection.namingStrategy.primaryKeyName(clonedTable, columnNames);
         const columnNamesString = columnNames
             .map((columnName) => `"${columnName}"`)
             .join(", ");
@@ -1187,12 +1257,12 @@ export class PostgresQueryRunner extends BaseQueryRunner {
     /**
      * Drops a primary key.
      */
-    async dropPrimaryKey(tableOrName) {
+    async dropPrimaryKey(tableOrName, constraintName) {
         const table = InstanceChecker.isTable(tableOrName)
             ? tableOrName
             : await this.getCachedTable(tableOrName);
         const up = this.dropPrimaryKeySql(table);
-        const down = this.createPrimaryKeySql(table, table.primaryColumns.map((column) => column.name));
+        const down = this.createPrimaryKeySql(table, table.primaryColumns.map((column) => column.name), constraintName);
         await this.executeQueries(up, down);
         table.primaryColumns.forEach((column) => {
             column.isPrimary = false;
@@ -1814,7 +1884,30 @@ export class PostgresQueryRunner extends BaseQueryRunner {
                 }
                 tableColumn.isNullable =
                     dbColumn["is_nullable"] === "YES";
-                tableColumn.isPrimary = !!columnConstraints.find((constraint) => constraint["constraint_type"] === "PRIMARY");
+                const primaryConstraint = columnConstraints.find((constraint) => constraint["constraint_type"] === "PRIMARY");
+                if (primaryConstraint) {
+                    tableColumn.isPrimary = true;
+                    // find another columns involved in primary key constraint
+                    const anotherPrimaryConstraints = dbConstraints.filter((constraint) => constraint["table_name"] ===
+                        dbColumn["table_name"] &&
+                        constraint["table_schema"] ===
+                            dbColumn["table_schema"] &&
+                        constraint["column_name"] !==
+                            dbColumn["column_name"] &&
+                        constraint["constraint_type"] ===
+                            "PRIMARY");
+                    // collect all column names
+                    const columnNames = anotherPrimaryConstraints.map((constraint) => constraint["column_name"]);
+                    columnNames.push(dbColumn["column_name"]);
+                    // build default primary key constraint name
+                    const pkName = this.connection.namingStrategy.primaryKeyName(table, columnNames);
+                    // if primary key has user-defined constraint name, write it in table column
+                    if (primaryConstraint["constraint_name"] !==
+                        pkName) {
+                        tableColumn.primaryKeyConstraintName =
+                            primaryConstraint["constraint_name"];
+                    }
+                }
                 const uniqueConstraints = columnConstraints.filter((constraint) => constraint["constraint_type"] === "UNIQUE");
                 const isConstraintComposite = uniqueConstraints.every((uniqueConstraint) => {
                     return dbConstraints.some((dbConstraint) => dbConstraint["constraint_type"] ===
@@ -1867,13 +1960,14 @@ export class PostgresQueryRunner extends BaseQueryRunner {
                     // In postgres there is no VIRTUAL generated column type
                     tableColumn.generatedType = "STORED";
                     // We cannot relay on information_schema.columns.generation_expression, because it is formatted different.
-                    const asExpressionQuery = `SELECT * FROM "${this.connection.metadataTableName}" ` +
-                        ` WHERE "table" = '${dbTable["table_name"]}'` +
-                        ` AND "name" = '${tableColumn.name}'` +
-                        ` AND "schema" = '${dbTable["table_schema"]}'` +
-                        ` AND "database" = '${this.driver.database}'` +
-                        ` AND "type" = '${MetadataTableType.GENERATED_COLUMN}'`;
-                    const results = await this.query(asExpressionQuery);
+                    const asExpressionQuery = await this.selectTypeormMetadataSql({
+                        database: currentDatabase,
+                        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;
                     }
@@ -2077,7 +2171,9 @@ export class PostgresQueryRunner extends BaseQueryRunner {
         }
         const primaryColumns = table.columns.filter((column) => column.isPrimary);
         if (primaryColumns.length > 0) {
-            const primaryKeyName = this.connection.namingStrategy.primaryKeyName(table, primaryColumns.map((column) => column.name));
+            const primaryKeyName = primaryColumns[0].primaryKeyConstraintName
+                ? primaryColumns[0].primaryKeyConstraintName
+                : this.connection.namingStrategy.primaryKeyName(table, primaryColumns.map((column) => column.name));
             const columnNames = primaryColumns
                 .map((column) => `"${column.name}"`)
                 .join(", ");
@@ -2223,8 +2319,10 @@ export class PostgresQueryRunner extends BaseQueryRunner {
     /**
      * Builds create primary key sql.
      */
-    createPrimaryKeySql(table, columnNames) {
-        const primaryKeyName = this.connection.namingStrategy.primaryKeyName(table, columnNames);
+    createPrimaryKeySql(table, columnNames, constraintName) {
+        const primaryKeyName = constraintName
+            ? constraintName
+            : this.connection.namingStrategy.primaryKeyName(table, columnNames);
         const columnNamesString = columnNames
             .map((columnName) => `"${columnName}"`)
             .join(", ");
@@ -2234,8 +2332,13 @@ export class PostgresQueryRunner extends BaseQueryRunner {
      * Builds drop primary key sql.
      */
     dropPrimaryKeySql(table) {
+        if (!table.primaryColumns.length)
+            throw new TypeORMError(`Table ${table} has no primary keys.`);
         const columnNames = table.primaryColumns.map((column) => column.name);
-        const primaryKeyName = this.connection.namingStrategy.primaryKeyName(table, columnNames);
+        const constraintName = table.primaryColumns[0].primaryKeyConstraintName;
+        const primaryKeyName = constraintName
+            ? constraintName
+            : this.connection.namingStrategy.primaryKeyName(table, columnNames);
         return new Query(`ALTER TABLE ${this.escapePath(table)} DROP CONSTRAINT "${primaryKeyName}"`);
     }
     /**
@@ -2446,25 +2549,22 @@ export class PostgresQueryRunner extends BaseQueryRunner {
         else if (!column.isGenerated || column.type === "uuid") {
             c += " " + this.connection.driver.createFullType(column);
         }
-        // CHARACTER SET, COLLATE, NOT NULL and DEFAULT do not exist on generated (virtual) columns
-        // Also, postgres only supports the stored generated column type
+        // Postgres only supports the stored generated column type
         if (column.generatedType === "STORED" && column.asExpression) {
             c += ` GENERATED ALWAYS AS (${column.asExpression}) STORED`;
         }
-        else {
-            if (column.charset)
-                c += ' CHARACTER SET "' + column.charset + '"';
-            if (column.collation)
-                c += ' COLLATE "' + column.collation + '"';
-            if (column.isNullable !== true)
-                c += " NOT NULL";
-            if (column.default !== undefined && column.default !== null)
-                c += " DEFAULT " + column.default;
-            if (column.isGenerated &&
-                column.generationStrategy === "uuid" &&
-                !column.default)
-                c += ` DEFAULT ${this.driver.uuidGenerator}`;
-        }
+        if (column.charset)
+            c += ' CHARACTER SET "' + column.charset + '"';
+        if (column.collation)
+            c += ' COLLATE "' + column.collation + '"';
+        if (column.isNullable !== true)
+            c += " NOT NULL";
+        if (column.default !== undefined && column.default !== null)
+            c += " DEFAULT " + column.default;
+        if (column.isGenerated &&
+            column.generationStrategy === "uuid" &&
+            !column.default)
+            c += ` DEFAULT ${this.driver.uuidGenerator}`;
         return c;
     }
     /**