@mikro-orm/knex 6.0.0-dev.23 → 6.0.0-dev.230

package/schema/SchemaComparator.d.ts

@@ -1,4 +1,5 @@
-import type { CheckDef, Column, ForeignKey, IndexDef, SchemaDifference, TableDifference } from '../typings';
+import { type Dictionary } from '@mikro-orm/core';
+import type { Column, ForeignKey, IndexDef, SchemaDifference, TableDifference } from '../typings';
 import type { DatabaseSchema } from './DatabaseSchema';
 import type { DatabaseTable } from './DatabaseTable';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
@@ -17,12 +18,12 @@ export declare class SchemaComparator {
      * operations to change the schema stored in fromSchema to the schema that is
      * stored in toSchema.
      */
-    compare(fromSchema: DatabaseSchema, toSchema: DatabaseSchema): SchemaDifference;
+    compare(fromSchema: DatabaseSchema, toSchema: DatabaseSchema, inverseDiff?: SchemaDifference): SchemaDifference;
     /**
      * Returns the difference between the tables fromTable and toTable.
      * If there are no differences this method returns the boolean false.
      */
-    diffTable(fromTable: DatabaseTable, toTable: DatabaseTable): TableDifference | false;
+    diffTable(fromTable: DatabaseTable, toTable: DatabaseTable, inverseTableDiff?: TableDifference): TableDifference | false;
     /**
      * Try to find columns that only changed their name, rename operations maybe cheaper than add/drop
      * however ambiguities between different possibilities should not lead to renaming at all.
@@ -38,7 +39,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 +51,8 @@ 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;
+    parseJsonDefault(defaultValue?: string | null): Dictionary | string | null;
     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();
@@ -19,7 +22,7 @@ class SchemaComparator {
      * operations to change the schema stored in fromSchema to the schema that is
      * stored in toSchema.
      */
-    compare(fromSchema, toSchema) {
+    compare(fromSchema, toSchema, inverseDiff) {
         const diff = { newTables: {}, removedTables: {}, changedTables: {}, orphanedForeignKeys: [], newNamespaces: new Set(), removedNamespaces: new Set(), fromSchema };
         const foreignKeysToTable = {};
         for (const namespace of toSchema.getNamespaces()) {
@@ -40,7 +43,7 @@ class SchemaComparator {
                 diff.newTables[tableName] = toSchema.getTable(tableName);
             }
             else {
-                const tableDifferences = this.diffTable(fromSchema.getTable(tableName), toSchema.getTable(tableName));
+                const tableDifferences = this.diffTable(fromSchema.getTable(tableName), toSchema.getTable(tableName), inverseDiff?.changedTables[tableName]);
                 if (tableDifferences !== false) {
                     diff.changedTables[tableName] = tableDifferences;
                 }
@@ -88,7 +91,7 @@ class SchemaComparator {
      * Returns the difference between the tables fromTable and toTable.
      * If there are no differences this method returns the boolean false.
      */
-    diffTable(fromTable, toTable) {
+    diffTable(fromTable, toTable, inverseTableDiff) {
         let changes = 0;
         const tableDifferences = {
             name: fromTable.getShortestName(),
@@ -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,
@@ -148,7 +157,7 @@ class SchemaComparator {
             this.log(`column ${tableDifferences.name}.${column.name} changed`, { changedProperties });
             changes++;
         }
-        this.detectColumnRenamings(tableDifferences);
+        this.detectColumnRenamings(tableDifferences, inverseTableDiff);
         const fromTableIndexes = fromTable.getIndexes();
         const toTableIndexes = toTable.getIndexes();
         // See if all the indexes in "from" table exist in "to" table
@@ -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 });
@@ -240,7 +249,7 @@ class SchemaComparator {
      * Try to find columns that only changed their name, rename operations maybe cheaper than add/drop
      * however ambiguities between different possibilities should not lead to renaming at all.
      */
-    detectColumnRenamings(tableDifferences) {
+    detectColumnRenamings(tableDifferences, inverseTableDiff) {
         const renameCandidates = {};
         for (const addedColumn of Object.values(tableDifferences.addedColumns)) {
             for (const removedColumn of Object.values(tableDifferences.removedColumns)) {
@@ -248,6 +257,10 @@ class SchemaComparator {
                 if (diff.size !== 0) {
                     continue;
                 }
+                const renamedColumn = inverseTableDiff?.renamedColumns[addedColumn.name];
+                if (renamedColumn && renamedColumn?.name !== removedColumn.name) {
+                    continue;
+                }
                 renameCandidates[addedColumn.name] = renameCandidates[addedColumn.name] ?? [];
                 renameCandidates[addedColumn.name].push([removedColumn, addedColumn]);
             }
@@ -324,12 +337,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 +350,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 +443,20 @@ 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);
+    }
+    parseJsonDefault(defaultValue) {
+        if (!defaultValue) {
+            return null;
+        }
+        const val = defaultValue
+            .replace(/^(_\w+\\)?'(.*?)\\?'$/, '$2')
+            .replace(/^\(?'(.*?)'\)?$/, '$1');
+        return (0, core_1.parseJsonSafe)(val);
     }
     hasSameDefaultValue(from, to) {
         if (from.default == null || from.default.toString().toLowerCase() === 'null' || from.default.toString().startsWith('nextval(')) {
@@ -439,6 +467,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 = this.parseJsonDefault(from.default);
+            const defaultValueTo = this.parseJsonDefault(to.default);
+            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,10 +18,12 @@ 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;
+    getCreateIndexSQL(tableName: string, index: IndexDef, partialExpression?: boolean): string;
     getDropIndexSQL(tableName: string, index: IndexDef): string;
     getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string;
     hasNonDefaultPrimaryKeyName(table: DatabaseTable): boolean;
@@ -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[]>;

package/schema/SchemaHelper.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchemaHelper = void 0;
 const core_1 = require("@mikro-orm/core");
 class SchemaHelper {
+    platform;
     constructor(platform) {
         this.platform = platform;
     }
@@ -46,7 +47,13 @@ class SchemaHelper {
     async getEnumDefinitions(connection, checks, tableName, schemaName) {
         return {};
     }
-    async loadInformationSchema(schema, connection, tables) {
+    getDropNativeEnumSQL(name, schema) {
+        throw new Error('Not supported by given driver');
+    }
+    getAlterNativeEnumSQL(name, schema, value) {
+        throw new Error('Not supported by given driver');
+    }
+    async loadInformationSchema(schema, connection, tables, schemas) {
         for (const t of tables) {
             const table = schema.addTable(t.table_name, t.schema_name);
             table.comment = t.table_comment;
@@ -70,14 +77,17 @@ class SchemaHelper {
         const tableReference = schemaReference + tableName;
         return `alter table ${tableReference} rename column ${oldColumnName} to ${columnName}`;
     }
-    getCreateIndexSQL(tableName, index) {
-        /* istanbul ignore if */
-        if (index.expression) {
+    getCreateIndexSQL(tableName, index, partialExpression = false) {
+        if (index.expression && !partialExpression) {
             return index.expression;
         }
         tableName = this.platform.quoteIdentifier(tableName);
         const keyName = this.platform.quoteIdentifier(index.keyName);
-        return `create index ${keyName} on ${tableName} (${index.columnNames.map(c => this.platform.quoteIdentifier(c)).join(', ')})`;
+        const sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName} `;
+        if (index.expression && partialExpression) {
+            return `${sql}(${index.expression})`;
+        }
+        return `${sql}(${index.columnNames.map(c => this.platform.quoteIdentifier(c)).join(', ')})`;
     }
     getDropIndexSQL(tableName, index) {
         return `drop index ${this.platform.quoteIdentifier(index.keyName)}`;
@@ -95,7 +105,7 @@ class SchemaHelper {
     }
     createTableColumn(table, column, fromTable, changedProperties) {
         const compositePK = fromTable.getPrimaryKey()?.composite;
-        if (column.autoincrement && !compositePK && (!changedProperties || changedProperties.has('autoincrement') || changedProperties.has('type'))) {
+        if (column.autoincrement && !column.generated && !compositePK && (!changedProperties || changedProperties.has('autoincrement') || changedProperties.has('type'))) {
             const primaryKey = !changedProperties && !this.hasNonDefaultPrimaryKeyName(fromTable);
             if (column.mappedType instanceof core_1.BigIntType) {
                 return table.bigIncrements(column.name, { primaryKey });
@@ -105,12 +115,16 @@ class SchemaHelper {
         if (column.mappedType instanceof core_1.EnumType && column.enumItems?.every(item => core_1.Utils.isString(item))) {
             return table.enum(column.name, column.enumItems);
         }
-        return table.specificType(column.name, column.type);
+        let columnType = column.type;
+        if (column.generated) {
+            columnType += ` generated always as ${column.generated}`;
+        }
+        return table.specificType(column.name, columnType);
     }
     configureColumn(column, col, knex, changedProperties) {
         const guard = (key) => !changedProperties || changedProperties.has(key);
         core_1.Utils.runIfNotEmpty(() => col.nullable(), column.nullable && guard('nullable'));
-        core_1.Utils.runIfNotEmpty(() => col.notNullable(), !column.nullable);
+        core_1.Utils.runIfNotEmpty(() => col.notNullable(), !column.nullable && !column.generated);
         core_1.Utils.runIfNotEmpty(() => col.unsigned(), column.unsigned);
         core_1.Utils.runIfNotEmpty(() => col.comment(column.comment), column.comment);
         this.configureColumnDefault(column, col, knex, changedProperties);
@@ -122,17 +136,17 @@ class SchemaHelper {
             core_1.Utils.runIfNotEmpty(() => col.defaultTo(column.default == null ? null : knex.raw(column.default)), guard('default'));
         }
         else {
-            core_1.Utils.runIfNotEmpty(() => col.defaultTo(column.default == null ? null : knex.raw(column.default)), column.default !== undefined);
+            core_1.Utils.runIfNotEmpty(() => col.defaultTo(knex.raw(column.default)), column.default != null && column.default !== 'null');
         }
         return col;
     }
     getPreAlterTable(tableDiff, safe) {
         return '';
     }
-    getAlterColumnAutoincrement(tableName, column) {
+    getAlterColumnAutoincrement(tableName, column, schemaName) {
         return '';
     }
-    getChangeColumnCommentSQL(tableName, to) {
+    getChangeColumnCommentSQL(tableName, to, schemaName) {
         return '';
     }
     async getNamespaces(connection) {

package/schema/SqlSchemaGenerator.d.ts

@@ -1,5 +1,4 @@
-import type { MikroORM, ISchemaGenerator } from '@mikro-orm/core';
-import { AbstractSchemaGenerator } from '@mikro-orm/core';
+import { AbstractSchemaGenerator, type MikroORM, type ISchemaGenerator } from '@mikro-orm/core';
 import type { SchemaDifference } from '../typings';
 import { DatabaseSchema } from './DatabaseSchema';
 import type { AbstractSqlDriver } from '../AbstractSqlDriver';
@@ -8,8 +7,6 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
     private readonly options;
     protected lastEnsuredDatabase?: string;
     static register(orm: MikroORM): void;
-    /** @deprecated use `dropSchema` and `createSchema` commands respectively */
-    generate(): Promise<string>;
     createSchema(options?: {
         wrap?: boolean;
         schema?: string;
@@ -82,10 +79,10 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
      * creates new database and connects to it
      */
     createDatabase(name: string): Promise<void>;
-    dropDatabase(name: string): Promise<void>;
+    dropDatabase(name?: string): Promise<void>;
     execute(sql: string, options?: {
         wrap?: boolean;
-    }): Promise<undefined>;
+    }): Promise<void>;
     private wrapSchema;
     private createSchemaBuilder;
     private createTable;

package/schema/SqlSchemaGenerator.js

@@ -5,22 +5,12 @@ const core_1 = require("@mikro-orm/core");
 const DatabaseSchema_1 = require("./DatabaseSchema");
 const SchemaComparator_1 = require("./SchemaComparator");
 class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
-    constructor() {
-        super(...arguments);
-        this.helper = this.platform.getSchemaHelper();
-        this.options = this.config.get('schemaGenerator');
-    }
+    helper = this.platform.getSchemaHelper();
+    options = this.config.get('schemaGenerator');
+    lastEnsuredDatabase;
     static register(orm) {
         orm.config.registerExtension('@mikro-orm/schema-generator', () => new SqlSchemaGenerator(orm.em));
     }
-    /** @deprecated use `dropSchema` and `createSchema` commands respectively */
-    async generate() {
-        const [dropSchema, createSchema] = await Promise.all([
-            this.getDropSchemaSQL({ wrap: false }),
-            this.getCreateSchemaSQL({ wrap: false }),
-        ]);
-        return this.wrapSchema(dropSchema + createSchema);
-    }
     async createSchema(options) {
         await this.ensureDatabase();
         const sql = await this.getCreateSchemaSQL(options);
@@ -101,7 +91,8 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         await this.ensureDatabase();
         const wrap = options.wrap ?? this.options.disableForeignKeys;
         const metadata = this.getOrderedMetadata(options.schema).reverse();
-        const schema = await DatabaseSchema_1.DatabaseSchema.create(this.connection, this.platform, this.config, options.schema);
+        const schemas = this.getTargetSchema(options.schema).getNamespaces();
+        const schema = await DatabaseSchema_1.DatabaseSchema.create(this.connection, this.platform, this.config, options.schema, schemas);
         let ret = '';
         // remove FKs explicitly if we can't use cascading statement and we don't disable FK checks (we need this for circular relations)
         for (const meta of metadata) {
@@ -118,6 +109,12 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         for (const meta of metadata) {
             ret += await this.dump(this.dropTable(meta.collection, this.getSchemaName(meta, options)), '\n');
         }
+        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');
+            }
+        }
         if (options.dropMigrationsTable) {
             ret += await this.dump(this.dropTable(this.config.get('migrations').tableName, this.config.get('schema')), '\n');
         }
@@ -140,25 +137,29 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         return this.diffToSQL(diffUp, options);
     }
     async getUpdateSchemaMigrationSQL(options = {}) {
-        await this.ensureDatabase();
+        if (!options.fromSchema) {
+            await this.ensureDatabase();
+        }
         const { fromSchema, toSchema } = await this.prepareSchemaForComparison(options);
         const comparator = new SchemaComparator_1.SchemaComparator(this.platform);
         const diffUp = comparator.compare(fromSchema, toSchema);
-        const diffDown = comparator.compare(toSchema, fromSchema);
+        const diffDown = comparator.compare(toSchema, fromSchema, diffUp);
         return {
             up: await this.diffToSQL(diffUp, options),
             down: this.platform.supportsDownMigrations() ? await this.diffToSQL(diffDown, options) : '',
         };
     }
     async prepareSchemaForComparison(options) {
-        options.wrap ?? (options.wrap = this.options.disableForeignKeys);
-        options.safe ?? (options.safe = false);
-        options.dropTables ?? (options.dropTables = true);
+        options.wrap ??= this.options.disableForeignKeys;
+        options.safe ??= false;
+        options.dropTables ??= true;
         const toSchema = this.getTargetSchema(options.schema);
-        const fromSchema = options.fromSchema ?? await DatabaseSchema_1.DatabaseSchema.create(this.connection, this.platform, this.config, options.schema);
+        const schemas = toSchema.getNamespaces();
+        const fromSchema = options.fromSchema ?? await DatabaseSchema_1.DatabaseSchema.create(this.connection, this.platform, this.config, options.schema, schemas);
         const wildcardSchemaTables = Object.values(this.metadata.getAll()).filter(meta => meta.schema === '*').map(meta => meta.tableName);
         fromSchema.prune(options.schema, wildcardSchemaTables);
         toSchema.prune(options.schema, wildcardSchemaTables);
+        toSchema.setNativeEnums(fromSchema.getNativeEnums());
         return { fromSchema, toSchema };
     }
     async diffToSQL(schemaDiff, options) {
@@ -214,7 +215,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         if (schema && schemaName === '*') {
             return `${schema}.${referencedTableName.replace(/^\*\./, '')}`;
         }
-        if (schemaName === this.platform.getDefaultSchemaName()) {
+        if (!schemaName || schemaName === this.platform.getDefaultSchemaName()) {
             return tableName;
         }
         return `${schemaName}.${tableName}`;
@@ -262,6 +263,12 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
     alterTable(diff, safe) {
         const ret = [];
         const [schemaName, tableName] = this.splitTableName(diff.name);
+        const changedNativeEnums = [];
+        for (const { column, changedProperties } of Object.values(diff.changedColumns)) {
+            if (column.nativeEnumName && changedProperties.has('enumItems') && column.nativeEnumName in diff.fromTable.nativeEnums) {
+                changedNativeEnums.push([column.nativeEnumName, column.enumItems, diff.fromTable.getColumn(column.name).enumItems]);
+            }
+        }
         ret.push(this.createSchemaBuilder(schemaName).alterTable(tableName, table => {
             for (const index of Object.values(diff.removedIndexes)) {
                 this.dropIndex(table, index);
@@ -275,6 +282,14 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
             for (const check of Object.values(diff.changedChecks)) {
                 this.dropCheck(table, check);
             }
+            /* istanbul ignore else */
+            if (!safe) {
+                for (const column of Object.values(diff.removedColumns)) {
+                    this.helper.pushTableQuery(table, `alter table ${this.platform.quoteIdentifier(tableName)} drop column ${this.platform.quoteIdentifier(column.name)}`);
+                }
+            }
+        }));
+        ret.push(this.createSchemaBuilder(schemaName).alterTable(tableName, table => {
             for (const column of Object.values(diff.addedColumns)) {
                 const col = this.helper.createTableColumn(table, column, diff.fromTable);
                 this.helper.configureColumn(column, col, this.knex);
@@ -288,27 +303,24 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                         .onDelete(foreignKey.deleteRule);
                 }
             }
-            /* istanbul ignore else */
-            if (!safe) {
-                for (const column of Object.values(diff.removedColumns)) {
-                    table.dropColumn(column.name);
-                }
-            }
             for (const { column, changedProperties } of Object.values(diff.changedColumns)) {
                 if (changedProperties.size === 1 && changedProperties.has('comment')) {
                     continue;
                 }
+                if (changedProperties.size === 1 && changedProperties.has('enumItems') && column.nativeEnumName) {
+                    continue;
+                }
                 const col = this.helper.createTableColumn(table, column, diff.fromTable, changedProperties).alter();
                 this.helper.configureColumn(column, col, this.knex, changedProperties);
             }
             for (const { column } of Object.values(diff.changedColumns).filter(diff => diff.changedProperties.has('autoincrement'))) {
-                this.helper.pushTableQuery(table, this.helper.getAlterColumnAutoincrement(tableName, column));
+                this.helper.pushTableQuery(table, this.helper.getAlterColumnAutoincrement(tableName, column, schemaName));
             }
             for (const { column, changedProperties } of Object.values(diff.changedColumns).filter(diff => diff.changedProperties.has('comment'))) {
                 if (['type', 'nullable', 'autoincrement', 'unsigned', 'default', 'enumItems'].some(t => changedProperties.has(t))) {
                     continue; // will be handled via knex
                 }
-                this.helper.pushTableQuery(table, this.helper.getChangeColumnCommentSQL(tableName, column));
+                this.helper.pushTableQuery(table, this.helper.getChangeColumnCommentSQL(tableName, column, schemaName));
             }
             for (const [oldColumnName, column] of Object.entries(diff.renamedColumns)) {
                 this.helper.pushTableQuery(table, this.helper.getRenameColumnSQL(tableName, oldColumnName, column, schemaName));
@@ -345,6 +357,13 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 table.comment(comment);
             }
         }));
+        if (this.platform.supportsNativeEnums()) {
+            changedNativeEnums.forEach(([enumName, itemsNew, itemsOld]) => {
+                // postgres allows only adding new items
+                const newItems = itemsNew.filter(val => !itemsOld.includes(val));
+                ret.push(...newItems.map(val => this.knex.schema.raw(this.helper.getAlterNativeEnumSQL(enumName, schemaName, val))));
+            });
+        }
         return ret;
     }
     /**
@@ -356,24 +375,26 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         await this.driver.reconnect();
     }
     async dropDatabase(name) {
+        name ??= this.config.get('dbName');
         this.config.set('dbName', this.helper.getManagementDbName());
         await this.driver.reconnect();
         await this.driver.execute(this.helper.getDropDatabaseSQL('' + this.knex.ref(name)));
     }
     async execute(sql, options = {}) {
-        options.wrap ?? (options.wrap = false);
+        options.wrap ??= false;
         const lines = this.wrapSchema(sql, options).split('\n').filter(i => i.trim());
         if (lines.length === 0) {
             return;
         }
         if (this.platform.supportsMultipleStatements()) {
             const query = lines.join('\n');
-            return void await this.driver.execute(query);
+            await this.driver.execute(query);
+            return;
         }
         await core_1.Utils.runSerial(lines, line => this.driver.execute(line));
     }
-    wrapSchema(sql, options = {}) {
-        options.wrap ?? (options.wrap = this.options.disableForeignKeys);
+    wrapSchema(sql, options) {
+        options.wrap ??= this.options.disableForeignKeys;
         if (!options.wrap || sql.trim() === '') {
             return sql;
         }
@@ -423,7 +444,14 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
             table.primary(index.columnNames, keyName);
         }
         else if (index.unique) {
-            table.unique(index.columnNames, { indexName: index.keyName });
+            // 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 });
+            }
         }
         else if (index.expression) {
             this.helper.pushTableQuery(table, index.expression);
@@ -435,14 +463,21 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
             }
         }
         else {
-            table.index(index.columnNames, index.keyName, index.type);
+            // 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);
         }
-        else if (index.unique) {
+        else if (index.unique && index.constraint) {
             table.dropUnique(index.columnNames, oldIndexName);
         }
         else {