@mikro-orm/knex 6.2.10-dev.5 → 6.2.10-dev.50

package/AbstractSqlDriver.js

@@ -1099,9 +1099,12 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 if (!prop) {
                     throw new Error(`Trying to order by not existing property ${meta.className}.${propName}`);
                 }
+                let path = parentPath;
                 const meta2 = this.metadata.find(prop.type);
                 const childOrder = orderHint[prop.name];
-                let path = `${parentPath}.${propName}`;
+                if (![core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) || !prop.owner || core_1.Utils.isPlainObject(childOrder)) {
+                    path += `.${propName}`;
+                }
                 if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY && typeof childOrder !== 'object') {
                     path += '[pivot]';
                 }

package/dialects/mysql/MySqlSchemaHelper.js

@@ -78,7 +78,7 @@ class MySqlSchemaHelper extends SchemaHelper_1.SchemaHelper {
       nullif(table_schema, schema()) as schema_name,
       column_name as column_name,
       column_default as column_default,
-      column_comment as column_comment,
+      nullif(column_comment, '') as column_comment,
       is_nullable as is_nullable,
       data_type as data_type,
       column_type as column_type,

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.5",
+  "version": "6.2.10-dev.50",
   "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.5",
+    "@mikro-orm/core": "6.2.10-dev.50",
     "better-sqlite3": "*",
     "libsql": "*",
     "mariadb": "*"

package/query/ObjectCriteriaNode.js

@@ -70,7 +70,8 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
             const primaryKey = this.key && this.metadata.find(this.entityName).primaryKeys.includes(field);
             if (childNode.shouldInline(payload)) {
                 const childAlias = qb.getAliasForJoinPath(childNode.getPath(), options);
-                this.inlineChildPayload(o, payload, field, alias, childAlias);
+                const a = qb.helper.isTableNameAliasRequired(qb.type) ? alias : undefined;
+                this.inlineChildPayload(o, payload, field, a, childAlias);
             }
             else if (childNode.shouldRename(payload)) {
                 o[childNode.renameFieldToPK(qb)] = payload;
@@ -149,7 +150,6 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
                 o[k] = payload[k];
             }
             else {
-                o[`${childAlias}.${k}`] = payload[k];
                 o[this.aliased(k, childAlias)] = payload[k];
             }
         }

package/query/QueryBuilder.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { inspect } from 'util';
 import type { Knex } from 'knex';
-import { type AnyEntity, type ConnectionType, type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityName, type EntityProperty, type FlushMode, type GroupOperator, type Loaded, LockMode, type LoggingOptions, type MetadataStorage, type ObjectQuery, PopulateHint, type PopulateOptions, type QBFilterQuery, type QBQueryOrderMap, QueryFlag, type QueryOrderMap, type QueryResult, type RequiredEntityData, type ExpandProperty } from '@mikro-orm/core';
+import { type AnyEntity, type ConnectionType, type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityName, type EntityProperty, type FlushMode, type GroupOperator, type Loaded, LockMode, type LoggingOptions, type MetadataStorage, type ObjectQuery, PopulateHint, type PopulateOptions, type QBFilterQuery, type QBQueryOrderMap, QueryFlag, type QueryOrderMap, type QueryResult, RawQueryFragment, type RequiredEntityData, type ExpandProperty } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
 import { type Alias, QueryBuilderHelper } from './QueryBuilderHelper';
