@mikro-orm/sql 7.0.7-dev.11 → 7.0.7-dev.13

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) {
@@ -56,13 +56,13 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             `where ${this.getIgnoredNamespacesConditionSQL('schemaname')} ` +
             `order by matviewname`);
     }
-    async loadMaterializedViews(schema, connection, schemaName) {
-        const views = await connection.execute(this.getListMaterializedViewsSQL());
+    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);
+        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) {
@@ -86,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') {
@@ -106,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);
@@ -128,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);
@@ -252,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,
@@ -272,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) {
@@ -351,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) {
@@ -375,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,
@@ -390,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);
@@ -428,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()) {

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.11",
+  "version": "7.0.7-dev.13",
   "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",
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^7.0.6"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.7-dev.11"
+    "@mikro-orm/core": "7.0.7-dev.13"
   },
   "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) {

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;
@@ -101,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. */
@@ -362,7 +362,7 @@ export class SchemaHelper {
     getChangeColumnCommentSQL(tableName, to, schemaName) {
         return '';
     }
-    async getNamespaces(connection) {
+    async getNamespaces(connection, ctx) {
         return [];
     }
     async mapIndexes(indexes) {
@@ -663,7 +663,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/typings.d.ts

@@ -252,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>;
@@ -320,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;