@mikro-orm/sql 7.0.7-dev.9 → 7.0.8-dev.0

package/AbstractSqlDriver.js

@@ -900,10 +900,10 @@ export class AbstractSqlDriver extends DatabaseDriver {
         sql = sql.substring(0, sql.length - 2) + ' where ';
         const pkProps = meta.primaryKeys.concat(...meta.concurrencyCheckKeys);
         const pks = Utils.flatten(pkProps.map(pk => meta.properties[pk].fieldNames));
-        sql +=
-            pks.length > 1
-                ? `(${pks.map(pk => this.platform.quoteIdentifier(pk)).join(', ')})`
-                : this.platform.quoteIdentifier(pks[0]);
+        const useTupleIn = pks.length <= 1 || this.platform.allowsComparingTuples();
+        const condTemplate = useTupleIn
+            ? `(${pks.map(() => '?').join(', ')})`
+            : `(${pks.map(pk => `${this.platform.quoteIdentifier(pk)} = ?`).join(' and ')})`;
         const conds = where.map(cond => {
             if (Utils.isPlainObject(cond) && Utils.getObjectKeysSize(cond) === 1) {
                 cond = Object.values(cond)[0];
@@ -917,12 +917,21 @@ export class AbstractSqlDriver extends DatabaseDriver {
                         params.push(cond[pk]);
                     }
                 });
-                return `(${Array.from({ length: pks.length }).fill('?').join(', ')})`;
+                return condTemplate;
             }
             params.push(cond);
             return '?';
         });
