@mikro-orm/knex 6.2.10-dev.1 → 6.2.10-dev.100

package/schema/SchemaHelper.js

@@ -30,7 +30,11 @@ class SchemaHelper {
         return core_1.Utils.flatten(pks);
     }
     inferLengthFromColumnType(type) {
-        return undefined;
+        const match = type.match(/^\w+\s*(?:\(\s*(\d+)\s*\)|$)/);
+        if (!match) {
+            return;
+        }
+        return +match[1];
     }
     async getForeignKeys(connection, tableName, schemaName) {
         const fks = await connection.execute(this.getForeignKeysSQL(tableName, schemaName));
@@ -56,13 +60,12 @@ class SchemaHelper {
     getDropNativeEnumSQL(name, schema) {
         throw new Error('Not supported by given driver');
     }
-    getAlterNativeEnumSQL(name, schema, value) {
+    getAlterNativeEnumSQL(name, schema, value, items, oldItems) {
         throw new Error('Not supported by given driver');
     }
     async loadInformationSchema(schema, connection, tables, schemas) {
         for (const t of tables) {
-            const table = schema.addTable(t.table_name, t.schema_name);
-            table.comment = t.table_comment;
+            const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
             const cols = await this.getColumns(connection, table.name, table.schema);
             const indexes = await this.getIndexes(connection, table.name, table.schema);
             const checks = await this.getChecks(connection, table.name, table.schema, cols);
@@ -273,5 +276,137 @@ class SchemaHelper {
     pushTableQuery(table, expression, grouping = 'alterTable') {
         table._statements.push({ grouping, method: 'raw', args: [expression] });
     }
+    async dump(builder, append) {
+        if (typeof builder === 'string') {
+            return builder ? builder + (builder.endsWith(';') ? '' : ';') + append : '';
+        }
+        const sql = await builder.generateDdlCommands();
+        const queries = [...sql.pre, ...sql.sql, ...sql.post];
+        if (queries.length === 0) {
+            return '';
+        }
+        const dump = `${queries.map(q => typeof q === 'object' ? q.sql : q).join(';\n')};${append}`;
+        const tmp = dump.replace(/pragma table_.+/ig, '').replace(/\n\n+/g, '\n').trim();
+        return tmp ? tmp + append : '';
+    }
+    createTable(tableDef, alter) {
+        return this.createSchemaBuilder(tableDef.schema).createTable(tableDef.name, table => {
+            tableDef.getColumns().forEach(column => {
+                const col = this.createTableColumn(table, column, tableDef, undefined, alter);
+                this.configureColumn(column, col, this.knex);
+            });
+            for (const index of tableDef.getIndexes()) {
+                const createPrimary = !tableDef.getColumns().some(c => c.autoincrement && c.primary) || this.hasNonDefaultPrimaryKeyName(tableDef);
+                this.createIndex(table, index, tableDef, createPrimary);
+            }
+            for (const check of tableDef.getChecks()) {
+                this.createCheck(table, check);
+            }
+            if (tableDef.comment) {
+                const comment = this.platform.quoteValue(tableDef.comment).replace(/^'|'$/g, '');
+                table.comment(comment);
+            }
+            if (!this.supportsSchemaConstraints()) {
+                for (const fk of Object.values(tableDef.getForeignKeys())) {
+                    this.createForeignKey(table, fk);
+                }
+            }
+            this.finalizeTable(table, this.platform.getConfig().get('charset'), this.platform.getConfig().get('collate'));
+        });
+    }
+    createForeignKey(table, foreignKey, schema) {
+        if (!this.options.createForeignKeyConstraints) {
+            return;
+        }
+        const builder = table
+            .foreign(foreignKey.columnNames, foreignKey.constraintName)
+            .references(foreignKey.referencedColumnNames)
+            .inTable(this.getReferencedTableName(foreignKey.referencedTableName, schema))
+            .withKeyName(foreignKey.constraintName);
+        if (foreignKey.localTableName !== foreignKey.referencedTableName || this.platform.supportsMultipleCascadePaths()) {
+            if (foreignKey.updateRule) {
+                builder.onUpdate(foreignKey.updateRule);
+            }
+            if (foreignKey.deleteRule) {
+                builder.onDelete(foreignKey.deleteRule);
+            }
+        }
+        if (foreignKey.deferMode) {
+            builder.deferrable(foreignKey.deferMode);
+        }
+    }
+    splitTableName(name) {
+        const parts = name.split('.');
+        const tableName = parts.pop();
+        const schemaName = parts.pop();
+        return [schemaName, tableName];
+    }
+    getReferencedTableName(referencedTableName, schema) {
+        const [schemaName, tableName] = this.splitTableName(referencedTableName);
+        schema = schemaName ?? schema ?? this.platform.getConfig().get('schema');
+        /* istanbul ignore next */
+        if (schema && schemaName === '*') {
+            return `${schema}.${referencedTableName.replace(/^\*\./, '')}`;
+        }
+        if (!schemaName || schemaName === this.platform.getDefaultSchemaName()) {
+            return tableName;
+        }
+        return `${schemaName}.${tableName}`;
+    }
+    createIndex(table, index, tableDef, createPrimary = false) {
+        if (index.primary && !createPrimary) {
+            return;
+        }
+        if (index.expression) {
+            this.pushTableQuery(table, index.expression);
+        }
+        else if (index.primary) {
+            const keyName = this.hasNonDefaultPrimaryKeyName(tableDef) ? index.keyName : undefined;
+            table.primary(index.columnNames, keyName);
+        }
+        else if (index.unique) {
+            // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
+            if (index.columnNames.some(column => column.includes('.'))) {
+                const columns = this.platform.getJsonIndexDefinition(index);
+                table.index(columns.map(column => this.knex.raw(column)), index.keyName, { indexType: 'unique' });
+            }
+            else {
+                table.unique(index.columnNames, { indexName: index.keyName, deferrable: index.deferMode });
+            }
+        }
+        else if (index.type === 'fulltext') {
+            const columns = index.columnNames.map(name => ({ name, type: tableDef.getColumn(name).type }));
+            if (this.platform.supportsCreatingFullTextIndex()) {
+                this.pushTableQuery(table, this.platform.getFullTextIndexExpression(index.keyName, tableDef.schema, tableDef.name, columns));
+            }
+        }
+        else {
+            // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
+            if (index.columnNames.some(column => column.includes('.'))) {
+                const columns = this.platform.getJsonIndexDefinition(index);
+                table.index(columns.map(column => this.knex.raw(column)), index.keyName, index.type);
+            }
+            else {
+                table.index(index.columnNames, index.keyName, index.type);
+            }
+        }
+    }
+    createCheck(table, check) {
+        table.check(check.expression, {}, check.name);
+    }
+    createSchemaBuilder(schema) {
+        const builder = this.knex.schema;
+        if (schema && schema !== this.platform.getDefaultSchemaName()) {
+            builder.withSchema(schema);
+        }
+        return builder;
+    }
+    get knex() {
+        const connection = this.platform.getConfig().getDriver().getConnection();
+        return connection.getKnex();
+    }
+    get options() {
+        return this.platform.getConfig().get('schemaGenerator');
+    }
 }
 exports.SchemaHelper = SchemaHelper;

package/schema/SqlSchemaGenerator.d.ts

@@ -5,10 +5,10 @@ import type { AbstractSqlDriver } from '../AbstractSqlDriver';
 export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<AbstractSqlDriver> implements ISchemaGenerator {
     protected readonly helper: import("./SchemaHelper").SchemaHelper;
     protected readonly options: {
-        disableForeignKeys?: boolean | undefined;
-        createForeignKeyConstraints?: boolean | undefined;
-        ignoreSchema?: string[] | undefined;
-        managementDbName?: string | undefined;
+        disableForeignKeys?: boolean;
+        createForeignKeyConstraints?: boolean;
+        ignoreSchema?: string[];
+        managementDbName?: string;
     };
     protected lastEnsuredDatabase?: string;
     static register(orm: MikroORM): void;
@@ -38,14 +38,11 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
         dropTables?: boolean;
         schema?: string;
     }): Promise<string>;
-    private getReferencedTableName;
-    private createForeignKey;
     /**
      * We need to drop foreign keys first for all tables to allow dropping PK constraints.
      */
     private preAlterTable;
     private postAlterTable;
-    private splitTableName;
     private alterTable;
     /**
      * creates new database and connects to it
@@ -57,11 +54,7 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
         ctx?: Transaction;
     }): Promise<void>;
     private wrapSchema;
-    private createSchemaBuilder;
-    private createTable;
-    private createIndex;
     private dropIndex;
-    private createCheck;
     private dropCheck;
     private dropTable;
     private createForeignKeys;

package/schema/SqlSchemaGenerator.js

@@ -59,7 +59,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 continue;
             }
             const sql = this.helper.getCreateNamespaceSQL(namespace);
-            ret += await this.dump(this.knex.schema.raw(sql), '\n');
+            ret += await this.dump(sql, '\n');
         }
         if (this.platform.supportsNativeEnums()) {
             const created = [];
@@ -70,14 +70,14 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 }
                 created.push(enumName);
                 const sql = this.helper.getCreateNativeEnumSQL(enumOptions.name, enumOptions.items, this.getSchemaName(enumOptions, options));
-                ret += await this.dump(this.knex.schema.raw(sql), '\n');
+                ret += await this.dump(sql, '\n');
             }
         }
         for (const tableDef of toSchema.getTables()) {
-            ret += await this.dump(this.createTable(tableDef));
+            ret += await this.dump(this.helper.createTable(tableDef));
         }
         for (const tableDef of toSchema.getTables()) {
-            ret += await this.dump(this.createSchemaBuilder(tableDef.schema).alterTable(tableDef.name, table => this.createForeignKeys(table, tableDef, options.schema)));
+            ret += await this.dump(this.helper.createSchemaBuilder(tableDef.schema).alterTable(tableDef.name, table => this.createForeignKeys(table, tableDef, options.schema)));
         }
         return this.wrapSchema(ret, { wrap });
     }
@@ -124,7 +124,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
             const table = schema.getTable(meta.tableName);
             if (!this.platform.usesCascadeStatement() && table && (!wrap || options.dropForeignKeys)) {
                 for (const fk of Object.values(table.getForeignKeys())) {
-                    const builder = this.createSchemaBuilder(table.schema).alterTable(table.name, tbl => {
+                    const builder = this.helper.createSchemaBuilder(table.schema).alterTable(table.name, tbl => {
                         tbl.dropForeign(fk.columnNames, fk.constraintName);
                     });
                     ret += await this.dump(builder, '\n');
@@ -137,7 +137,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         if (this.platform.supportsNativeEnums()) {
             for (const columnName of Object.keys(schema.getNativeEnums())) {
                 const sql = this.helper.getDropNativeEnumSQL(columnName, options.schema ?? this.config.get('schema'));
-                ret += await this.dump(this.knex.schema.raw(sql), '\n');
+                ret += await this.dump(sql, '\n');
             }
         }
         if (options.dropMigrationsTable) {
@@ -191,28 +191,28 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         if (this.platform.supportsSchemas()) {
             for (const newNamespace of schemaDiff.newNamespaces) {
                 const sql = this.helper.getCreateNamespaceSQL(newNamespace);
-                ret += await this.dump(this.knex.schema.raw(sql), '\n');
+                ret += await this.dump(sql, '\n');
             }
         }
         if (this.platform.supportsNativeEnums()) {
             for (const newNativeEnum of schemaDiff.newNativeEnums) {
                 const sql = this.helper.getCreateNativeEnumSQL(newNativeEnum.name, newNativeEnum.items, this.getSchemaName(newNativeEnum, options));
-                ret += await this.dump(this.knex.schema.raw(sql), '\n');
+                ret += await this.dump(sql, '\n');
             }
         }
-        if (!options.safe) {
+        if (!options.safe && this.options.createForeignKeyConstraints) {
             for (const orphanedForeignKey of schemaDiff.orphanedForeignKeys) {
-                const [schemaName, tableName] = this.splitTableName(orphanedForeignKey.localTableName);
-                ret += await this.dump(this.createSchemaBuilder(schemaName).alterTable(tableName, table => {
+                const [schemaName, tableName] = this.helper.splitTableName(orphanedForeignKey.localTableName);
+                ret += await this.dump(this.helper.createSchemaBuilder(schemaName).alterTable(tableName, table => {
                     return table.dropForeign(orphanedForeignKey.columnNames, orphanedForeignKey.constraintName);
                 }));
             }
         }
         for (const newTable of Object.values(schemaDiff.newTables)) {
-            ret += await this.dump(this.createTable(newTable, true));
+            ret += await this.dump(this.helper.createTable(newTable, true));
         }
         for (const newTable of Object.values(schemaDiff.newTables)) {
-            ret += await this.dump(this.createSchemaBuilder(newTable.schema).alterTable(newTable.name, table => {
+            ret += await this.dump(this.helper.createSchemaBuilder(newTable.schema).alterTable(newTable.name, table => {
                 this.createForeignKeys(table, newTable, options.schema);
             }));
         }
@@ -228,7 +228,11 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         }
         for (const changedTable of Object.values(schemaDiff.changedTables)) {
             for (const builder of this.alterTable(changedTable, options.safe)) {
-                ret += await this.dump(builder);
+                let diff = await this.dump(builder);
+                if (diff.includes('CREATE TABLE `_knex_temp_alter') && this.helper.getAlterTable) {
+                    diff = await this.helper.getAlterTable(changedTable, options.wrap);
+                }
+                ret += diff;
             }
         }
         for (const changedTable of Object.values(schemaDiff.changedTables)) {
@@ -239,50 +243,17 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         if (!options.safe && this.platform.supportsNativeEnums()) {
             for (const removedNativeEnum of schemaDiff.removedNativeEnums) {
                 const sql = this.helper.getDropNativeEnumSQL(removedNativeEnum.name, removedNativeEnum.schema);
-                ret += await this.dump(this.knex.schema.raw(sql), '\n');
+                ret += await this.dump(sql, '\n');
             }
         }
         if (options.dropTables && !options.safe) {
             for (const removedNamespace of schemaDiff.removedNamespaces) {
                 const sql = this.helper.getDropNamespaceSQL(removedNamespace);
-                ret += await this.dump(this.knex.schema.raw(sql), '\n');
+                ret += await this.dump(sql, '\n');
             }
         }
         return this.wrapSchema(ret, options);
     }
-    getReferencedTableName(referencedTableName, schema) {
-        const [schemaName, tableName] = this.splitTableName(referencedTableName);
-        schema = schemaName ?? schema ?? this.config.get('schema');
-        /* istanbul ignore next */
-        if (schema && schemaName === '*') {
-            return `${schema}.${referencedTableName.replace(/^\*\./, '')}`;
-        }
-        if (!schemaName || schemaName === this.platform.getDefaultSchemaName()) {
-            return tableName;
-        }
-        return `${schemaName}.${tableName}`;
-    }
-    createForeignKey(table, foreignKey, schema) {
-        if (!this.options.createForeignKeyConstraints) {
-            return;
-        }
-        const builder = table
-            .foreign(foreignKey.columnNames, foreignKey.constraintName)
-            .references(foreignKey.referencedColumnNames)
-            .inTable(this.getReferencedTableName(foreignKey.referencedTableName, schema))
-            .withKeyName(foreignKey.constraintName);
-        if (foreignKey.localTableName !== foreignKey.referencedTableName || this.platform.supportsMultipleCascadePaths()) {
-            if (foreignKey.updateRule) {
-                builder.onUpdate(foreignKey.updateRule);
-            }
-            if (foreignKey.deleteRule) {
-                builder.onDelete(foreignKey.deleteRule);
-            }
-        }
-        if (foreignKey.deferMode) {
-            builder.deferrable(foreignKey.deferMode);
-        }
-    }
     /**
      * We need to drop foreign keys first for all tables to allow dropping PK constraints.
      */
@@ -290,8 +261,8 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         const ret = [];
         const push = (sql) => sql ? ret.push(this.knex.schema.raw(sql)) : undefined;
         push(this.helper.getPreAlterTable(diff, safe));
-        const [schemaName, tableName] = this.splitTableName(diff.name);
-        ret.push(this.createSchemaBuilder(schemaName).alterTable(tableName, table => {
+        const [schemaName, tableName] = this.helper.splitTableName(diff.name);
+        ret.push(this.helper.createSchemaBuilder(schemaName).alterTable(tableName, table => {
             for (const foreignKey of Object.values(diff.removedForeignKeys)) {
                 table.dropForeign(foreignKey.columnNames, foreignKey.constraintName);
             }
@@ -307,15 +278,9 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         push(this.helper.getPostAlterTable(diff, safe));
         return ret;
     }
-    splitTableName(name) {
-        const parts = name.split('.');
-        const tableName = parts.pop();
-        const schemaName = parts.pop();
-        return [schemaName, tableName];
-    }
     alterTable(diff, safe) {
         const ret = [];
-        const [schemaName, tableName] = this.splitTableName(diff.name);
+        const [schemaName, tableName] = this.helper.splitTableName(diff.name);
         if (this.platform.supportsNativeEnums()) {
             const changedNativeEnums = [];
             for (const { column, changedProperties } of Object.values(diff.changedColumns)) {
@@ -331,10 +296,10 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 // postgres allows only adding new items, the values are case insensitive
                 itemsOld = itemsOld.map(v => v.toLowerCase());
                 const newItems = itemsNew.filter(val => !itemsOld.includes(val.toLowerCase()));
-                ret.push(...newItems.map(val => this.knex.schema.raw(this.helper.getAlterNativeEnumSQL(enumName, schemaName, val))));
+                ret.push(...newItems.map(val => this.knex.schema.raw(this.helper.getAlterNativeEnumSQL(enumName, schemaName, val, itemsNew, itemsOld))));
             });
         }
-        ret.push(this.createSchemaBuilder(schemaName).alterTable(tableName, table => {
+        ret.push(this.helper.createSchemaBuilder(schemaName).alterTable(tableName, table => {
             for (const index of Object.values(diff.removedIndexes)) {
                 this.dropIndex(table, index);
             }
@@ -352,7 +317,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 this.helper.pushTableQuery(table, this.helper.getDropColumnsSQL(tableName, Object.values(diff.removedColumns), schemaName));
             }
         }));
-        ret.push(this.createSchemaBuilder(schemaName).alterTable(tableName, table => {
+        ret.push(this.helper.createSchemaBuilder(schemaName).alterTable(tableName, table => {
             for (const column of Object.values(diff.addedColumns)) {
                 const col = this.helper.createTableColumn(table, column, diff.fromTable, undefined, true);
                 this.helper.configureColumn(column, col, this.knex);
@@ -360,7 +325,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 if (foreignKey && this.options.createForeignKeyConstraints) {
                     delete diff.addedForeignKeys[foreignKey.constraintName];
                     const builder = col.references(foreignKey.referencedColumnNames[0])
-                        .inTable(this.getReferencedTableName(foreignKey.referencedTableName))
+                        .inTable(this.helper.getReferencedTableName(foreignKey.referencedTableName))
                         .withKeyName(foreignKey.constraintName)
                         .onUpdate(foreignKey.updateRule)
                         .onDelete(foreignKey.deleteRule);
@@ -394,31 +359,31 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 this.helper.pushTableQuery(table, this.helper.getRenameColumnSQL(tableName, oldColumnName, column, schemaName));
             }
             for (const foreignKey of Object.values(diff.addedForeignKeys)) {
-                this.createForeignKey(table, foreignKey);
+                this.helper.createForeignKey(table, foreignKey, undefined);
             }
             for (const foreignKey of Object.values(diff.changedForeignKeys)) {
-                this.createForeignKey(table, foreignKey);
+                this.helper.createForeignKey(table, foreignKey, undefined);
             }
             for (const index of Object.values(diff.addedIndexes)) {
-                this.createIndex(table, index, diff.toTable);
+                this.helper.createIndex(table, index, diff.toTable);
             }
             for (const index of Object.values(diff.changedIndexes)) {
-                this.createIndex(table, index, diff.toTable, true);
+                this.helper.createIndex(table, index, diff.toTable, true);
             }
             for (const [oldIndexName, index] of Object.entries(diff.renamedIndexes)) {
                 if (index.unique) {
                     this.dropIndex(table, index, oldIndexName);
-                    this.createIndex(table, index, diff.toTable);
+                    this.helper.createIndex(table, index, diff.toTable);
                 }
                 else {
                     this.helper.pushTableQuery(table, this.helper.getRenameIndexSQL(diff.name, index, oldIndexName));
                 }
             }
             for (const check of Object.values(diff.addedChecks)) {
-                this.createCheck(table, check);
+                this.helper.createCheck(table, check);
             }
             for (const check of Object.values(diff.changedChecks)) {
-                this.createCheck(table, check);
+                this.helper.createCheck(table, check);
             }
             if ('changedComment' in diff) {
                 const comment = diff.changedComment ? this.platform.quoteValue(diff.changedComment).replace(/^'|'$/g, '') : '';
@@ -483,76 +448,6 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         ret += this.helper.getSchemaEnd();
         return ret;
     }
-    createSchemaBuilder(schema) {
-        const builder = this.knex.schema;
-        if (schema && schema !== this.platform.getDefaultSchemaName()) {
-            builder.withSchema(schema);
-        }
-        return builder;
-    }
-    createTable(tableDef, alter) {
-        return this.createSchemaBuilder(tableDef.schema).createTable(tableDef.name, table => {
-            tableDef.getColumns().forEach(column => {
-                const col = this.helper.createTableColumn(table, column, tableDef, undefined, alter);
-                this.helper.configureColumn(column, col, this.knex);
-            });
-            for (const index of tableDef.getIndexes()) {
-                const createPrimary = !tableDef.getColumns().some(c => c.autoincrement && c.primary) || this.helper.hasNonDefaultPrimaryKeyName(tableDef);
-                this.createIndex(table, index, tableDef, createPrimary);
-            }
-            for (const check of tableDef.getChecks()) {
-                this.createCheck(table, check);
-            }
-            if (tableDef.comment) {
-                const comment = this.platform.quoteValue(tableDef.comment).replace(/^'|'$/g, '');
-                table.comment(comment);
-            }
-            if (!this.helper.supportsSchemaConstraints()) {
-                for (const fk of Object.values(tableDef.getForeignKeys())) {
-                    this.createForeignKey(table, fk);
-                }
-            }
-            this.helper.finalizeTable(table, this.config.get('charset'), this.config.get('collate'));
-        });
-    }
-    createIndex(table, index, tableDef, createPrimary = false) {
-        if (index.primary && !createPrimary) {
-            return;
-        }
-        if (index.primary) {
-            const keyName = this.helper.hasNonDefaultPrimaryKeyName(tableDef) ? index.keyName : undefined;
-            table.primary(index.columnNames, keyName);
-        }
-        else if (index.unique) {
-            // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
-            if (index.columnNames.some(column => column.includes('.'))) {
-                const columns = this.platform.getJsonIndexDefinition(index);
-                table.index(columns.map(column => this.knex.raw(column)), index.keyName, { indexType: 'unique' });
-            }
-            else {
-                table.unique(index.columnNames, { indexName: index.keyName, deferrable: index.deferMode });
-            }
-        }
-        else if (index.expression) {
-            this.helper.pushTableQuery(table, index.expression);
-        }
-        else if (index.type === 'fulltext') {
-            const columns = index.columnNames.map(name => ({ name, type: tableDef.getColumn(name).type }));
-            if (this.platform.supportsCreatingFullTextIndex()) {
-                this.helper.pushTableQuery(table, this.platform.getFullTextIndexExpression(index.keyName, tableDef.schema, tableDef.name, columns));
-            }
-        }
-        else {
-            // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
-            if (index.columnNames.some(column => column.includes('.'))) {
-                const columns = this.platform.getJsonIndexDefinition(index);
-                table.index(columns.map(column => this.knex.raw(column)), index.keyName, index.type);
-            }
-            else {
-                table.index(index.columnNames, index.keyName, index.type);
-            }
-        }
-    }
     dropIndex(table, index, oldIndexName = index.keyName) {
         if (index.primary) {
             table.dropPrimary(oldIndexName);
@@ -564,14 +459,11 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
             table.dropIndex(index.columnNames, oldIndexName);
         }
     }
-    createCheck(table, check) {
-        table.check(check.expression, {}, check.name);
-    }
     dropCheck(table, check) {
         table.dropChecks(check.name);
     }
     dropTable(name, schema) {
-        let builder = this.createSchemaBuilder(schema).dropTableIfExists(name);
+        let builder = this.helper.createSchemaBuilder(schema).dropTableIfExists(name);
         if (this.platform.usesCascadeStatement()) {
             builder = this.knex.schema.raw(builder.toQuery() + ' cascade');
         }
@@ -582,18 +474,11 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
             return;
         }
         for (const fk of Object.values(tableDef.getForeignKeys())) {
-            this.createForeignKey(table, fk, schema);
+            this.helper.createForeignKey(table, fk, schema);
         }
     }
     async dump(builder, append = '\n\n') {
-        const sql = await builder.generateDdlCommands();
-        const queries = [...sql.pre, ...sql.sql, ...sql.post];
-        if (queries.length === 0) {
-            return '';
-        }
-        const dump = `${queries.map(q => typeof q === 'object' ? q.sql : q).join(';\n')};${append}`;
-        const tmp = dump.replace(/pragma table_.+/ig, '').replace(/\n\n+/g, '\n').trim();
-        return tmp ? tmp + append : '';
+        return this.helper.dump(builder, append);
     }
     get knex() {
         return this.connection.getKnex();

package/typings.d.ts

@@ -47,7 +47,7 @@ export interface Column {
     unique?: boolean;
     /** mysql only */
     extra?: string;
-    ignoreSchemaChanges?: ('type' | 'extra')[];
+    ignoreSchemaChanges?: ('type' | 'extra' | 'default')[];
 }
 export interface ForeignKey {
     columnNames: string[];
@@ -129,6 +129,8 @@ export interface IQueryBuilder<T> {
     readonly alias: string;
     readonly type?: QueryType;
     _fields?: Field<T>[];
+    /** @internal */
+    helper: any;
     select(fields: Field<T> | Field<T>[], distinct?: boolean): this;
     addSelect(fields: string | string[]): this;
     from<T extends AnyEntity<T> = AnyEntity>(target: EntityName<T> | IQueryBuilder<T>, aliasName?: string): IQueryBuilder<T>;