@mikro-orm/sql 7.0.7-dev.2 → 7.0.7-dev.20

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -34,12 +34,12 @@ export class SqliteSchemaHelper extends SchemaHelper {
         return (`select name as table_name from sqlite_master where type = 'table' and name != 'sqlite_sequence' and name != 'geometry_columns' and name != 'spatial_ref_sys' ` +
             `union all select name as table_name from sqlite_temp_master where type = 'table' order by name`);
     }
-    async getAllTables(connection, schemas) {
-        const databases = await this.getDatabaseList(connection);
+    async getAllTables(connection, schemas, ctx) {
+        const databases = await this.getDatabaseList(connection, ctx);
         const hasAttachedDbs = databases.length > 1; // More than just 'main'
         // If no attached databases, use original behavior
         if (!hasAttachedDbs && !schemas?.length) {
-            return connection.execute(this.getListTablesSQL());
+            return connection.execute(this.getListTablesSQL(), [], 'all', ctx);
         }
         // With attached databases, query each one
         const targetSchemas = schemas?.length ? schemas : databases;
@@ -47,15 +47,15 @@ export class SqliteSchemaHelper extends SchemaHelper {
         for (const dbName of targetSchemas) {
             const prefix = this.getSchemaPrefix(dbName);
             const tables = await connection.execute(`select name from ${prefix}sqlite_master where type = 'table' ` +
-                `and name != 'sqlite_sequence' and name != 'geometry_columns' and name != 'spatial_ref_sys'`);
+                `and name != 'sqlite_sequence' and name != 'geometry_columns' and name != 'spatial_ref_sys'`, [], 'all', ctx);
             for (const t of tables) {
                 allTables.push({ table_name: t.name, schema_name: dbName });
             }
         }
         return allTables;
     }
-    async getNamespaces(connection) {
-        return this.getDatabaseList(connection);
+    async getNamespaces(connection, ctx) {
+        return this.getDatabaseList(connection, ctx);
     }
     getIgnoredViewsCondition() {
         return SPATIALITE_VIEWS.map(v => `name != '${v}'`).join(' and ');
@@ -63,12 +63,12 @@ export class SqliteSchemaHelper extends SchemaHelper {
     getListViewsSQL() {
         return `select name as view_name, sql as view_definition from sqlite_master where type = 'view' and ${this.getIgnoredViewsCondition()} order by name`;
     }
-    async loadViews(schema, connection, schemaName) {
-        const databases = await this.getDatabaseList(connection);
+    async loadViews(schema, connection, schemaName, ctx) {
+        const databases = await this.getDatabaseList(connection, ctx);
         const hasAttachedDbs = databases.length > 1; // More than just 'main'
         // If no attached databases and no specific schema, use original behavior
         if (!hasAttachedDbs && !schemaName) {
-            const views = await connection.execute(this.getListViewsSQL());
+            const views = await connection.execute(this.getListViewsSQL(), [], 'all', ctx);
             for (const view of views) {
                 schema.addView(view.view_name, schemaName, this.extractViewDefinition(view.view_definition));
             }
@@ -79,7 +79,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
         const targetDbs = schemaName ? [schemaName] : databases;
         for (const dbName of targetDbs) {
             const prefix = this.getSchemaPrefix(dbName);
-            const views = await connection.execute(`select name as view_name, sql as view_definition from ${prefix}sqlite_master where type = 'view' and ${this.getIgnoredViewsCondition()} order by name`);
+            const views = await connection.execute(`select name as view_name, sql as view_definition from ${prefix}sqlite_master where type = 'view' and ${this.getIgnoredViewsCondition()} order by name`, [], 'all', ctx);
             for (const view of views) {
                 schema.addView(view.view_name, dbName, this.extractViewDefinition(view.view_definition));
             }
@@ -92,15 +92,15 @@ export class SqliteSchemaHelper extends SchemaHelper {
         /* v8 ignore next */
         return `drop database if exists ${this.quote(name)}`;
     }
-    async loadInformationSchema(schema, connection, tables, schemas) {
+    async loadInformationSchema(schema, connection, tables, schemas, ctx) {
         for (const t of tables) {
             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);
-            const pks = await this.getPrimaryKeys(connection, indexes, table.name, table.schema);
-            const fks = await this.getForeignKeys(connection, table.name, table.schema);
-            const enums = await this.getEnumDefinitions(connection, table.name, table.schema);
+            const cols = await this.getColumns(connection, table.name, table.schema, ctx);
+            const indexes = await this.getIndexes(connection, table.name, table.schema, ctx);
+            const checks = await this.getChecks(connection, table.name, table.schema, ctx);
+            const pks = await this.getPrimaryKeys(connection, indexes, table.name, table.schema, ctx);
+            const fks = await this.getForeignKeys(connection, table.name, table.schema, ctx);
+            const enums = await this.getEnumDefinitions(connection, table.name, table.schema, ctx);
             table.init(cols, indexes, checks, pks, fks, enums);
         }
     }
@@ -252,8 +252,8 @@ export class SqliteSchemaHelper extends SchemaHelper {
     /**
      * Returns all database names excluding 'temp'.
      */
-    async getDatabaseList(connection) {
-        const databases = await connection.execute('pragma database_list');
+    async getDatabaseList(connection, ctx) {
+        const databases = await connection.execute('pragma database_list', [], 'all', ctx);
         return databases.filter(d => d.name !== 'temp').map(d => d.name);
     }
     /**
@@ -264,11 +264,11 @@ export class SqliteSchemaHelper extends SchemaHelper {
         /* v8 ignore next - fallback for non-standard view definitions */
         return match ? match[1] : viewDefinition;
     }
-    async getColumns(connection, tableName, schemaName) {
+    async getColumns(connection, tableName, schemaName, ctx) {
         const prefix = this.getSchemaPrefix(schemaName);
-        const columns = await connection.execute(`pragma ${prefix}table_xinfo('${tableName}')`);
+        const columns = await connection.execute(`pragma ${prefix}table_xinfo('${tableName}')`, [], 'all', ctx);
         const sql = `select sql from ${prefix}sqlite_master where type = ? and name = ?`;
-        const tableDefinition = await connection.execute(sql, ['table', tableName], 'get');
+        const tableDefinition = await connection.execute(sql, ['table', tableName], 'get', ctx);
         const composite = columns.reduce((count, col) => count + (col.pk ? 1 : 0), 0) > 1;
         // there can be only one, so naive check like this should be enough
         const hasAutoincrement = tableDefinition.sql.toLowerCase().includes('autoincrement');
@@ -321,10 +321,10 @@ export class SqliteSchemaHelper extends SchemaHelper {
         // everything else is an expression that had its outer parens stripped
         return `(${value})`;
     }
-    async getEnumDefinitions(connection, tableName, schemaName) {
+    async getEnumDefinitions(connection, tableName, schemaName, ctx) {
         const prefix = this.getSchemaPrefix(schemaName);
         const sql = `select sql from ${prefix}sqlite_master where type = ? and name = ?`;
-        const tableDefinition = await connection.execute(sql, ['table', tableName], 'get');
+        const tableDefinition = await connection.execute(sql, ['table', tableName], 'get', ctx);
         const checkConstraints = [...(tableDefinition.sql.match(/[`["'][^`\]"']+[`\]"'] text check \(.*?\)/gi) ?? [])];
         return checkConstraints.reduce((o, item) => {
             // check constraints are defined as (note that last closing paren is missing):
@@ -339,17 +339,17 @@ export class SqliteSchemaHelper extends SchemaHelper {
             return o;
         }, {});
     }
-    async getPrimaryKeys(connection, indexes, tableName, schemaName) {
+    async getPrimaryKeys(connection, indexes, tableName, schemaName, ctx) {
         const prefix = this.getSchemaPrefix(schemaName);
         const sql = `pragma ${prefix}table_info(\`${tableName}\`)`;
-        const cols = await connection.execute(sql);
+        const cols = await connection.execute(sql, [], 'all', ctx);
         return cols.filter(col => !!col.pk).map(col => col.name);
     }
-    async getIndexes(connection, tableName, schemaName) {
+    async getIndexes(connection, tableName, schemaName, ctx) {
         const prefix = this.getSchemaPrefix(schemaName);
         const sql = `pragma ${prefix}table_info(\`${tableName}\`)`;
-        const cols = await connection.execute(sql);
-        const indexes = await connection.execute(`pragma ${prefix}index_list(\`${tableName}\`)`);
+        const cols = await connection.execute(sql, [], 'all', ctx);
+        const indexes = await connection.execute(`pragma ${prefix}index_list(\`${tableName}\`)`, [], 'all', ctx);
         const ret = [];
         for (const col of cols.filter(c => c.pk)) {
             ret.push({
@@ -361,7 +361,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
             });
         }
         for (const index of indexes.filter(index => !this.isImplicitIndex(index.name))) {
-            const res = await connection.execute(`pragma ${prefix}index_info(\`${index.name}\`)`);
+            const res = await connection.execute(`pragma ${prefix}index_info(\`${index.name}\`)`, [], 'all', ctx);
             ret.push(...res.map(row => ({
                 columnNames: [row.name],
                 keyName: index.name,
@@ -372,8 +372,8 @@ export class SqliteSchemaHelper extends SchemaHelper {
         }
         return this.mapIndexes(ret);
     }
-    async getChecks(connection, tableName, schemaName) {
-        const { columns, constraints } = await this.getColumnDefinitions(connection, tableName, schemaName);
+    async getChecks(connection, tableName, schemaName, ctx) {
+        const { columns, constraints } = await this.getColumnDefinitions(connection, tableName, schemaName, ctx);
         const checks = [];
         for (const key of Object.keys(columns)) {
             const column = columns[key];
@@ -399,17 +399,17 @@ export class SqliteSchemaHelper extends SchemaHelper {
         }
         return checks;
     }
-    async getColumnDefinitions(connection, tableName, schemaName) {
+    async getColumnDefinitions(connection, tableName, schemaName, ctx) {
         const prefix = this.getSchemaPrefix(schemaName);
-        const columns = await connection.execute(`pragma ${prefix}table_xinfo('${tableName}')`);
+        const columns = await connection.execute(`pragma ${prefix}table_xinfo('${tableName}')`, [], 'all', ctx);
         const sql = `select sql from ${prefix}sqlite_master where type = ? and name = ?`;
-        const tableDefinition = await connection.execute(sql, ['table', tableName], 'get');
+        const tableDefinition = await connection.execute(sql, ['table', tableName], 'get', ctx);
         return this.parseTableDefinition(tableDefinition.sql, columns);
     }
-    async getForeignKeys(connection, tableName, schemaName) {
-        const { constraints } = await this.getColumnDefinitions(connection, tableName, schemaName);
+    async getForeignKeys(connection, tableName, schemaName, ctx) {
+        const { constraints } = await this.getColumnDefinitions(connection, tableName, schemaName, ctx);
         const prefix = this.getSchemaPrefix(schemaName);
-        const fks = await connection.execute(`pragma ${prefix}foreign_key_list(\`${tableName}\`)`);
+        const fks = await connection.execute(`pragma ${prefix}foreign_key_list(\`${tableName}\`)`, [], 'all', ctx);
         const qualifiedTableName = schemaName ? `${schemaName}.${tableName}` : tableName;
         return fks.reduce((ret, fk) => {
             const constraintName = this.platform.getIndexName(tableName, [fk.from], 'foreign');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.7-dev.2",
+  "version": "7.0.7-dev.20",
   "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.",
   "keywords": [
     "data-mapper",
@@ -47,13 +47,13 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "kysely": "0.28.14"
+    "kysely": "0.28.15"
   },
   "devDependencies": {
     "@mikro-orm/core": "^7.0.6"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.7-dev.2"
+    "@mikro-orm/core": "7.0.7-dev.20"
   },
   "engines": {
     "node": ">= 22.17.0"

package/query/NativeQueryBuilder.d.ts

@@ -121,7 +121,9 @@ export declare class NativeQueryBuilder implements Subquery {
     as(alias: string): this;
     toRaw(): RawQueryFragment;
     protected compileSelect(): void;
-    protected getFields(): string;
+    /** Whether this COUNT query needs a subquery wrapper for multi-column distinct. */
+    protected needsCountSubquery(): boolean;
+    protected getFields(countSubquery?: boolean): string;
     protected compileInsert(): void;
     protected addOutputClause(type: 'inserted' | 'deleted'): void;
     protected processInsertData(): string[];

package/query/NativeQueryBuilder.js

@@ -281,9 +281,13 @@ export class NativeQueryBuilder {
         return raw(sql, params);
     }
     compileSelect() {
+        const wrapCountSubquery = this.needsCountSubquery();
+        if (wrapCountSubquery) {
+            this.parts.push(`select count(*) as ${this.quote('count')} from (`);
+        }
         this.parts.push('select');
         this.addHintComment();
-        this.parts.push(`${this.getFields()} from ${this.getTableName()}`);
+        this.parts.push(`${this.getFields(wrapCountSubquery)} from ${this.getTableName()}`);
         if (this.options.joins) {
             for (const join of this.options.joins) {
                 this.parts.push(join.sql);
@@ -302,23 +306,40 @@ export class NativeQueryBuilder {
             this.parts.push(`having ${this.options.having.sql}`);
             this.params.push(...this.options.having.params);
         }
-        if (this.options.orderBy) {
-            this.parts.push(`order by ${this.options.orderBy}`);
-        }
-        if (this.options.limit != null) {
-            this.parts.push(`limit ?`);
-            this.params.push(this.options.limit);
+        if (!wrapCountSubquery) {
+            if (this.options.orderBy) {
+                this.parts.push(`order by ${this.options.orderBy}`);
+            }
+            if (this.options.limit != null) {
+                this.parts.push(`limit ?`);
+                this.params.push(this.options.limit);
+            }
+            if (this.options.offset != null) {
+                this.parts.push(`offset ?`);
+                this.params.push(this.options.offset);
+            }
         }
-        if (this.options.offset != null) {
-            this.parts.push(`offset ?`);
-            this.params.push(this.options.offset);
+        if (wrapCountSubquery) {
+            const asKeyword = this.platform.usesAsKeyword() ? ' as ' : ' ';
+            this.parts.push(`)${asKeyword}${this.quote('dcnt')}`);
         }
     }
-    getFields() {
+    /** Whether this COUNT query needs a subquery wrapper for multi-column distinct. */
+    needsCountSubquery() {
+        return (this.type === QueryType.COUNT &&
+            !!this.options.distinct &&
+            this.options.select.length > 1 &&
+            !this.platform.supportsMultiColumnCountDistinct());
+    }
+    getFields(countSubquery) {
         if (!this.options.select || this.options.select.length === 0) {
             throw new Error('No fields selected');
         }
         let fields = this.options.select.map(field => this.quote(field)).join(', ');
+        // count subquery emits just `distinct col1, col2` — the outer wrapper adds count(*)
+        if (countSubquery) {
+            return `distinct ${fields}`;
+        }
         if (this.options.distinct) {
             fields = `distinct ${fields}`;
         }

package/query/QueryBuilderHelper.js

@@ -572,7 +572,7 @@ export class QueryBuilderHelper {
         else if (value[op] instanceof Raw || typeof value[op]?.toRaw === 'function') {
             const query = value[op] instanceof Raw ? value[op] : value[op].toRaw();
             const mappedKey = this.mapper(key, type, query, null);
-            let sql = query.sql;
+            let sql = query.sql.replaceAll(ALIAS_REPLACEMENT, this.#alias);
             if (['$in', '$nin'].includes(op)) {
                 sql = `(${sql})`;
             }

package/schema/DatabaseSchema.d.ts

@@ -1,4 +1,4 @@
-import { type Configuration, type Dictionary, type EntityMetadata } from '@mikro-orm/core';
+import { type Configuration, type Dictionary, type EntityMetadata, type Transaction } from '@mikro-orm/core';
 import { DatabaseTable } from './DatabaseTable.js';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection.js';
 import type { DatabaseView } from '../typings.js';
@@ -42,7 +42,7 @@ export declare class DatabaseSchema {
     hasNamespace(namespace: string): boolean;
     hasNativeEnum(name: string): boolean;
     getNamespaces(): string[];
-    static create(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, schemas?: string[], takeTables?: (string | RegExp)[], skipTables?: (string | RegExp)[], skipViews?: (string | RegExp)[]): Promise<DatabaseSchema>;
+    static create(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, schemas?: string[], takeTables?: (string | RegExp)[], skipTables?: (string | RegExp)[], skipViews?: (string | RegExp)[], ctx?: Transaction): Promise<DatabaseSchema>;
     static fromMetadata(metadata: EntityMetadata[], platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, em?: any): DatabaseSchema;
     private static getViewDefinition;
     private static getSchemaName;

package/schema/DatabaseSchema.js

@@ -87,9 +87,9 @@ export class DatabaseSchema {
     getNamespaces() {
         return [...this.#namespaces];
     }
-    static async create(connection, platform, config, schemaName, schemas, takeTables, skipTables, skipViews) {
+    static async create(connection, platform, config, schemaName, schemas, takeTables, skipTables, skipViews, ctx) {
         const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema') ?? platform.getDefaultSchemaName());
-        const allTables = await platform.getSchemaHelper().getAllTables(connection, schemas);
+        const allTables = await platform.getSchemaHelper().getAllTables(connection, schemas, ctx);
         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());
@@ -97,12 +97,12 @@ export class DatabaseSchema {
             (t.table_name !== migrationsTableName || (t.schema_name && t.schema_name !== migrationsSchemaName)));
         await platform
             .getSchemaHelper()
-            .loadInformationSchema(schema, connection, tables, schemas && schemas.length > 0 ? schemas : undefined);
+            .loadInformationSchema(schema, connection, tables, schemas && schemas.length > 0 ? schemas : undefined, ctx);
         // Load views from database
-        await platform.getSchemaHelper().loadViews(schema, connection);
+        await platform.getSchemaHelper().loadViews(schema, connection, schemaName, ctx);
         // Load materialized views (PostgreSQL only)
         if (platform.supportsMaterializedViews()) {
-            await platform.getSchemaHelper().loadMaterializedViews(schema, connection, schemaName);
+            await platform.getSchemaHelper().loadMaterializedViews(schema, connection, schemaName, ctx);
         }
         // Filter out skipped views
         if (skipViews && skipViews.length > 0) {
@@ -147,7 +147,27 @@ export class DatabaseSchema {
             if (meta.view) {
                 const viewDefinition = this.getViewDefinition(meta, em, platform);
                 if (viewDefinition) {
-                    schema.addView(meta.collection, this.getSchemaName(meta, config, schemaName), viewDefinition, meta.materialized, meta.withData);
+                    const view = schema.addView(meta.collection, this.getSchemaName(meta, config, schemaName), viewDefinition, meta.materialized, meta.withData);
+                    if (meta.materialized) {
+                        // Use a DatabaseTable to resolve property names → field names for indexes.
+                        // addIndex only needs meta + table name, not actual columns.
+                        const indexTable = new DatabaseTable(platform, meta.collection, this.getSchemaName(meta, config, schemaName));
+                        meta.indexes.forEach(index => indexTable.addIndex(meta, index, 'index'));
+                        meta.uniques.forEach(index => indexTable.addIndex(meta, index, 'unique'));
+                        const pkProps = meta.props.filter(prop => prop.primary);
+                        indexTable.addIndex(meta, { properties: pkProps.map(prop => prop.name) }, 'primary');
+                        // Materialized views don't have primary keys or constraints in the DB,
+                        // convert to match what PostgreSQL stores.
+                        view.indexes = indexTable.getIndexes().map(idx => {
+                            if (idx.primary) {
+                                return { ...idx, primary: false, unique: true, constraint: false };
+                            }
+                            if (idx.constraint) {
+                                return { ...idx, constraint: false };
+                            }
+                            return idx;
+                        });
+                    }
                 }
                 continue;
             }

package/schema/SchemaComparator.d.ts

@@ -1,7 +1,7 @@
 import { type Dictionary } from '@mikro-orm/core';
 import type { Column, ForeignKey, IndexDef, SchemaDifference, TableDifference } from '../typings.js';
 import type { DatabaseSchema } from './DatabaseSchema.js';
-import type { DatabaseTable } from './DatabaseTable.js';
+import { DatabaseTable } from './DatabaseTable.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 /**
  * Compares two Schemas and return an instance of SchemaDifference.

package/schema/SchemaComparator.js

@@ -1,4 +1,5 @@
 import { ArrayType, BooleanType, DateTimeType, inspect, JsonType, parseJsonSafe, Utils, } from '@mikro-orm/core';
+import { DatabaseTable } from './DatabaseTable.js';
 /**
  * Compares two Schemas and return an instance of SchemaDifference.
  */
@@ -114,15 +115,16 @@ export class SchemaComparator {
                 }
             }
         }
-        // Compare views
+        // Compare views — prefer schema-qualified lookup to avoid matching
+        // views with the same name in different schemas
         for (const toView of toSchema.getViews()) {
             const viewName = toView.schema ? `${toView.schema}.${toView.name}` : toView.name;
-            if (!fromSchema.hasView(toView.name) && !fromSchema.hasView(viewName)) {
+            if (!fromSchema.hasView(viewName) && !fromSchema.hasView(toView.name)) {
                 diff.newViews[viewName] = toView;
                 this.log(`view ${viewName} added`);
             }
             else {
-                const fromView = fromSchema.getView(toView.name) ?? fromSchema.getView(viewName);
+                const fromView = fromSchema.getView(viewName) ?? fromSchema.getView(toView.name);
                 if (fromView && this.diffViewExpression(fromView.definition, toView.definition)) {
                     diff.changedViews[viewName] = { from: fromView, to: toView };
                     this.log(`view ${viewName} changed`);
@@ -132,11 +134,34 @@ export class SchemaComparator {
         // Check for removed views
         for (const fromView of fromSchema.getViews()) {
             const viewName = fromView.schema ? `${fromView.schema}.${fromView.name}` : fromView.name;
-            if (!toSchema.hasView(fromView.name) && !toSchema.hasView(viewName)) {
+            if (!toSchema.hasView(viewName) && !toSchema.hasView(fromView.name)) {
                 diff.removedViews[viewName] = fromView;
                 this.log(`view ${viewName} removed`);
             }
         }
+        // Diff materialized view indexes using the existing table diff infrastructure.
+        // Build transient DatabaseTable objects from view indexes so diffTable handles
+        // added/removed/changed/renamed index detection and alterTable emits correct DDL.
+        for (const toView of toSchema.getViews()) {
+            if (!toView.materialized || toView.withData === false) {
+                continue;
+            }
+            const viewName = toView.schema ? `${toView.schema}.${toView.name}` : toView.name;
+            // New or definition-changed views have indexes handled during create/recreate
+            if (diff.newViews[viewName] || diff.changedViews[viewName]) {
+                continue;
+            }
+            // If we get here, the view exists in fromSchema (otherwise it would be in diff.newViews)
+            const fromView = fromSchema.getView(viewName) ?? fromSchema.getView(toView.name);
+            const fromTable = new DatabaseTable(this.#platform, fromView.name, fromView.schema);
+            fromTable.init([], fromView.indexes ?? [], [], []);
+            const toTable = new DatabaseTable(this.#platform, toView.name, toView.schema);
+            toTable.init([], toView.indexes ?? [], [], []);
+            const tableDiff = this.diffTable(fromTable, toTable);
+            if (tableDiff) {
+                diff.changedTables[viewName] = tableDiff;
+            }
+        }
         return diff;
     }
     /**

package/schema/SchemaHelper.d.ts

@@ -1,4 +1,4 @@
-import { type Connection, type Dictionary, type Options, RawQueryFragment } from '@mikro-orm/core';
+import { type Connection, type Dictionary, type Options, type Transaction, RawQueryFragment } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../typings.js';
@@ -26,13 +26,13 @@ export declare abstract class SchemaHelper {
     getDropNativeEnumSQL(name: string, schema?: string): string;
     getAlterNativeEnumSQL(name: string, schema?: string, value?: string, items?: string[], oldItems?: string[]): string;
     /** Loads table metadata (columns, indexes, foreign keys) from the database information schema. */
-    abstract loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
+    abstract loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[], ctx?: Transaction): Promise<void>;
     /** Returns the SQL query to list all tables in the database. */
     getListTablesSQL(): string;
     /** Retrieves all tables from the database. */
-    getAllTables(connection: AbstractSqlConnection, schemas?: string[]): Promise<Table[]>;
+    getAllTables(connection: AbstractSqlConnection, schemas?: string[], ctx?: Transaction): Promise<Table[]>;
     getListViewsSQL(): string;
-    loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string): Promise<void>;
+    loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string, ctx?: Transaction): Promise<void>;
     /** Returns SQL to rename a column in a table. */
     getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column, schemaName?: string): string;
     /** Returns SQL to create an index on a table. */
@@ -61,7 +61,7 @@ export declare abstract class SchemaHelper {
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string[];
     getPostAlterTable(tableDiff: TableDifference, safe: boolean): string[];
     getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
-    getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
+    getNamespaces(connection: AbstractSqlConnection, ctx?: Transaction): Promise<string[]>;
     protected mapIndexes(indexes: IndexDef[]): Promise<IndexDef[]>;
     mapForeignKeys(fks: any[], tableName: string, schemaName?: string): Dictionary;
     normalizeDefaultValue(defaultValue: string | RawQueryFragment, length?: number, defaultValues?: Dictionary<string[]>): string | number;
@@ -84,7 +84,8 @@ export declare abstract class SchemaHelper {
     getReferencedTableName(referencedTableName: string, schema?: string): string;
     createIndex(index: IndexDef, table: DatabaseTable, createPrimary?: boolean): string;
     createCheck(table: DatabaseTable, check: CheckDef): string;
-    protected getTableName(table: string, schema?: string): string;
+    /** @internal */
+    getTableName(table: string, schema?: string): string;
     getTablesGroupedBySchemas(tables: Table[]): Map<string | undefined, Table[]>;
     get options(): NonNullable<Options['schemaGenerator']>;
     protected processComment(comment: string): string;
@@ -100,5 +101,5 @@ export declare abstract class SchemaHelper {
     dropMaterializedViewIfExists(name: string, schema?: string): string;
     refreshMaterializedView(name: string, schema?: string, concurrently?: boolean): string;
     getListMaterializedViewsSQL(): string;
-    loadMaterializedViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string): Promise<void>;
+    loadMaterializedViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string, ctx?: Transaction): Promise<void>;
 }

package/schema/SchemaHelper.js

@@ -1,4 +1,4 @@
-import { RawQueryFragment, Utils } from '@mikro-orm/core';
+import { RawQueryFragment, Utils, } from '@mikro-orm/core';
 /** Base class for database-specific schema helpers. Provides SQL generation for DDL operations. */
 export class SchemaHelper {
     platform;
@@ -72,13 +72,13 @@ export class SchemaHelper {
         throw new Error('Not supported by given driver');
     }
     /** Retrieves all tables from the database. */
-    async getAllTables(connection, schemas) {
-        return connection.execute(this.getListTablesSQL());
+    async getAllTables(connection, schemas, ctx) {
+        return connection.execute(this.getListTablesSQL(), [], 'all', ctx);
     }
     getListViewsSQL() {
         throw new Error('Not supported by given driver');
     }
-    async loadViews(schema, connection, schemaName) {
+    async loadViews(schema, connection, schemaName, ctx) {
         throw new Error('Not supported by given driver');
     }
     /** Returns SQL to rename a column in a table. */
@@ -302,7 +302,14 @@ export class SchemaHelper {
         if (changedProperties.has('type')) {
             let type = column.type + (column.generated ? ` generated always as ${column.generated}` : '');
             if (column.nativeEnumName) {
-                type = this.quote(this.getTableName(type, table.schema));
+                const parts = type.split('.');
+                if (parts.length === 2 && parts[0] === '*' && table.schema) {
+                    type = `${table.schema}.${parts[1]}`;
+                }
+                else if (parts.length === 1) {
+                    type = this.getTableName(type, table.schema);
+                }
+                type = this.quote(type);
             }
             sql.push(`alter table ${table.getQuotedName()} alter column ${this.quote(column.name)} type ${type + this.castColumn(column.name, type)}`);
         }
@@ -362,7 +369,7 @@ export class SchemaHelper {
     getChangeColumnCommentSQL(tableName, to, schemaName) {
         return '';
     }
-    async getNamespaces(connection) {
+    async getNamespaces(connection, ctx) {
         return [];
     }
     async mapIndexes(indexes) {
@@ -593,6 +600,7 @@ export class SchemaHelper {
     createCheck(table, check) {
         return `alter table ${table.getQuotedName()} add constraint ${this.quote(check.name)} check (${check.expression})`;
     }
+    /** @internal */
     getTableName(table, schema) {
         if (schema && schema !== this.platform.getDefaultSchemaName()) {
             return `${schema}.${table}`;
@@ -662,7 +670,7 @@ export class SchemaHelper {
     getListMaterializedViewsSQL() {
         throw new Error('Not supported by given driver');
     }
-    async loadMaterializedViews(schema, connection, schemaName) {
+    async loadMaterializedViews(schema, connection, schemaName, ctx) {
         throw new Error('Not supported by given driver');
     }
 }

package/schema/SqlSchemaGenerator.d.ts

@@ -62,6 +62,7 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
      * Uses topological sort based on view definition string matching.
      */
     private sortViewsByDependencies;
+    private appendViewCreation;
     private escapeRegExp;
 }
 export { SqlSchemaGenerator as SchemaGenerator };