-        sql += ` in (${conds.join(', ')})`;
+        if (useTupleIn) {
+            sql +=
+                pks.length > 1
+                    ? `(${pks.map(pk => this.platform.quoteIdentifier(pk)).join(', ')})`
+                    : this.platform.quoteIdentifier(pks[0]);
+            sql += ` in (${conds.join(', ')})`;
+        }
+        else {
+            sql += conds.join(' or ');
+        }
         if (this.platform.usesReturningStatement() && returning.size > 0) {
             const returningFields = Utils.flatten([...returning].map(prop => meta.properties[prop].fieldNames));
             /* v8 ignore next */

package/dialects/mysql/MySqlSchemaHelper.d.ts

@@ -1,4 +1,4 @@
-import { type Dictionary, type Type } from '@mikro-orm/core';
+import { type Dictionary, type Transaction, type Type } from '@mikro-orm/core';
 import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../../typings.js';
 import type { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
@@ -17,9 +17,9 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
     finalizeTable(table: DatabaseTable, charset: string, collate?: string): string;
     getListTablesSQL(): string;
     getListViewsSQL(): string;
-    loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string): Promise<void>;
-    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[]): Promise<void>;
-    getAllIndexes(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<IndexDef[]>>;
+    loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string, ctx?: Transaction): Promise<void>;
+    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[], ctx?: Transaction): Promise<void>;
+    getAllIndexes(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<IndexDef[]>>;
     getCreateIndexSQL(tableName: string, index: IndexDef, partialExpression?: boolean): string;
     /**
      * Build the column list for a MySQL index, with MySQL-specific handling for collation.
@@ -30,16 +30,16 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
      * Append MySQL-specific index suffixes like INVISIBLE.
      */
     protected appendMySqlIndexSuffix(sql: string, index: IndexDef): string;
-    getAllColumns(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Column[]>>;
-    getAllChecks(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<CheckDef[]>>;
-    getAllForeignKeys(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Dictionary<ForeignKey>>>;
+    getAllColumns(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<Column[]>>;
+    getAllChecks(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<CheckDef[]>>;
+    getAllForeignKeys(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<Dictionary<ForeignKey>>>;
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string[];
     getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column): string;
     getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string[];
     getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
     alterTableColumn(column: Column, table: DatabaseTable, changedProperties: Set<string>): string[];
     private getColumnDeclarationSQL;
-    getAllEnumDefinitions(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Dictionary<string[]>>>;
+    getAllEnumDefinitions(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<Dictionary<string[]>>>;
     private supportsCheckConstraints;
     protected getChecksSQL(tables: Table[]): string;
     normalizeDefaultValue(defaultValue: string, length: number): string | number;

package/dialects/mysql/MySqlSchemaHelper.js

@@ -36,14 +36,14 @@ export class MySqlSchemaHelper extends SchemaHelper {
     getListViewsSQL() {
         return `select table_name as view_name, nullif(table_schema, schema()) as schema_name, view_definition from information_schema.views where table_schema = schema()`;
     }
-    async loadViews(schema, connection, schemaName) {
-        const views = await connection.execute(this.getListViewsSQL());
+    async loadViews(schema, connection, schemaName, ctx) {
+        const views = await connection.execute(this.getListViewsSQL(), [], 'all', ctx);
         for (const view of views) {
             // MySQL information_schema.views.view_definition requires SHOW VIEW privilege
             // and may return NULL. Use SHOW CREATE VIEW as fallback.
             let definition = view.view_definition?.trim();
             if (!definition) {
-                const createView = await connection.execute(`show create view \`${view.view_name}\``);
+                const createView = await connection.execute(`show create view \`${view.view_name}\``, [], 'all', ctx);
                 if (createView[0]?.['Create View']) {
                     // Extract SELECT statement from CREATE VIEW ... AS SELECT ...
                     const match = /\bAS\s+(.+)$/is.exec(createView[0]['Create View']);
@@ -55,15 +55,15 @@ export class MySqlSchemaHelper extends SchemaHelper {
             }
         }
     }
-    async loadInformationSchema(schema, connection, tables) {
+    async loadInformationSchema(schema, connection, tables, schemas, ctx) {
         if (tables.length === 0) {
             return;
         }
-        const columns = await this.getAllColumns(connection, tables);
-        const indexes = await this.getAllIndexes(connection, tables);
-        const checks = await this.getAllChecks(connection, tables);
-        const fks = await this.getAllForeignKeys(connection, tables);
-        const enums = await this.getAllEnumDefinitions(connection, tables);
+        const columns = await this.getAllColumns(connection, tables, ctx);
+        const indexes = await this.getAllIndexes(connection, tables, ctx);
+        const checks = await this.getAllChecks(connection, tables, ctx);
+        const fks = await this.getAllForeignKeys(connection, tables, ctx);
+        const enums = await this.getAllEnumDefinitions(connection, tables, ctx);
         for (const t of tables) {
             const key = this.getTableKey(t);
             const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
@@ -71,12 +71,12 @@ export class MySqlSchemaHelper extends SchemaHelper {
             table.init(columns[key], indexes[key], checks[key], pks, fks[key], enums[key]);
         }
     }
-    async getAllIndexes(connection, tables) {
+    async getAllIndexes(connection, tables, ctx) {
         const sql = `select table_name as table_name, nullif(table_schema, schema()) as schema_name, index_name as index_name, non_unique as non_unique, column_name as column_name, index_type as index_type, sub_part as sub_part, collation as sort_order /*!80013 , expression as expression, is_visible as is_visible */
         from information_schema.statistics where table_schema = database()
         and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(', ')})
         order by schema_name, table_name, index_name, seq_in_index`;
-        const allIndexes = await connection.execute(sql);
+        const allIndexes = await connection.execute(sql, [], 'all', ctx);
         const ret = {};
         for (const index of allIndexes) {
             const key = this.getTableKey(index);
@@ -191,7 +191,7 @@ export class MySqlSchemaHelper extends SchemaHelper {
         }
         return sql;
     }
-    async getAllColumns(connection, tables) {
+    async getAllColumns(connection, tables, ctx) {
         const sql = `select table_name as table_name,
       nullif(table_schema, schema()) as schema_name,
       column_name as column_name,
@@ -208,7 +208,7 @@ export class MySqlSchemaHelper extends SchemaHelper {
       ifnull(datetime_precision, character_maximum_length) length
       from information_schema.columns where table_schema = database() and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name))})
       order by ordinal_position`;
-        const allColumns = await connection.execute(sql);
+        const allColumns = await connection.execute(sql, [], 'all', ctx);
         const str = (val) => (val != null ? '' + val : val);
         const extra = (val) => val.replace(/auto_increment|default_generated|(stored|virtual) generated/i, '').trim() || undefined;
         const ret = {};
@@ -244,13 +244,13 @@ export class MySqlSchemaHelper extends SchemaHelper {
         }
         return ret;
     }
-    async getAllChecks(connection, tables) {
+    async getAllChecks(connection, tables, ctx) {
         /* v8 ignore next */
-        if (!(await this.supportsCheckConstraints(connection))) {
+        if (!(await this.supportsCheckConstraints(connection, ctx))) {
             return {};
         }
         const sql = this.getChecksSQL(tables);
-        const allChecks = await connection.execute(sql);
+        const allChecks = await connection.execute(sql, [], 'all', ctx);
         const ret = {};
         for (const check of allChecks) {
             const key = this.getTableKey(check);
@@ -264,14 +264,14 @@ export class MySqlSchemaHelper extends SchemaHelper {
         }
         return ret;
     }
-    async getAllForeignKeys(connection, tables) {
+    async getAllForeignKeys(connection, tables, ctx) {
         const sql = `select k.constraint_name as constraint_name, nullif(k.table_schema, schema()) as schema_name, k.table_name as table_name, k.column_name as column_name, k.referenced_table_name as referenced_table_name, k.referenced_column_name as referenced_column_name, c.update_rule as update_rule, c.delete_rule as delete_rule
         from information_schema.key_column_usage k
         inner join information_schema.referential_constraints c on c.constraint_name = k.constraint_name and c.table_name = k.table_name
         where k.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(', ')})
         and k.table_schema = database() and c.constraint_schema = database() and k.referenced_column_name is not null
         order by constraint_name, k.ordinal_position`;
-        const allFks = await connection.execute(sql);
+        const allFks = await connection.execute(sql, [], 'all', ctx);
         const ret = {};
         for (const fk of allFks) {
             const key = this.getTableKey(fk);
@@ -329,11 +329,11 @@ export class MySqlSchemaHelper extends SchemaHelper {
         ret += col.comment ? ` comment ${this.platform.quoteValue(col.comment)}` : '';
         return ret;
     }
-    async getAllEnumDefinitions(connection, tables) {
+    async getAllEnumDefinitions(connection, tables, ctx) {
         const sql = `select column_name as column_name, column_type as column_type, table_name as table_name
       from information_schema.columns
       where data_type = 'enum' and table_name in (${tables.map(t => `'${t.table_name}'`).join(', ')}) and table_schema = database()`;
-        const enums = await connection.execute(sql);
+        const enums = await connection.execute(sql, [], 'all', ctx);
         return enums.reduce((o, item) => {
             o[item.table_name] ??= {};
             o[item.table_name][item.column_name] = item.column_type
@@ -343,12 +343,12 @@ export class MySqlSchemaHelper extends SchemaHelper {
             return o;
         }, {});
     }
-    async supportsCheckConstraints(connection) {
+    async supportsCheckConstraints(connection, ctx) {
         if (this.#cache.supportsCheckConstraints != null) {
             return this.#cache.supportsCheckConstraints;
         }
         const sql = `select 1 from information_schema.tables where table_name = 'CHECK_CONSTRAINTS' and table_schema = 'information_schema'`;
-        const res = await connection.execute(sql);
+        const res = await connection.execute(sql, [], 'all', ctx);
         return (this.#cache.supportsCheckConstraints = res.length > 0);
     }
     getChecksSQL(tables) {

package/dialects/postgresql/PostgreSqlSchemaHelper.d.ts

@@ -1,4 +1,4 @@
-import { type Dictionary } from '@mikro-orm/core';
+import { type Dictionary, type Transaction } from '@mikro-orm/core';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
 import type { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
 import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../../typings.js';
@@ -19,16 +19,16 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     getListTablesSQL(): string;
     private getIgnoredViewsCondition;
     getListViewsSQL(): string;
-    loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection): Promise<void>;
+    loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string, ctx?: Transaction): Promise<void>;
     getListMaterializedViewsSQL(): string;
-    loadMaterializedViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string): Promise<void>;
+    loadMaterializedViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string, ctx?: Transaction): Promise<void>;
     createMaterializedView(name: string, schema: string | undefined, definition: string, withData?: boolean): string;
     dropMaterializedViewIfExists(name: string, schema?: string): string;
     refreshMaterializedView(name: string, schema?: string, concurrently?: boolean): string;
-    getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
+    getNamespaces(connection: AbstractSqlConnection, ctx?: Transaction): Promise<string[]>;
     private getIgnoredNamespacesConditionSQL;
-    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
-    getAllIndexes(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<IndexDef[]>>;
+    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[], ctx?: Transaction): Promise<void>;
+    getAllIndexes(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<IndexDef[]>>;
     /**
      * Parses column definitions from the full CREATE INDEX expression.
      * Since pg_get_indexdef(oid, col_num, true) doesn't include sort modifiers,
@@ -47,10 +47,10 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
         name: string;
         schema?: string;
         items: string[];
-    }>): Promise<Dictionary<Column[]>>;
-    getAllChecks(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>): Promise<Dictionary<CheckDef[]>>;
-    getAllForeignKeys(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>): Promise<Dictionary<Dictionary<ForeignKey>>>;
-    getNativeEnumDefinitions(connection: AbstractSqlConnection, schemas: string[]): Promise<Dictionary<{
+    }>, ctx?: Transaction): Promise<Dictionary<Column[]>>;
+    getAllChecks(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, ctx?: Transaction): Promise<Dictionary<CheckDef[]>>;
+    getAllForeignKeys(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, ctx?: Transaction): Promise<Dictionary<Dictionary<ForeignKey>>>;
+    getNativeEnumDefinitions(connection: AbstractSqlConnection, schemas: string[], ctx?: Transaction): Promise<Dictionary<{
         name: string;
         schema?: string;
         items: string[];

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -41,8 +41,8 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             `and ${this.getIgnoredViewsCondition()} ` +
             `order by table_name`);
     }
-    async loadViews(schema, connection) {
-        const views = await connection.execute(this.getListViewsSQL());
+    async loadViews(schema, connection, schemaName, ctx) {
+        const views = await connection.execute(this.getListViewsSQL(), [], 'all', ctx);
         for (const view of views) {
             const definition = view.view_definition?.trim().replace(/;$/, '') ?? '';
             if (definition) {
@@ -51,17 +51,26 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         }
     }
     getListMaterializedViewsSQL() {
-        return (`select matviewname as view_name, schemaname as schema_name, definition as view_definition ` +
+        return (`select matviewname as view_name, schemaname as schema_name, definition as view_definition, ispopulated as is_populated ` +
             `from pg_matviews ` +
             `where ${this.getIgnoredNamespacesConditionSQL('schemaname')} ` +
             `order by matviewname`);
     }
-    async loadMaterializedViews(schema, connection, schemaName) {
-        const views = await connection.execute(this.getListMaterializedViewsSQL());
-        for (const view of views) {
-            const definition = view.view_definition?.trim().replace(/;$/, '') ?? '';
+    async loadMaterializedViews(schema, connection, schemaName, ctx) {
+        const views = await connection.execute(this.getListMaterializedViewsSQL(), [], 'all', ctx);
+        if (views.length === 0) {
+            return;
+        }
+        const tables = views.map(v => ({ table_name: v.view_name, schema_name: v.schema_name }));
+        const indexes = await this.getAllIndexes(connection, tables, ctx);
+        for (let i = 0; i < views.length; i++) {
+            const definition = views[i].view_definition?.trim().replace(/;$/, '') ?? '';
             if (definition) {
-                schema.addView(view.view_name, view.schema_name, definition, true);
+                const dbView = schema.addView(views[i].view_name, views[i].schema_name, definition, true, views[i].is_populated);
+                const key = this.getTableKey(tables[i]);
+                if (indexes[key]?.length) {
+                    dbView.indexes = indexes[key];
+                }
             }
         }
     }
@@ -77,11 +86,11 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         const concurrent = concurrently ? ' concurrently' : '';
         return `refresh materialized view${concurrent} ${this.quote(this.getTableName(name, schema))}`;
     }
-    async getNamespaces(connection) {
+    async getNamespaces(connection, ctx) {
         const sql = `select schema_name from information_schema.schemata ` +
             `where ${this.getIgnoredNamespacesConditionSQL()} ` +
             `order by schema_name`;
-        const res = await connection.execute(sql);
+        const res = await connection.execute(sql, [], 'all', ctx);
         return res.map(row => row.schema_name);
     }
     getIgnoredNamespacesConditionSQL(column = 'schema_name') {
@@ -97,18 +106,18 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         const ignoredPrefixes = ['pg_', 'crdb_', '_timescaledb_'].map(p => `"${column}" not like '${p}%'`).join(' and ');
         return `${ignoredPrefixes} and "${column}" not in (${ignored})`;
     }
-    async loadInformationSchema(schema, connection, tables, schemas) {
+    async loadInformationSchema(schema, connection, tables, schemas, ctx) {
         schemas ??= tables.length === 0 ? [schema.name] : tables.map(t => t.schema_name);
-        const nativeEnums = await this.getNativeEnumDefinitions(connection, schemas);
+        const nativeEnums = await this.getNativeEnumDefinitions(connection, schemas, ctx);
         schema.setNativeEnums(nativeEnums);
         if (tables.length === 0) {
             return;
         }
         const tablesBySchema = this.getTablesGroupedBySchemas(tables);
-        const columns = await this.getAllColumns(connection, tablesBySchema, nativeEnums);
-        const indexes = await this.getAllIndexes(connection, tables);
-        const checks = await this.getAllChecks(connection, tablesBySchema);
-        const fks = await this.getAllForeignKeys(connection, tablesBySchema);
+        const columns = await this.getAllColumns(connection, tablesBySchema, nativeEnums, ctx);
+        const indexes = await this.getAllIndexes(connection, tables, ctx);
+        const checks = await this.getAllChecks(connection, tablesBySchema, ctx);
+        const fks = await this.getAllForeignKeys(connection, tablesBySchema, ctx);
         for (const t of tables) {
             const key = this.getTableKey(t);
             const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
@@ -119,10 +128,10 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             }
         }
     }
-    async getAllIndexes(connection, tables) {
+    async getAllIndexes(connection, tables, ctx) {
         const sql = this.getIndexesSQL(tables);
         const unquote = (str) => str.replace(/['"`]/g, '');
-        const allIndexes = await connection.execute(sql);
+        const allIndexes = await connection.execute(sql, [], 'all', ctx);
         const ret = {};
         for (const index of allIndexes) {
             const key = this.getTableKey(index);
@@ -243,7 +252,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         /* v8 ignore next - pg_get_indexdef always returns balanced parentheses */
         return '';
     }
-    async getAllColumns(connection, tablesBySchemas, nativeEnums) {
+    async getAllColumns(connection, tablesBySchemas, nativeEnums, ctx) {
         const sql = `select table_schema as schema_name, table_name, column_name,
       column_default,
       is_nullable,
@@ -263,7 +272,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
       join pg_attribute pga on pgc.oid = pga.attrelid and cols.column_name = pga.attname
       where (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(table_schema = ${this.platform.quoteValue(schema)} and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}))`).join(' or ')})
       order by ordinal_position`;
-        const allColumns = await connection.execute(sql);
+        const allColumns = await connection.execute(sql, [], 'all', ctx);
         const str = (val) => (val != null ? '' + val : val);
         const ret = {};
         for (const col of allColumns) {
@@ -342,9 +351,9 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         }
         return ret;
     }
-    async getAllChecks(connection, tablesBySchemas) {
+    async getAllChecks(connection, tablesBySchemas, ctx) {
         const sql = this.getChecksSQL(tablesBySchemas);
-        const allChecks = await connection.execute(sql);
+        const allChecks = await connection.execute(sql, [], 'all', ctx);
         const ret = {};
         const seen = new Set();
         for (const check of allChecks) {
@@ -366,7 +375,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         }
         return ret;
     }
-    async getAllForeignKeys(connection, tablesBySchemas) {
+    async getAllForeignKeys(connection, tablesBySchemas, ctx) {
         const sql = `select nsp1.nspname schema_name, cls1.relname table_name, nsp2.nspname referenced_schema_name,
       cls2.relname referenced_table_name, a.attname column_name, af.attname referenced_column_name, conname constraint_name,
       confupdtype update_rule, confdeltype delete_rule, array_position(con.conkey,a.attnum) as ord, condeferrable, condeferred,
@@ -381,7 +390,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
       where (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(cls1.relname in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}) and nsp1.nspname = ${this.platform.quoteValue(schema)})`).join(' or ')})
       and confrelid > 0
       order by nsp1.nspname, cls1.relname, constraint_name, ord`;
-        const allFks = await connection.execute(sql);
+        const allFks = await connection.execute(sql, [], 'all', ctx);
         const ret = {};
         function mapReferentialIntegrity(value, def) {
             const match = ['n', 'd'].includes(value) && /ON DELETE (SET (NULL|DEFAULT) \(.*?\))/.exec(def);
@@ -419,14 +428,14 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         });
         return ret;
     }
-    async getNativeEnumDefinitions(connection, schemas) {
+    async getNativeEnumDefinitions(connection, schemas, ctx) {
         const uniqueSchemas = Utils.unique(schemas);
         const res = await connection.execute(`select t.typname as enum_name, n.nspname as schema_name, array_agg(e.enumlabel order by e.enumsortorder) as enum_value
         from pg_type t
         join pg_enum e on t.oid = e.enumtypid
         join pg_catalog.pg_namespace n on n.oid = t.typnamespace
         where n.nspname in (${Array(uniqueSchemas.length).fill('?').join(', ')})
-        group by t.typname, n.nspname`, uniqueSchemas);
+        group by t.typname, n.nspname`, uniqueSchemas, 'all', ctx);
         return res.reduce((o, row) => {
             let name = row.enum_name;
             if (row.schema_name && row.schema_name !== this.platform.getDefaultSchemaName()) {
@@ -511,6 +520,9 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                 if (parts.length === 2 && parts[0] === '*') {
                     columnType = `${table.schema}.${parts[1]}`;
                 }
+                else if (parts.length === 1) {
+                    columnType = this.getTableName(column.type, table.schema);
+                }
                 if (columnType.endsWith('[]')) {
                     columnType = this.quote(columnType.substring(0, columnType.length - 2)) + '[]';
                 }

package/dialects/sqlite/SqliteSchemaHelper.d.ts

@@ -1,4 +1,4 @@
-import { type Connection } from '@mikro-orm/core';
+import { type Connection, type Transaction } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
 import type { Column, IndexDef, Table, TableDifference } from '../../typings.js';
@@ -11,13 +11,13 @@ export declare class SqliteSchemaHelper extends SchemaHelper {
     getCreateNamespaceSQL(name: string): string;
     getDropNamespaceSQL(name: string): string;
     getListTablesSQL(): string;
-    getAllTables(connection: AbstractSqlConnection, schemas?: string[]): Promise<Table[]>;
-    getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
+    getAllTables(connection: AbstractSqlConnection, schemas?: string[], ctx?: Transaction): Promise<Table[]>;
+    getNamespaces(connection: AbstractSqlConnection, ctx?: Transaction): Promise<string[]>;
     private getIgnoredViewsCondition;
     getListViewsSQL(): string;
-    loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string): Promise<void>;
+    loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string, ctx?: Transaction): Promise<void>;
     getDropDatabaseSQL(name: string): string;
-    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
+    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[], ctx?: Transaction): Promise<void>;
     createTable(table: DatabaseTable, alter?: boolean): string[];
     createTableColumn(column: Column, table: DatabaseTable, _changedProperties?: Set<string>): string | undefined;
     getAddColumnsSQL(table: DatabaseTable, columns: Column[], diff?: TableDifference): string[];
@@ -45,7 +45,7 @@ export declare class SqliteSchemaHelper extends SchemaHelper {
      */
     private wrapExpressionDefault;
     private getEnumDefinitions;
-    getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[], tableName: string, schemaName?: string): Promise<string[]>;
+    getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[], tableName: string, schemaName?: string, ctx?: Transaction): Promise<string[]>;
     private getIndexes;
     private getChecks;
     private getColumnDefinitions;

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.9",
+  "version": "7.0.8-dev.0",
   "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"
+    "@mikro-orm/core": "^7.0.7"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.7-dev.9"
+    "@mikro-orm/core": "7.0.8-dev.0"
   },
   "engines": {
     "node": ">= 22.17.0"

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

package/schema/SqlSchemaGenerator.js

@@ -89,16 +89,9 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
                 this.append(ret, fks, true);
             }
         }
-        // Create views after tables (views may depend on tables)
-        // Sort views by dependencies (views depending on other views come later)
         const sortedViews = this.sortViewsByDependencies(toSchema.getViews());
         for (const view of sortedViews) {
-            if (view.materialized) {
-                this.append(ret, this.helper.createMaterializedView(view.name, view.schema, view.definition, view.withData ?? true));
-            }
-            else {
-                this.append(ret, this.helper.createView(view.name, view.schema, view.definition), true);
-            }
+            this.appendViewCreation(ret, view);
         }
         return this.wrapSchema(ret, options);
     }
@@ -185,8 +178,8 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
             this.append(ret, this.helper.dropTableIfExists(meta.tableName, this.getSchemaName(meta, options)));
         }
         if (this.platform.supportsNativeEnums()) {
-            for (const columnName of Object.keys(schema.getNativeEnums())) {
-                const sql = this.helper.getDropNativeEnumSQL(columnName, options.schema ?? this.config.get('schema'));
+            for (const enumOptions of Object.values(schema.getNativeEnums())) {
+                const sql = this.helper.getDropNativeEnumSQL(enumOptions.name, this.getSchemaName(enumOptions, options));
                 this.append(ret, sql);
             }
         }
@@ -338,27 +331,14 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
                 this.append(ret, sql);
             }
         }
-        // Create new views after all table changes are done
-        // Sort views by dependencies (views depending on other views come later)
         const sortedNewViews = this.sortViewsByDependencies(Object.values(schemaDiff.newViews));
         for (const view of sortedNewViews) {
-            if (view.materialized) {
-                this.append(ret, this.helper.createMaterializedView(view.name, view.schema, view.definition, view.withData ?? true));
-            }
-            else {
-                this.append(ret, this.helper.createView(view.name, view.schema, view.definition), true);
-            }
+            this.appendViewCreation(ret, view);
         }
-        // Recreate changed views (also sorted by dependencies)
         const changedViews = Object.values(schemaDiff.changedViews).map(v => v.to);
         const sortedChangedViews = this.sortViewsByDependencies(changedViews);
         for (const view of sortedChangedViews) {
-            if (view.materialized) {
-                this.append(ret, this.helper.createMaterializedView(view.name, view.schema, view.definition, view.withData ?? true));
-            }
-            else {
-                this.append(ret, this.helper.createView(view.name, view.schema, view.definition), true);
-            }
+            this.appendViewCreation(ret, view);
         }
         return this.wrapSchema(ret, options);
     }
@@ -511,6 +491,22 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         // Sort and map back to views
         return calc.sort().map(index => indexToView.get(index));
     }
+    appendViewCreation(ret, view) {
+        if (view.materialized) {
+            this.append(ret, this.helper.createMaterializedView(view.name, view.schema, view.definition, view.withData ?? true));
+            // Skip indexes for WITH NO DATA views — they have no data to index yet.
+            // Indexes will be created on the next schema:update after REFRESH populates data.
+            if (view.withData !== false) {
+                const viewName = this.helper.getTableName(view.name, view.schema);
+                for (const index of view.indexes ?? []) {
+                    this.append(ret, this.helper.getCreateIndexSQL(viewName, index));
+                }
+            }
+        }
+        else {
+            this.append(ret, this.helper.createView(view.name, view.schema, view.definition), true);
+        }
+    }
     escapeRegExp(string) {
         return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     }

package/typings.d.ts

@@ -142,6 +142,8 @@ export interface DatabaseView {
     materialized?: boolean;
     /** For materialized views, whether data was populated on creation. */
     withData?: boolean;
+    /** Indexes on the materialized view. Only materialized views support indexes. */
+    indexes?: IndexDef[];
 }
 export interface SchemaDifference {
     newNamespaces: Set<string>;
@@ -250,8 +252,9 @@ export type MapTableName<T extends {
 }, TOptions extends MikroKyselyPluginOptions = {}> = {
     [P in T as TOptions['tableNamingStrategy'] extends 'entity' ? P['name'] : PreferStringLiteral<NonNullable<P['tableName']>, P['name']>]: P;
 };
+type ResolveTableNaming<TOptions extends MikroKyselyPluginOptions> = TOptions['tableNamingStrategy'] extends 'entity' ? 'entity' : 'underscore';
 export type MapValueAsTable<TMap extends Record<string, any>, TOptions extends MikroKyselyPluginOptions = {}> = {
-    [K in keyof TMap as TransformName<K, TOptions['tableNamingStrategy'] extends 'entity' ? 'entity' : 'underscore'>]: InferKyselyTable<TMap[K], TOptions>;
+    [K in keyof TMap as TransformName<K, ResolveTableNaming<TOptions>>]: InferKyselyTable<TMap[K], TOptions>;
 };
 export type InferKyselyTable<TSchema extends EntitySchemaWithMeta, TOptions extends MikroKyselyPluginOptions = {}> = ExcludeNever<{
     -readonly [K in keyof InferEntityProperties<TSchema> as TransformColumnName<K, TOptions['columnNamingStrategy'] extends 'property' ? 'property' : 'underscore', MaybeReturnType<InferEntityProperties<TSchema>[K]>>]: InferColumnValue<MaybeReturnType<InferEntityProperties<TSchema>[K]>, TOptions['processOnCreateHooks'] extends true ? true : false>;
@@ -318,7 +321,9 @@ export type InferClassEntityDB<TEntities, TOptions extends MikroKyselyPluginOpti
 type ClassEntityDBMap<TEntities, TOptions extends MikroKyselyPluginOptions = {}> = {
     [T in TEntities as ClassEntityTableName<T, TOptions>]: ClassEntityColumns<T, TOptions>;
 };
-type ClassEntityTableName<T, TOptions extends MikroKyselyPluginOptions = {}> = T extends abstract new (...args: any[]) => infer Instance ? TransformName<InferEntityName<Instance>, TOptions['tableNamingStrategy'] extends 'entity' ? 'entity' : 'underscore'> : never;
+type ClassEntityTableName<T, TOptions extends MikroKyselyPluginOptions = {}> = T extends {
+    '~entityName'?: infer Name extends string;
+} ? TransformName<Name, ResolveTableNaming<TOptions>> : T extends abstract new (...args: any[]) => infer Instance ? TransformName<InferEntityName<Instance>, ResolveTableNaming<TOptions>> : never;
 type ClassEntityColumns<T, TOptions extends MikroKyselyPluginOptions = {}> = T extends abstract new (...args: any[]) => infer Instance ? {
     [K in keyof Instance as ClassEntityColumnName<K, Instance[K], TOptions>]: ClassEntityColumnValue<Instance[K]>;
 } : never;