@mikro-orm/knex 6.2.10-dev.9 → 6.2.10-dev.90

package/AbstractSqlDriver.js

@@ -538,7 +538,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         let sql = `update ${this.getTableName(meta, options)} set `;
         const addParams = (prop, value) => {
             if (prop.kind === core_1.ReferenceKind.EMBEDDED && prop.object) {
-                if (prop.array) {
+                if (prop.array && value) {
                     for (let i = 0; i < value.length; i++) {
                         const item = value[i];
                         value[i] = this.mapDataToFieldNames(item, false, prop.embeddedProps, options.convertCustomTypes);
@@ -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/PivotCollectionPersister.d.ts

@@ -1,4 +1,4 @@
-import { type EntityMetadata, type EntityProperty, type Primary } from '@mikro-orm/core';
+import { type EntityMetadata, type EntityProperty, type Primary, type Transaction } from '@mikro-orm/core';
 import { type AbstractSqlDriver } from './AbstractSqlDriver';
 export declare class PivotCollectionPersister<Entity extends object> {
     private readonly meta;
@@ -10,7 +10,7 @@ export declare class PivotCollectionPersister<Entity extends object> {
     private readonly deletes;
     private readonly batchSize;
     private order;
-    constructor(meta: EntityMetadata<Entity>, driver: AbstractSqlDriver, ctx?: any, schema?: string | undefined);
+    constructor(meta: EntityMetadata<Entity>, driver: AbstractSqlDriver, ctx?: Transaction | undefined, schema?: string | undefined);
     enqueueUpdate(prop: EntityProperty<Entity>, insertDiff: Primary<Entity>[][], deleteDiff: Primary<Entity>[][] | boolean, pks: Primary<Entity>[]): void;
     private enqueueInsert;
     private enqueueDelete;

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/BaseSqlitePlatform.d.ts

@@ -30,6 +30,9 @@ export declare abstract class BaseSqlitePlatform extends AbstractSqlPlatform {
     }): string;
     getFloatDeclarationSQL(): string;
     getBooleanTypeDeclarationSQL(): string;
+    getCharTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
     getVarcharTypeDeclarationSQL(column: {
         length?: number;
     }): string;

package/dialects/sqlite/BaseSqlitePlatform.js

@@ -38,6 +38,9 @@ class BaseSqlitePlatform extends AbstractSqlPlatform_1.AbstractSqlPlatform {
     getBooleanTypeDeclarationSQL() {
         return 'integer';
     }
+    getCharTypeDeclarationSQL(column) {
+        return 'text';
+    }
     getVarcharTypeDeclarationSQL(column) {
         return 'text';
     }

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/dialects/sqlite/LibSqlKnexDialect.d.ts

@@ -2,5 +2,10 @@ import { MonkeyPatchable } from '../../MonkeyPatchable';
 export declare class LibSqlKnexDialect extends MonkeyPatchable.BetterSqlite3Dialect {
     get driverName(): string;
     _driver(): any;
+    _query(this: any, connection: any, obj: any): Promise<any>;
+    acquireRawConnection(this: any): Promise<any>;
     tableCompiler(): any;
+    validateConnection(connection: any): boolean;
+    private getCallMethod;
+    private isRunQuery;
 }

package/dialects/sqlite/LibSqlKnexDialect.js

@@ -10,9 +10,76 @@ class LibSqlKnexDialect extends MonkeyPatchable_1.MonkeyPatchable.BetterSqlite3D
     _driver() {
         return require('libsql');
     }
+    async _query(connection, obj) {
+        /* istanbul ignore next */
+        if (!obj.sql) {
+            throw new Error('The query is empty');
+        }
+        /* istanbul ignore next */
+        if (!connection) {
+            throw new Error('No connection provided');
+        }
+        const callMethod = this.getCallMethod(obj);
+        const statement = connection.prepare(obj.sql);
+        const bindings = this._formatBindings(obj.bindings);
+        const response = await statement[callMethod](bindings);
+        obj.response = response;
+        obj.context = {
+            lastID: response.lastInsertRowid,
+            changes: response.changes,
+        };
+        return obj;
+    }
+    async acquireRawConnection() {
+        const connection = new this.driver(this.connectionSettings.filename, {
+            ...this.connectionSettings,
+        });
+        connection.__created = Date.now();
+        return connection;
+    }
     tableCompiler() {
         // eslint-disable-next-line prefer-rest-params
         return new SqliteTableCompiler_1.SqliteTableCompiler(this, ...arguments);
     }
+    validateConnection(connection) {
+        if (connection.memory) {
+            return true;
+        }
+        /* istanbul ignore next */
+        return connection.__created > Date.now() - 10_000;
+    }
+    getCallMethod(obj) {
+        if (obj.method === 'raw') {
+            const query = obj.sql.trim().toLowerCase();
+            if ((query.startsWith('insert into') || query.startsWith('update ')) && query.includes(' returning ')) {
+                return 'all';
+            }
+            if (this.isRunQuery(query)) {
+                return 'run';
+            }
+        }
+        /* istanbul ignore next */
+        switch (obj.method) {
+            case 'insert':
+            case 'update':
+                return obj.returning ? 'all' : 'run';
+            case 'counter':
+            case 'del':
+                return 'run';
+            default:
+                return 'all';
+        }
+    }
+    isRunQuery(query) {
+        query = query.trim().toLowerCase();
+        /* istanbul ignore next */
+        if ((query.startsWith('insert into') || query.startsWith('update ')) && query.includes(' returning ')) {
+            return false;
+        }
+        return query.startsWith('insert into') ||
+            query.startsWith('update') ||
+            query.startsWith('delete') ||
+            query.startsWith('truncate');
+    }
 }
 exports.LibSqlKnexDialect = LibSqlKnexDialect;

package/index.mjs

@@ -33,6 +33,7 @@ export const ChangeSet = mod.ChangeSet;
 export const ChangeSetComputer = mod.ChangeSetComputer;
 export const ChangeSetPersister = mod.ChangeSetPersister;
 export const ChangeSetType = mod.ChangeSetType;
+export const CharacterType = mod.CharacterType;
 export const Check = mod.Check;
 export const CheckConstraintViolationException = mod.CheckConstraintViolationException;
 export const Collection = mod.Collection;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.2.10-dev.9",
+  "version": "6.2.10-dev.90",
   "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.9",
+    "@mikro-orm/core": "6.2.10-dev.90",
     "better-sqlite3": "*",
     "libsql": "*",
     "mariadb": "*"

package/query/CriteriaNode.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { inspect } from 'util';
 import { type EntityKey, type EntityProperty, type MetadataStorage } from '@mikro-orm/core';
 import type { ICriteriaNode, ICriteriaNodeProcessOptions, IQueryBuilder } from '../typings';

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,6 @@
-/// <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';
@@ -54,9 +53,9 @@ export type QBField2<Entity, RootAlias extends string, Context> = (EntityKey<Ent
 export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias extends string = never, Hint extends string = never, Context extends object = never> {
     protected readonly metadata: MetadataStorage;
     protected readonly driver: AbstractSqlDriver;
-    protected readonly context?: Knex.Transaction<any, any[]> | undefined;
+    protected readonly context?: Knex.Transaction | undefined;
     protected connectionType?: ConnectionType | undefined;
-    protected em?: SqlEntityManager<AbstractSqlDriver<import("..").AbstractSqlConnection, AbstractSqlPlatform>> | undefined;
+    protected em?: SqlEntityManager | undefined;
     protected loggerContext?: (LoggingOptions & Dictionary) | undefined;
     get mainAlias(): Alias<Entity>;
     get alias(): string;
@@ -88,7 +87,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>;
@@ -119,7 +118,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     /**
      * @internal
      */
-    constructor(entityName: EntityName<Entity> | QueryBuilder<Entity, any, any>, metadata: MetadataStorage, driver: AbstractSqlDriver, context?: Knex.Transaction<any, any[]> | undefined, alias?: string, connectionType?: ConnectionType | undefined, em?: SqlEntityManager<AbstractSqlDriver<import("..").AbstractSqlConnection, AbstractSqlPlatform>> | undefined, loggerContext?: (LoggingOptions & Dictionary) | undefined);
+    constructor(entityName: EntityName<Entity> | QueryBuilder<Entity, any, any>, metadata: MetadataStorage, driver: AbstractSqlDriver, context?: Knex.Transaction | undefined, alias?: string, connectionType?: ConnectionType | undefined, em?: SqlEntityManager | undefined, loggerContext?: (LoggingOptions & Dictionary) | undefined);
     select(fields: Field<Entity> | Field<Entity>[], distinct?: boolean): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
     addSelect(fields: Field<Entity> | Field<Entity>[]): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;
     distinct(): SelectQueryBuilder<Entity, RootAlias, Hint, Context>;

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;
@@ -442,6 +453,9 @@ class QueryBuilderHelper {
             const tmp = value[op].length === 1 && core_1.Utils.isPlainObject(value[op][0]) ? fields.map(f => value[op][0][f]) : value[op];
             value[op] = this.knex.raw(`(${fields.map(() => '?').join(', ')})`, tmp);
         }
+        if (value[op] instanceof core_1.RawQueryFragment) {
+            value[op] = this.knex.raw(value[op].sql, value[op].params);
+        }
         if (this.subQueries[key]) {
             return void qb[m](this.knex.raw(`(${this.subQueries[key]})`), replacement, value[op]);
         }

package/schema/DatabaseTable.d.ts

@@ -25,7 +25,7 @@ export declare class DatabaseTable {
     removeColumn(name: string): void;
     getIndexes(): IndexDef[];
     getChecks(): CheckDef[];
-    init(cols: Column[], indexes: IndexDef[] | undefined, checks: CheckDef<unknown>[] | undefined, pks: string[], fks?: Dictionary<ForeignKey>, enums?: Dictionary<string[]>): void;
+    init(cols: Column[], indexes: IndexDef[] | undefined, checks: CheckDef[] | undefined, pks: string[], fks?: Dictionary<ForeignKey>, enums?: Dictionary<string[]>): void;
     addColumn(column: Column): void;
     addColumnFromProperty(prop: EntityProperty, meta: EntityMetadata, config: Configuration): void;
     private getIndexName;

package/schema/DatabaseTable.js

@@ -70,17 +70,11 @@ class DatabaseTable {
                     prop.length = undefined;
                 }
             }
-            if (mappedType instanceof core_1.DateTimeType || mappedType instanceof core_1.IntervalType) {
-                const match = prop.columnTypes[idx].match(/\w+\((\d+)\)/);
-                if (match) {
-                    prop.length ??= +match[1];
-                }
-                else {
-                    prop.length ??= this.platform.getDefaultDateTimeLength();
-                }
-            }
             if (prop.length == null && prop.columnTypes[idx]) {
                 prop.length = this.platform.getSchemaHelper().inferLengthFromColumnType(prop.columnTypes[idx]);
+                if (typeof mappedType.getDefaultLength !== 'undefined') {
+                    prop.length ??= mappedType.getDefaultLength(this.platform);
+                }
             }
             const primary = !meta.compositePK && !!prop.primary && prop.kind === core_1.ReferenceKind.SCALAR && this.platform.isNumericColumn(mappedType);
             this.columns[field] = {
@@ -171,7 +165,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 +499,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;
         }
@@ -542,7 +537,10 @@ class DatabaseTable {
         }
         return {
             name: prop,
-            type: fk ? runtimeType : (core_1.Utils.entries(core_1.t).find(([k, v]) => Object.getPrototypeOf(column.mappedType) === v.prototype)?.[0] ?? runtimeType),
+            type: fk ? runtimeType : (core_1.Utils.keys(core_1.t).find(k => {
+                const typeInCoreMap = this.platform.getMappedType(k);
+                return (typeInCoreMap !== core_1.Type.getType(core_1.UnknownType) || k === 'unknown') && typeInCoreMap === column.mappedType;
+            }) ?? runtimeType),
             runtimeType,
             kind,
             generated: column.generated,
@@ -558,6 +556,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 +600,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');
@@ -415,7 +418,8 @@ class SchemaComparator {
             log(`'unsigned' changed for column ${tableName}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('unsigned');
         }
-        if (!this.hasSameDefaultValue(fromColumn, toColumn)) {
+        if (!(fromColumn.ignoreSchemaChanges?.includes('default') ||
+            toColumn.ignoreSchemaChanges?.includes('default')) && !this.hasSameDefaultValue(fromColumn, toColumn)) {
             log(`'default' changed for column ${tableName}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('default');
         }

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;
+        createForeignKeyConstraints?: boolean;
+        ignoreSchema?: string[];
+        managementDbName?: string;
+    };
 }

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));
@@ -61,8 +65,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 +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)) {
@@ -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

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