@mikro-orm/knex 6.2.10-dev.21 → 6.2.10-dev.23

package/dialects/sqlite/BaseSqliteSchemaHelper.d.ts

@@ -1,7 +1,7 @@
 import type { Connection, Dictionary } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../../AbstractSqlConnection';
 import { SchemaHelper } from '../../schema/SchemaHelper';
-import type { CheckDef, Column, IndexDef } from '../../typings';
+import type { CheckDef, Column, IndexDef, TableDifference } from '../../typings';
 export declare abstract class BaseSqliteSchemaHelper extends SchemaHelper {
     disableForeignKeysSQL(): string;
     enableForeignKeysSQL(): string;
@@ -24,4 +24,5 @@ export declare abstract class BaseSqliteSchemaHelper extends SchemaHelper {
      * Implicit indexes will be ignored when diffing
      */
     isImplicitIndex(name: string): boolean;
+    getAlterTable(changedTable: TableDifference, wrap?: boolean): Promise<string>;
 }

package/dialects/sqlite/BaseSqliteSchemaHelper.js

@@ -168,5 +168,22 @@ class BaseSqliteSchemaHelper extends SchemaHelper_1.SchemaHelper {
         // Ignore indexes with reserved names, e.g. autoindexes
         return name.startsWith('sqlite_');
     }
+    async getAlterTable(changedTable, wrap) {
+        wrap ??= this.options.disableForeignKeys;
+        const tempName = `${(changedTable.toTable.name)}__temp_alter`;
+        const quotedName = this.platform.quoteIdentifier(changedTable.toTable.name);
+        const quotedTempName = this.platform.quoteIdentifier(tempName);
+        const createSql = await this.dump(this.createTable(changedTable.toTable), '');
+        const [first, ...rest] = createSql.split('\n');
+        return [
+            'pragma foreign_keys = off;',
+            first.replace(`create table ${quotedName}`, `create table ${quotedTempName}`),
+            `insert into ${quotedTempName} select * from ${quotedName};`,
+            `drop table ${quotedName};`,
+            `alter table ${quotedTempName} rename to ${quotedName};`,
+            ...rest,
+            'pragma foreign_keys = on;',
+        ].join('\n');
+    }
 }
 exports.BaseSqliteSchemaHelper = BaseSqliteSchemaHelper;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.2.10-dev.21",
+  "version": "6.2.10-dev.23",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "main": "index.js",
   "module": "index.mjs",
@@ -66,7 +66,7 @@
     "@mikro-orm/core": "^6.2.9"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.2.10-dev.21",
+    "@mikro-orm/core": "6.2.10-dev.23",
     "better-sqlite3": "*",
     "libsql": "*",
     "mariadb": "*"

package/schema/SchemaHelper.d.ts

@@ -2,7 +2,7 @@ import { type Connection, type Dictionary } from '@mikro-orm/core';
 import type { Knex } from 'knex';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
-import type { CheckDef, Column, IndexDef, Table, TableDifference } from '../typings';
+import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../typings';
 import type { DatabaseSchema } from './DatabaseSchema';
 import type { DatabaseTable } from './DatabaseTable';
 export declare abstract class SchemaHelper {
@@ -58,4 +58,20 @@ export declare abstract class SchemaHelper {
      * Uses `raw` method injected in `AbstractSqlConnection` to allow adding custom queries inside alter statements.
      */
     pushTableQuery(table: Knex.TableBuilder, expression: string, grouping?: string): void;
+    dump(builder: Knex.SchemaBuilder | string, append: string): Promise<string>;
+    createTable(tableDef: DatabaseTable, alter?: boolean): Knex.SchemaBuilder;
+    createForeignKey(table: Knex.CreateTableBuilder, foreignKey: ForeignKey, schema?: string): void;
+    splitTableName(name: string): [string | undefined, string];
+    getReferencedTableName(referencedTableName: string, schema?: string): string;
+    createIndex(table: Knex.CreateTableBuilder, index: IndexDef, tableDef: DatabaseTable, createPrimary?: boolean): void;
+    createCheck(table: Knex.CreateTableBuilder, check: CheckDef): void;
+    createSchemaBuilder(schema?: string): Knex.SchemaBuilder;
+    getAlterTable?(changedTable: TableDifference, wrap?: boolean): Promise<string>;
+    get knex(): Knex;
+    get options(): {
+        disableForeignKeys?: boolean | undefined;
+        createForeignKeyConstraints?: boolean | undefined;
+        ignoreSchema?: string[] | undefined;
+        managementDbName?: string | undefined;
+    };
 }

package/schema/SchemaHelper.js

@@ -273,5 +273,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.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.expression) {
+            this.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.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

@@ -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) {
             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)) {
@@ -334,7 +299,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 ret.push(...newItems.map(val => this.knex.schema.raw(this.helper.getAlterNativeEnumSQL(enumName, schemaName, val))));
             });
         }
-        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();