@mikro-orm/knex 6.0.0-dev.14 → 6.0.0-dev.140

package/query/enums.d.ts

@@ -6,3 +6,10 @@ export declare enum QueryType {
     UPDATE = "UPDATE",
     DELETE = "DELETE"
 }
+export declare enum JoinType {
+    leftJoin = "left join",
+    innerJoin = "inner join",
+    pivotJoin = "pivot join",
+    innerJoinLateral = "inner join lateral",
+    leftJoinLateral = "left join lateral"
+}

package/query/enums.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryType = void 0;
+exports.JoinType = exports.QueryType = void 0;
 var QueryType;
 (function (QueryType) {
     QueryType["TRUNCATE"] = "TRUNCATE";
@@ -9,4 +9,12 @@ var QueryType;
     QueryType["INSERT"] = "INSERT";
     QueryType["UPDATE"] = "UPDATE";
     QueryType["DELETE"] = "DELETE";
-})(QueryType = exports.QueryType || (exports.QueryType = {}));
+})(QueryType || (exports.QueryType = QueryType = {}));
+var JoinType;
+(function (JoinType) {
+    JoinType["leftJoin"] = "left join";
+    JoinType["innerJoin"] = "inner join";
+    JoinType["pivotJoin"] = "pivot join";
+    JoinType["innerJoinLateral"] = "inner join lateral";
+    JoinType["leftJoinLateral"] = "left join lateral";
+})(JoinType || (exports.JoinType = JoinType = {}));

package/schema/DatabaseSchema.d.ts

@@ -1,4 +1,4 @@
-import type { Configuration, Dictionary, EntityMetadata } from '@mikro-orm/core';
+import { type Configuration, type Dictionary, type EntityMetadata } from '@mikro-orm/core';
 import { DatabaseTable } from './DatabaseTable';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
