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

package/AbstractSqlPlatform.d.ts

@@ -36,6 +36,8 @@ export declare abstract class AbstractSqlPlatform extends Platform {
     quoteJsonKey(key: string): string;
     getJsonIndexDefinition(index: IndexDef): string[];
     supportsUnionWhere(): boolean;
+    /** Whether the platform supports `count(distinct col1, col2)` with multiple columns. If false, a subquery wrapper is used instead. */
+    supportsMultiColumnCountDistinct(): boolean;
     supportsSchemas(): boolean;
     /** @inheritDoc */
     generateCustomOrder(escapedColumn: string, values: unknown[]): string;

package/AbstractSqlPlatform.js

@@ -91,6 +91,10 @@ export class AbstractSqlPlatform extends Platform {
     supportsUnionWhere() {
         return true;
     }
+    /** Whether the platform supports `count(distinct col1, col2)` with multiple columns. If false, a subquery wrapper is used instead. */
+    supportsMultiColumnCountDistinct() {
+        return false;
+    }
     supportsSchemas() {
         return false;
     }

package/dialects/mssql/MsSqlNativeQueryBuilder.js

@@ -137,13 +137,18 @@ export class MsSqlNativeQueryBuilder extends NativeQueryBuilder {
         this.parts[this.parts.length - 1] += ';';
     }
     compileSelect() {
+        const wrapCountSubquery = this.needsCountSubquery();
+        if (wrapCountSubquery) {
+            this.parts.push(`select count(*) as ${this.quote('count')} from (`);
+        }
         this.parts.push('select');
-        if (this.options.limit != null && this.options.offset == null) {
+        // skip top(?) inside the count subquery — it would limit the distinct rows before counting
+        if (this.options.limit != null && this.options.offset == null && !wrapCountSubquery) {
             this.parts.push(`top (?)`);
             this.params.push(this.options.limit);
         }
         this.addHintComment();
-        this.parts.push(`${this.getFields()} from ${this.getTableName()}`);
+        this.parts.push(`${this.getFields(wrapCountSubquery)} from ${this.getTableName()}`);
         this.addLockClause();
         if (this.options.joins) {
             for (const join of this.options.joins) {
@@ -163,21 +168,27 @@ export class MsSqlNativeQueryBuilder extends 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.offset != null) {
-            /* v8 ignore next */
-            if (!this.options.orderBy) {
-                throw new Error('Order by clause is required for pagination');
+        if (!wrapCountSubquery) {
+            if (this.options.orderBy) {
+                this.parts.push(`order by ${this.options.orderBy}`);
             }
-            this.parts.push(`offset ? rows`);
-            this.params.push(this.options.offset);
-            if (this.options.limit != null) {
-                this.parts.push(`fetch next ? rows only`);
-                this.params.push(this.options.limit);
+            if (this.options.offset != null) {
+                /* v8 ignore next */
+                if (!this.options.orderBy) {
+                    throw new Error('Order by clause is required for pagination');
+                }
+                this.parts.push(`offset ? rows`);
+                this.params.push(this.options.offset);
+                if (this.options.limit != null) {
+                    this.parts.push(`fetch next ? rows only`);
+                    this.params.push(this.options.limit);
+                }
             }
         }
+        if (wrapCountSubquery) {
+            const asKeyword = this.platform.usesAsKeyword() ? ' as ' : ' ';
+            this.parts.push(`)${asKeyword}${this.quote('dcnt')}`);
+        }
     }
     addLockClause() {
         if (!this.options.lockMode ||

package/dialects/mysql/BaseMySqlPlatform.d.ts

@@ -14,6 +14,7 @@ export declare class BaseMySqlPlatform extends AbstractSqlPlatform {
         readonly "desc nulls first": "is not null";
         readonly "desc nulls last": "is null";
     };
+    supportsMultiColumnCountDistinct(): boolean;
     /** @internal */
     createNativeQueryBuilder(): MySqlNativeQueryBuilder;
     getDefaultCharset(): string;

package/dialects/mysql/BaseMySqlPlatform.js

@@ -18,6 +18,9 @@ export class BaseMySqlPlatform extends AbstractSqlPlatform {
         [QueryOrder.desc_nulls_first]: 'is not null',
         [QueryOrder.desc_nulls_last]: 'is null',
     };
+    supportsMultiColumnCountDistinct() {
+        return true;
+    }
     /** @internal */
     createNativeQueryBuilder() {
         return new MySqlNativeQueryBuilder(this);

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/oracledb/OracleNativeQueryBuilder.js

@@ -213,9 +213,13 @@ export class OracleNativeQueryBuilder extends NativeQueryBuilder {
         }
     }
     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);
@@ -234,16 +238,22 @@ export class OracleNativeQueryBuilder extends 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.offset != null) {
-            this.parts.push(`offset ? rows`);
-            this.params.push(this.options.offset);
+        if (!wrapCountSubquery) {
+            if (this.options.orderBy) {
+                this.parts.push(`order by ${this.options.orderBy}`);
+            }
+            if (this.options.offset != null) {
+                this.parts.push(`offset ? rows`);
+                this.params.push(this.options.offset);
+            }
+            if (this.options.limit != null) {
+                this.parts.push(`fetch next ? rows only`);
+                this.params.push(this.options.limit);
+            }
         }
-        if (this.options.limit != null) {
-            this.parts.push(`fetch next ? rows only`);
-            this.params.push(this.options.limit);
+        if (wrapCountSubquery) {
+            const asKeyword = this.platform.usesAsKeyword() ? ' as ' : ' ';
+            this.parts.push(`)${asKeyword}${this.quote('dcnt')}`);
         }
     }
 }

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;