@@ -88,7 +88,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     protected _having: Dictionary;
     protected _returning?: Field<Entity>[];
     protected _onConflict?: {
-        fields: string[];
+        fields: string[] | RawQueryFragment;
         ignore?: boolean;
         merge?: EntityData<Entity> | Field<Entity>[];
         where?: QBFilterQuery<Entity>;

package/query/QueryBuilder.js

@@ -348,11 +348,13 @@ class QueryBuilder {
         this.ensureNotFinalized();
         this._onConflict ??= [];
         this._onConflict.push({
-            fields: core_1.Utils.asArray(fields).flatMap(f => {
-                const key = f.toString();
-                /* istanbul ignore next */
-                return meta.properties[key]?.fieldNames ?? [key];
-            }),
+            fields: core_1.Utils.isRawSql(fields)
+                ? fields
+                : core_1.Utils.asArray(fields).flatMap(f => {
+                    const key = f.toString();
+                    /* istanbul ignore next */
+                    return meta.properties[key]?.fieldNames ?? [key];
+                }),
         });
         return this;
     }
@@ -1222,7 +1224,7 @@ class QueryBuilder {
                     const prop = this.helper.getProperty(f, a);
                     const type = this.platform.castColumn(prop);
                     const fieldName = this.helper.mapper(field, this.type, undefined, null);
-                    if (!prop?.persist && !prop?.formula && !pks.includes(fieldName)) {
+                    if (!prop?.persist && !prop?.formula && !prop?.hasConvertToJSValueSQL && !pks.includes(fieldName)) {
                         addToSelect.push(fieldName);
                     }
                     const key = (0, core_1.raw)(`min(${this.knex.ref(fieldName)}${type})`);
@@ -1245,8 +1247,10 @@ class QueryBuilder {
                     }
                     return false;
                 });
+                /* istanbul ignore next */
                 if (field instanceof core_1.RawQueryFragment) {
-                    knexQuery.select(this.platform.formatQuery(field.sql, field.params));
+                    const sql = this.platform.formatQuery(field.sql, field.params);
+                    knexQuery.select(this.knex.raw(sql));
                 }
                 else if (field) {
                     knexQuery.select(field);

package/query/QueryBuilderHelper.d.ts

@@ -1,5 +1,5 @@
 import type { Knex } from 'knex';
-import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityProperty, type FlatQueryOrderMap, LockMode, type QBFilterQuery } from '@mikro-orm/core';
+import { type Dictionary, type EntityData, type EntityKey, type EntityMetadata, type EntityProperty, type FlatQueryOrderMap, LockMode, type QBFilterQuery, RawQueryFragment } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums';
 import type { Field, JoinOptions } from '../typings';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
@@ -34,7 +34,7 @@ export declare class QueryBuilderHelper {
     isSimpleRegExp(re: any): re is RegExp;
     getRegExpParam(re: RegExp): string;
     appendOnConflictClause<T>(type: QueryType, onConflict: {
-        fields: string[];
+        fields: string[] | RawQueryFragment;
         ignore?: boolean;
         merge?: EntityData<T> | Field<T>[];
         where?: QBFilterQuery<T>;

package/query/QueryBuilderHelper.js

@@ -67,7 +67,8 @@ class QueryBuilderHelper {
         }
         const rawField = core_1.RawQueryFragment.getKnownFragment(field);
         if (rawField) {
-            return this.knex.raw(rawField.sql, rawField.params);
+            // sometimes knex is confusing the binding positions, we need to interpolate early
+            return this.knex.raw(this.platform.formatQuery(rawField.sql, rawField.params));
         }
         const [a, f] = this.splitField(field);
         const prop = this.getProperty(f, a);
@@ -194,7 +195,8 @@ class QueryBuilderHelper {
                 join.primaryKeys.forEach((primaryKey, idx) => {
                     const right = `${join.alias}.${join.joinColumns[idx]}`;
                     if (join.prop.formula) {
-                        const left = join.prop.formula(join.ownerAlias);
+                        const alias = this.platform.quoteIdentifier(join.ownerAlias);
+                        const left = join.prop.formula(alias);
                         conditions.push(`${left} = ${this.knex.ref(right)}`);
                         return;
                     }
@@ -352,7 +354,16 @@ class QueryBuilderHelper {
     }
     appendOnConflictClause(type, onConflict, qb) {
         onConflict.forEach(item => {
-            const sub = item.fields.length > 0 ? qb.onConflict(item.fields) : qb.onConflict();
+            let sub;
+            if (core_1.Utils.isRawSql(item.fields)) {
+                sub = qb.onConflict(this.knex.raw(item.fields.sql, item.fields.params));
+            }
+            else if (item.fields.length > 0) {
+                sub = qb.onConflict(item.fields);
+            }
+            else {
+                sub = qb.onConflict();
+            }
             core_1.Utils.runIfNotEmpty(() => sub.ignore(), item.ignore);
             core_1.Utils.runIfNotEmpty(() => {
                 let mergeParam = item.merge;

package/schema/DatabaseTable.js

@@ -171,7 +171,7 @@ class DatabaseTable {
     getEntityDeclaration(namingStrategy, schemaHelper, scalarPropertiesForRelations) {
         const { fksOnColumnProps, fksOnStandaloneProps, columnFks, fkIndexes, nullableForeignKeys, skippedColumnNames, } = this.foreignKeysToProps(namingStrategy, scalarPropertiesForRelations);
         const name = namingStrategy.getEntityName(this.name, this.schema);
-        const schema = new core_1.EntitySchema({ name, collection: this.name, schema: this.schema });
+        const schema = new core_1.EntitySchema({ name, collection: this.name, schema: this.schema, comment: this.comment });
         const compositeFkIndexes = {};
         const compositeFkUniques = {};
         const potentiallyUnmappedIndexes = this.indexes.filter(index => !index.primary // Skip primary index. Whether it's in use by scalar column or FK, it's already mapped.
@@ -505,6 +505,7 @@ class DatabaseTable {
             columnOptions.length = column.length;
             columnOptions.precision = column.precision;
             columnOptions.scale = column.scale;
+            columnOptions.comment = column.comment;
             columnOptions.enum = !!column.enumItems?.length;
             columnOptions.items = column.enumItems;
         }
@@ -558,6 +559,7 @@ class DatabaseTable {
             length: column.length,
             precision: column.precision,
             scale: column.scale,
+            comment: column.comment,
             index: index ? index.keyName : undefined,
             unique: unique ? unique.keyName : undefined,
             enum: !!column.enumItems?.length,
@@ -601,8 +603,7 @@ class DatabaseTable {
         // If this column is using an enum.
         if (column.enumItems?.length) {
             // We will create a new enum name for this type and set it as the property type as well.
-            // The enum name will be a concatenation of the table name and the column name.
-            return namingStrategy.getClassName(this.name + '_' + column.name, '_');
+            return namingStrategy.getEnumClassName(column.name, this.name, this.schema);
         }
         return column.mappedType?.runtimeType ?? 'unknown';
     }

package/schema/SchemaComparator.js

@@ -369,7 +369,10 @@ class SchemaComparator {
         }
         const defaultRule = ['restrict', 'no action'];
         const rule = (key, method) => {
-            return (key[method] ?? defaultRule[0]).toLowerCase().replace(defaultRule[1], defaultRule[0]);
+            return (key[method] ?? defaultRule[0])
+                .toLowerCase()
+                .replace(defaultRule[1], defaultRule[0])
+                .replace(/"/g, '');
         };
         const compare = (method) => rule(key1, method) === rule(key2, method);
         return !compare('updateRule') || !compare('deleteRule');

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

@@ -61,8 +61,7 @@ class SchemaHelper {
     }
     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 +272,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

@@ -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();

package/typings.d.ts

@@ -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>;