@@ -10,14 +10,17 @@ export declare class DatabaseSchema {
     readonly name: string;
     private tables;
     private namespaces;
+    private nativeEnums;
     constructor(platform: AbstractSqlPlatform, name: string);
     addTable(name: string, schema: string | undefined | null, comment?: string): DatabaseTable;
     getTables(): DatabaseTable[];
     getTable(name: string): DatabaseTable | undefined;
     hasTable(name: string): boolean;
+    setNativeEnums(nativeEnums: Dictionary<unknown[]>): void;
+    getNativeEnums(): Dictionary<unknown[]>;
     hasNamespace(namespace: string): boolean;
     getNamespaces(): string[];
-    static create(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, config: Configuration, schemaName?: string): Promise<DatabaseSchema>;
+    static create(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, schemas?: string[]): Promise<DatabaseSchema>;
     static fromMetadata(metadata: EntityMetadata[], platform: AbstractSqlPlatform, config: Configuration, schemaName?: string): DatabaseSchema;
     private static getSchemaName;
     private static shouldHaveColumn;

package/schema/DatabaseSchema.js

@@ -7,15 +7,19 @@ const DatabaseTable_1 = require("./DatabaseTable");
  * @internal
  */
 class DatabaseSchema {
+    platform;
+    name;
+    tables = [];
+    namespaces = new Set();
+    nativeEnums = {}; // for postgres
     constructor(platform, name) {
         this.platform = platform;
         this.name = name;
-        this.tables = [];
-        this.namespaces = new Set();
     }
     addTable(name, schema, comment) {
         const namespaceName = schema ?? this.name;
         const table = new DatabaseTable_1.DatabaseTable(this.platform, name, namespaceName);
+        table.nativeEnums = this.nativeEnums;
         table.comment = comment;
         this.tables.push(table);
         if (namespaceName != null) {
@@ -32,24 +36,38 @@ class DatabaseSchema {
     hasTable(name) {
         return !!this.getTable(name);
     }
+    setNativeEnums(nativeEnums) {
+        this.nativeEnums = nativeEnums;
+        this.tables.forEach(t => t.nativeEnums = nativeEnums);
+    }
+    getNativeEnums() {
+        return this.nativeEnums;
+    }
     hasNamespace(namespace) {
         return this.namespaces.has(namespace);
     }
     getNamespaces() {
         return [...this.namespaces];
     }
-    static async create(connection, platform, config, schemaName) {
-        const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema'));
+    static async create(connection, platform, config, schemaName, schemas) {
+        const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema') ?? platform.getDefaultSchemaName());
         const allTables = await connection.execute(platform.getSchemaHelper().getListTablesSQL());
         const parts = config.get('migrations').tableName.split('.');
         const migrationsTableName = parts[1] ?? parts[0];
         const migrationsSchemaName = parts.length > 1 ? parts[0] : config.get('schema', platform.getDefaultSchemaName());
         const tables = allTables.filter(t => t.table_name !== migrationsTableName || (t.schema_name && t.schema_name !== migrationsSchemaName));
-        await platform.getSchemaHelper().loadInformationSchema(schema, connection, tables);
+        await platform.getSchemaHelper().loadInformationSchema(schema, connection, tables, schemas && schemas.length > 0 ? schemas : undefined);
         return schema;
     }
     static fromMetadata(metadata, platform, config, schemaName) {
         const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema'));
+        const nativeEnums = {};
+        for (const meta of metadata) {
+            meta.props
+                .filter(prop => prop.nativeEnumName)
+                .forEach(prop => nativeEnums[prop.nativeEnumName] = prop.items?.map(val => '' + val) ?? []);
+        }
+        schema.setNativeEnums(nativeEnums);
         for (const meta of metadata) {
             const table = schema.addTable(meta.collection, this.getSchemaName(meta, config, schemaName));
             table.comment = meta.comment;
@@ -75,18 +93,18 @@ class DatabaseSchema {
         return (meta.schema === '*' ? schema : meta.schema) ?? config.get('schema');
     }
     static shouldHaveColumn(meta, prop) {
-        if (prop.persist === false || !prop.fieldNames) {
+        if (prop.persist === false || (prop.columnTypes?.length ?? 0) === 0) {
             return false;
         }
-        if (meta.pivotTable || (core_1.ReferenceType.EMBEDDED && prop.object)) {
+        if (meta.pivotTable || (prop.kind === core_1.ReferenceKind.EMBEDDED && prop.object)) {
             return true;
         }
         const getRootProperty = (prop) => prop.embedded ? getRootProperty(meta.properties[prop.embedded[0]]) : prop;
         const rootProp = getRootProperty(prop);
-        if (rootProp.reference === core_1.ReferenceType.EMBEDDED) {
+        if (rootProp.kind === core_1.ReferenceKind.EMBEDDED) {
             return prop === rootProp || !rootProp.object;
         }
-        return [core_1.ReferenceType.SCALAR, core_1.ReferenceType.MANY_TO_ONE].includes(prop.reference) || (prop.reference === core_1.ReferenceType.ONE_TO_ONE && prop.owner);
+        return [core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.MANY_TO_ONE].includes(prop.kind) || (prop.kind === core_1.ReferenceKind.ONE_TO_ONE && prop.owner);
     }
     toJSON() {
         const { platform, namespaces, ...rest } = this;

package/schema/DatabaseTable.d.ts

@@ -1,4 +1,4 @@
-import type { Dictionary, EntityMetadata, EntityProperty, NamingStrategy } from '@mikro-orm/core';
+import { type Dictionary, type EntityMetadata, type EntityProperty, type NamingStrategy } from '@mikro-orm/core';
 import type { SchemaHelper } from './SchemaHelper';
 import type { CheckDef, Column, ForeignKey, IndexDef } from '../typings';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
@@ -13,10 +13,12 @@ export declare class DatabaseTable {
     private indexes;
     private checks;
     private foreignKeys;
+    nativeEnums: Dictionary<unknown[]>;
     comment?: string;
     constructor(platform: AbstractSqlPlatform, name: string, schema?: string | undefined);
     getColumns(): Column[];
     getColumn(name: string): Column | undefined;
+    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;
@@ -37,7 +39,7 @@ export declare class DatabaseTable {
     getPrimaryKey(): IndexDef | undefined;
     hasPrimaryKey(): boolean;
     private getPropertyDeclaration;
-    private getReferenceType;
+    private getReferenceKind;
     private getPropertyName;
     private getPropertyType;
     private getPropertyDefaultValue;

package/schema/DatabaseTable.js

@@ -6,14 +6,19 @@ const core_1 = require("@mikro-orm/core");
  * @internal
  */
 class DatabaseTable {
+    platform;
+    name;
+    schema;
+    columns = {};
+    indexes = [];
+    checks = [];
+    foreignKeys = {};
+    nativeEnums = {}; // for postgres
+    comment;
     constructor(platform, name, schema) {
         this.platform = platform;
         this.name = name;
         this.schema = schema;
-        this.columns = {};
-        this.indexes = [];
-        this.checks = [];
-        this.foreignKeys = {};
         Object.defineProperties(this, {
             platform: { enumerable: false, writable: true },
         });
@@ -24,8 +29,11 @@ class DatabaseTable {
     getColumn(name) {
         return this.columns[name];
     }
+    removeColumn(name) {
+        delete this.columns[name];
+    }
     getIndexes() {
-        return this.indexes;
+        return core_1.Utils.removeDuplicates(this.indexes);
     }
     getChecks() {
         return this.checks;
@@ -41,7 +49,7 @@ class DatabaseTable {
             const type = v.name in enums ? 'enum' : v.type;
             v.mappedType = this.platform.getMappedType(type);
             v.default = v.default?.toString().startsWith('nextval(') ? null : v.default;
-            v.enumItems = enums[v.name] || [];
+            v.enumItems ??= enums[v.name] || [];
             o[v.name] = v;
             return o;
         }, {});
@@ -51,44 +59,51 @@ class DatabaseTable {
     }
     addColumnFromProperty(prop, meta) {
         prop.fieldNames.forEach((field, idx) => {
-            var _a;
             const type = prop.enum ? 'enum' : prop.columnTypes[idx];
             const mappedType = this.platform.getMappedType(type);
             if (mappedType instanceof core_1.DecimalType) {
                 const match = prop.columnTypes[idx].match(/\w+\((\d+), ?(\d+)\)/);
                 /* istanbul ignore else */
                 if (match) {
-                    prop.precision = +match[1];
-                    prop.scale = +match[2];
+                    prop.precision ??= +match[1];
+                    prop.scale ??= +match[2];
                     prop.length = undefined;
                 }
             }
             if (mappedType instanceof core_1.DateTimeType) {
-                prop.length ?? (prop.length = this.platform.getDefaultDateTimeLength());
+                const match = prop.columnTypes[idx].match(/\w+\((\d+)\)/);
+                if (match) {
+                    prop.length ??= +match[1];
+                }
+                else {
+                    prop.length ??= this.platform.getDefaultDateTimeLength();
+                }
             }
-            const primary = !meta.compositePK && !!prop.primary && prop.reference === core_1.ReferenceType.SCALAR && this.platform.isNumericColumn(mappedType);
+            const primary = !meta.compositePK && !!prop.primary && prop.kind === core_1.ReferenceKind.SCALAR && this.platform.isNumericColumn(mappedType);
             this.columns[field] = {
                 name: prop.fieldNames[idx],
                 type: prop.columnTypes[idx],
+                generated: prop.generated,
                 mappedType,
                 unsigned: prop.unsigned && this.platform.isNumericColumn(mappedType),
                 autoincrement: prop.autoincrement ?? primary,
                 primary,
-                nullable: !!prop.nullable,
+                nullable: this.columns[field]?.nullable ?? !!prop.nullable,
+                nativeEnumName: prop.nativeEnumName,
                 length: prop.length,
                 precision: prop.precision,
                 scale: prop.scale,
                 default: prop.defaultRaw,
-                enumItems: prop.items?.every(core_1.Utils.isString) ? prop.items : undefined,
+                enumItems: prop.nativeEnumName || prop.items?.every(core_1.Utils.isString) ? prop.items : undefined,
                 comment: prop.comment,
                 extra: prop.extra,
                 ignoreSchemaChanges: prop.ignoreSchemaChanges,
             };
-            (_a = this.columns[field]).unsigned || (_a.unsigned = this.columns[field].autoincrement);
+            this.columns[field].unsigned ||= this.columns[field].autoincrement;
             const defaultValue = this.platform.getSchemaHelper().normalizeDefaultValue(prop.defaultRaw, prop.length);
             this.columns[field].default = defaultValue;
         });
-        if ([core_1.ReferenceType.MANY_TO_ONE, core_1.ReferenceType.ONE_TO_ONE].includes(prop.reference)) {
+        if ([core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
             const constraintName = this.getIndexName(true, prop.fieldNames, 'foreign');
             let schema = prop.targetMeta.schema === '*' ? this.schema : prop.targetMeta.schema ?? this.schema;
             if (prop.referencedTableName.includes('.')) {
@@ -102,11 +117,11 @@ class DatabaseTable {
                 referencedTableName: schema ? `${schema}.${prop.referencedTableName}` : prop.referencedTableName,
             };
             const cascade = prop.cascade.includes(core_1.Cascade.REMOVE) || prop.cascade.includes(core_1.Cascade.ALL);
-            if (prop.onDelete || cascade || prop.nullable) {
-                this.foreignKeys[constraintName].deleteRule = prop.onDelete || (cascade ? 'cascade' : 'set null');
+            if (prop.deleteRule || cascade || prop.nullable) {
+                this.foreignKeys[constraintName].deleteRule = prop.deleteRule || (cascade ? 'cascade' : 'set null');
             }
-            if (prop.onUpdateIntegrity || prop.cascade.includes(core_1.Cascade.PERSIST) || prop.cascade.includes(core_1.Cascade.ALL)) {
-                this.foreignKeys[constraintName].updateRule = prop.onUpdateIntegrity || 'cascade';
+            if (prop.updateRule || prop.cascade.includes(core_1.Cascade.PERSIST) || prop.cascade.includes(core_1.Cascade.ALL)) {
+                this.foreignKeys[constraintName].updateRule = prop.updateRule || 'cascade';
             }
         }
         if (prop.index) {
@@ -114,6 +129,7 @@ class DatabaseTable {
                 columnNames: prop.fieldNames,
                 composite: prop.fieldNames.length > 1,
                 keyName: this.getIndexName(prop.index, prop.fieldNames, 'index'),
+                constraint: false,
                 primary: false,
                 unique: false,
             });
@@ -123,6 +139,7 @@ class DatabaseTable {
                 columnNames: prop.fieldNames,
                 composite: prop.fieldNames.length > 1,
                 keyName: this.getIndexName(prop.unique, prop.fieldNames, 'unique'),
+                constraint: !prop.fieldNames.some((d) => d.includes('.')),
                 primary: false,
                 unique: true,
             });
@@ -164,8 +181,8 @@ class DatabaseTable {
         }
         const meta = schema.init().meta;
         meta.relations
-            .filter(prop => prop.primary && prop.reference === core_1.ReferenceType.MANY_TO_ONE && !meta.compositePK)
-            .forEach(prop => prop.reference = core_1.ReferenceType.ONE_TO_ONE);
+            .filter(prop => prop.primary && prop.kind === core_1.ReferenceKind.MANY_TO_ONE && !meta.compositePK)
+            .forEach(prop => prop.kind = core_1.ReferenceKind.ONE_TO_ONE);
         return meta;
     }
     /**
@@ -206,20 +223,20 @@ class DatabaseTable {
         const prop = this.getPropertyName(namingStrategy, column);
         const index = compositeFkIndexes[prop] || this.indexes.find(idx => idx.columnNames[0] === column.name && !idx.composite && !idx.unique && !idx.primary);
         const unique = compositeFkUniques[prop] || this.indexes.find(idx => idx.columnNames[0] === column.name && !idx.composite && idx.unique && !idx.primary);
-        const reference = this.getReferenceType(fk, unique);
+        const kind = this.getReferenceKind(fk, unique);
         const type = this.getPropertyType(namingStrategy, column, fk);
         const fkOptions = {};
         if (fk) {
             fkOptions.fieldNames = fk.columnNames;
             fkOptions.referencedTableName = fk.referencedTableName;
             fkOptions.referencedColumnNames = fk.referencedColumnNames;
-            fkOptions.onUpdateIntegrity = fk.updateRule?.toLowerCase();
-            fkOptions.onDelete = fk.deleteRule?.toLowerCase();
+            fkOptions.updateRule = fk.updateRule?.toLowerCase();
+            fkOptions.deleteRule = fk.deleteRule?.toLowerCase();
         }
         return {
             name: prop,
             type,
-            reference,
+            kind,
             columnType: column.type,
             default: this.getPropertyDefaultValue(schemaHelper, column, type),
             defaultRaw: this.getPropertyDefaultValue(schemaHelper, column, type, true),
@@ -227,6 +244,8 @@ class DatabaseTable {
             primary: column.primary,
             fieldName: column.name,
             length: column.length,
+            precision: column.precision,
+            scale: column.scale,
             index: index ? index.keyName : undefined,
             unique: unique ? unique.keyName : undefined,
             enum: !!column.enumItems?.length,
@@ -234,14 +253,14 @@ class DatabaseTable {
             ...fkOptions,
         };
     }
-    getReferenceType(fk, unique) {
+    getReferenceKind(fk, unique) {
         if (fk && unique) {
-            return core_1.ReferenceType.ONE_TO_ONE;
+            return core_1.ReferenceKind.ONE_TO_ONE;
         }
         if (fk) {
-            return core_1.ReferenceType.MANY_TO_ONE;
+            return core_1.ReferenceKind.MANY_TO_ONE;
         }
-        return core_1.ReferenceType.SCALAR;
+        return core_1.ReferenceKind.SCALAR;
     }
     getPropertyName(namingStrategy, column) {
         const fk = Object.values(this.foreignKeys).find(fk => fk.columnNames.includes(column.name));
@@ -288,7 +307,20 @@ class DatabaseTable {
         return '' + val;
     }
     addIndex(meta, index, type) {
-        const properties = core_1.Utils.flatten(core_1.Utils.asArray(index.properties).map(prop => meta.properties[prop].fieldNames));
+        const properties = core_1.Utils.unique(core_1.Utils.flatten(core_1.Utils.asArray(index.properties).map(prop => {
+            const root = prop.replace(/\..+$/, '');
+            if (meta.properties[prop]) {
+                if (meta.properties[prop].embeddedPath) {
+                    return [meta.properties[prop].embeddedPath.join('.')];
+                }
+                return meta.properties[prop].fieldNames;
+            }
+            // json index, we need to rename the column only
+            if (meta.properties[root]) {
+                return [prop.replace(root, meta.properties[root].fieldNames[0])];
+            }
+            return [prop];
+        })));
         if (properties.length === 0 && !index.expression) {
             return;
         }
@@ -297,10 +329,13 @@ class DatabaseTable {
             keyName: name,
             columnNames: properties,
             composite: properties.length > 1,
+            // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
+            constraint: type !== 'index' && !properties.some((d) => d.includes('.')),
             primary: type === 'primary',
             unique: type !== 'index',
             type: index.type,
             expression: index.expression,
+            options: index.options,
         });
     }
     addCheck(check) {
@@ -308,10 +343,10 @@ class DatabaseTable {
     }
     toJSON() {
         const { platform, columns, ...rest } = this;
-        const columnsMapped = Object.keys(columns).reduce((o, col) => {
+        const columnsMapped = core_1.Utils.keys(columns).reduce((o, col) => {
             const { mappedType, ...restCol } = columns[col];
             o[col] = restCol;
-            o[col].mappedType = Object.keys(core_1.t).find(k => core_1.t[k] === mappedType.constructor);
+            o[col].mappedType = core_1.Utils.keys(core_1.t).find(k => core_1.t[k] === mappedType.constructor);
             return o;
         }, {});
         return { columns: columnsMapped, ...rest };

package/schema/SchemaComparator.d.ts

@@ -1,4 +1,4 @@
-import type { CheckDef, Column, ForeignKey, IndexDef, SchemaDifference, TableDifference } from '../typings';
+import type { Column, ForeignKey, IndexDef, SchemaDifference, TableDifference } from '../typings';
 import type { DatabaseSchema } from './DatabaseSchema';
 import type { DatabaseTable } from './DatabaseTable';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
@@ -38,7 +38,7 @@ export declare class SchemaComparator {
      * Returns the difference between the columns
      * If there are differences this method returns field2, otherwise the boolean false.
      */
-    diffColumn(column1: Column, column2: Column, tableName?: string): Set<string>;
+    diffColumn(fromColumn: Column, toColumn: Column, tableName?: string): Set<string>;
     diffEnumItems(items1?: string[], items2?: string[]): boolean;
     diffComment(comment1?: string, comment2?: string): boolean;
     /**
@@ -50,7 +50,7 @@ export declare class SchemaComparator {
      * Checks if the other index already fulfills all the indexing and constraint needs of the current one.
      */
     isIndexFulfilledBy(index1: IndexDef, index2: IndexDef): boolean;
-    diffCheck(check1: CheckDef, check2: CheckDef): boolean;
+    diffExpression(expr1: string, expr2: string): boolean;
     hasSameDefaultValue(from: Column, to: Column): boolean;
     private mapColumnToProperty;
     private log;

package/schema/SchemaComparator.js

@@ -7,6 +7,9 @@ const core_1 = require("@mikro-orm/core");
  * Compares two Schemas and return an instance of SchemaDifference.
  */
 class SchemaComparator {
+    platform;
+    helper;
+    logger;
     constructor(platform) {
         this.platform = platform;
         this.helper = this.platform.getSchemaHelper();
@@ -139,6 +142,12 @@ class SchemaComparator {
             if (changedProperties.size === 0) {
                 continue;
             }
+            if (changedProperties.size === 1 && changedProperties.has('generated')) {
+                tableDifferences.addedColumns[column.name] = toTable.getColumn(column.name);
+                tableDifferences.removedColumns[column.name] = column;
+                changes++;
+                continue;
+            }
             tableDifferences.changedColumns[column.name] = {
                 oldColumnName: column.name,
                 fromColumn: column,
@@ -200,7 +209,7 @@ class SchemaComparator {
             }
             // See if index has changed in "to" table
             const toTableCheck = toTable.getCheck(check.name);
-            if (!this.diffCheck(check, toTableCheck)) {
+            if (!this.diffExpression(check.expression, toTableCheck.expression)) {
                 continue;
             }
             this.log(`check constraint ${check.name} changed in table ${tableDifferences.name}`, { fromTableCheck: check, toTableCheck });
@@ -324,12 +333,12 @@ class SchemaComparator {
      * Returns the difference between the columns
      * If there are differences this method returns field2, otherwise the boolean false.
      */
-    diffColumn(column1, column2, tableName) {
+    diffColumn(fromColumn, toColumn, tableName) {
         const changedProperties = new Set();
-        const prop1 = this.mapColumnToProperty({ ...column1, autoincrement: false });
-        const prop2 = this.mapColumnToProperty({ ...column2, autoincrement: false });
-        const columnType1 = column1.mappedType.getColumnType(prop1, this.platform).toLowerCase();
-        const columnType2 = column2.mappedType.getColumnType(prop2, this.platform).toLowerCase();
+        const fromProp = this.mapColumnToProperty({ ...fromColumn, autoincrement: false });
+        const toProp = this.mapColumnToProperty({ ...toColumn, autoincrement: false });
+        const fromColumnType = fromColumn.mappedType.getColumnType(fromProp, this.platform).toLowerCase();
+        const toColumnType = toColumn.mappedType.getColumnType(toProp, this.platform).toLowerCase();
         const log = (msg, params) => {
             if (tableName) {
                 const copy = core_1.Utils.copy(params);
@@ -337,40 +346,46 @@ class SchemaComparator {
                 this.log(msg, copy);
             }
         };
-        if (columnType1 !== columnType2 &&
-            !(column1.ignoreSchemaChanges?.includes('type') ||
-                column2.ignoreSchemaChanges?.includes('type'))) {
-            log(`'type' changed for column ${tableName}.${column1.name}`, { columnType1, columnType2 });
+        if (fromColumnType !== toColumnType &&
+            !(fromColumn.ignoreSchemaChanges?.includes('type') ||
+                toColumn.ignoreSchemaChanges?.includes('type'))) {
+            log(`'type' changed for column ${tableName}.${fromColumn.name}`, { fromColumnType, toColumnType });
             changedProperties.add('type');
         }
-        if (column1.nullable !== column2.nullable) {
-            log(`'nullable' changed for column ${tableName}.${column1.name}`, { column1, column2 });
+        if (fromColumn.nullable !== toColumn.nullable && !fromColumn.generated && !toColumn.generated) {
+            log(`'nullable' changed for column ${tableName}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('nullable');
         }
-        if (!!column1.autoincrement !== !!column2.autoincrement) {
-            log(`'autoincrement' changed for column ${tableName}.${column1.name}`, { column1, column2 });
+        if (this.diffExpression(fromColumn.generated, toColumn.generated)) {
+            log(`'generated' changed for column ${tableName}.${fromColumn.name}`, { fromColumn, toColumn });
+            changedProperties.add('generated');
+        }
+        if (!!fromColumn.autoincrement !== !!toColumn.autoincrement) {
+            log(`'autoincrement' changed for column ${tableName}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('autoincrement');
         }
-        if (column1.unsigned !== column2.unsigned && this.platform.supportsUnsigned()) {
-            log(`'unsigned' changed for column ${tableName}.${column1.name}`, { column1, column2 });
+        if (fromColumn.unsigned !== toColumn.unsigned && this.platform.supportsUnsigned()) {
+            log(`'unsigned' changed for column ${tableName}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('unsigned');
         }
-        if (!this.hasSameDefaultValue(column1, column2)) {
-            log(`'default' changed for column ${tableName}.${column1.name}`, { column1, column2 });
+        if (!this.hasSameDefaultValue(fromColumn, toColumn)) {
+            log(`'default' changed for column ${tableName}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('default');
         }
-        if (this.diffComment(column1.comment, column2.comment)) {
-            log(`'comment' changed for column ${tableName}.${column1.name}`, { column1, column2 });
+        if (this.diffComment(fromColumn.comment, toColumn.comment)) {
+            log(`'comment' changed for column ${tableName}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('comment');
         }
-        if (this.diffEnumItems(column1.enumItems, column2.enumItems)) {
-            log(`'enumItems' changed for column ${tableName}.${column1.name}`, { column1, column2 });
+        if (!(fromColumn.mappedType instanceof core_1.ArrayType) &&
+            !(toColumn.mappedType instanceof core_1.ArrayType) &&
+            this.diffEnumItems(fromColumn.enumItems, toColumn.enumItems)) {
+            log(`'enumItems' changed for column ${tableName}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('enumItems');
         }
-        if ((column1.extra || '').toLowerCase() !== (column2.extra || '').toLowerCase() &&
-            !(column1.ignoreSchemaChanges?.includes('extra') ||
-                column2.ignoreSchemaChanges?.includes('extra'))) {
-            log(`'extra' changed for column ${tableName}.${column1.name}`, { column1, column2 });
+        if ((fromColumn.extra || '').toLowerCase() !== (toColumn.extra || '').toLowerCase() &&
+            !(fromColumn.ignoreSchemaChanges?.includes('extra') ||
+                toColumn.ignoreSchemaChanges?.includes('extra'))) {
+            log(`'extra' changed for column ${tableName}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('extra');
         }
         return changedProperties;
@@ -424,11 +439,11 @@ class SchemaComparator {
         }
         return index1.primary === index2.primary && index1.unique === index2.unique;
     }
-    diffCheck(check1, check2) {
-        // check constraint definition might be normalized by the driver,
+    diffExpression(expr1, expr2) {
+        // expressions like check constraints might be normalized by the driver,
         // e.g. quotes might be added (https://github.com/mikro-orm/mikro-orm/issues/3827)
-        const simplify = (str) => str?.replace(/['"`()]/g, '').toLowerCase();
-        return simplify(check1.expression) !== simplify(check2.expression);
+        const simplify = (str) => str?.replace(/_\w+\\'(.*?)\\'/g, '$1').replace(/['"`()]|::\w+| +/g, '').toLowerCase();
+        return simplify(expr1) !== simplify(expr2);
     }
     hasSameDefaultValue(from, to) {
         if (from.default == null || from.default.toString().toLowerCase() === 'null' || from.default.toString().startsWith('nextval(')) {
@@ -439,6 +454,11 @@ class SchemaComparator {
             const defaultValueTo = !['0', 'false', 'f', 'n', 'no', 'off'].includes('' + to.default);
             return defaultValueFrom === defaultValueTo;
         }
+        if (to.mappedType instanceof core_1.JsonType) {
+            const defaultValueFrom = (0, core_1.parseJsonSafe)(from.default.replace(/^'(.*)'$/, '$1'));
+            const defaultValueTo = (0, core_1.parseJsonSafe)(to.default?.replace(/^'(.*)'$/, '$1'));
+            return core_1.Utils.equals(defaultValueFrom, defaultValueTo);
+        }
         if (to.mappedType instanceof core_1.DateTimeType && from.default && to.default) {
             // normalize now/current_timestamp defaults, also remove `()` from the end of default expression
             const defaultValueFrom = from.default.toLowerCase().replace('current_timestamp', 'now').replace(/\(\)$/, '');

package/schema/SchemaHelper.d.ts

@@ -1,5 +1,5 @@
 import type { Knex } from 'knex';
-import type { Connection, Dictionary } from '@mikro-orm/core';
+import { type Connection, type Dictionary } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
 import type { CheckDef, Column, IndexDef, Table, TableDifference } from '../typings';
@@ -18,7 +18,9 @@ export declare abstract class SchemaHelper {
     getForeignKeys(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Dictionary>;
     protected getTableKey(t: Table): string;
     getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName: string, schemaName?: string): Promise<Dictionary<string[]>>;
-    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[]): Promise<void>;
+    getDropNativeEnumSQL(name: string, schema?: string): string;
+    getAlterNativeEnumSQL(name: string, schema?: string, value?: string): string;
+    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
     getListTablesSQL(schemaName?: string): string;
     getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column, schemaName?: string): string;
     getCreateIndexSQL(tableName: string, index: IndexDef): string;
@@ -29,8 +31,8 @@ export declare abstract class SchemaHelper {
     configureColumn(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;
     configureColumnDefault(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string;
-    getAlterColumnAutoincrement(tableName: string, column: Column): string;
-    getChangeColumnCommentSQL(tableName: string, to: Column): string;
+    getAlterColumnAutoincrement(tableName: string, column: Column, schemaName?: string): string;
+    getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
     getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
     getColumns(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Column[]>;
     getIndexes(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<IndexDef[]>;