@mikro-orm/oracledb 7.0.13 → 7.0.14-dev.1

package/OracleConnection.d.ts

@@ -1,28 +1,12 @@
-import {
-  AbstractSqlConnection,
-  type AnyEntity,
-  type EntityData,
-  type LoggingOptions,
-  NativeQueryBuilder,
-  OracleDialect,
-  type QueryResult,
-  type RawQueryFragment,
-  type Transaction,
-} from '@mikro-orm/sql';
+import { AbstractSqlConnection, type AnyEntity, type EntityData, type LoggingOptions, NativeQueryBuilder, OracleDialect, type QueryResult, type RawQueryFragment, type Transaction } from '@mikro-orm/sql';
 import { type PoolAttributes } from 'oracledb';
 /** Oracle database connection using the `oracledb` driver. */
 export declare class OracleConnection extends AbstractSqlConnection {
-  createKyselyDialect(overrides: PoolAttributes): Promise<OracleDialect>;
-  mapOptions(overrides: PoolAttributes): PoolAttributes;
-  execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(
-    query: string | NativeQueryBuilder | RawQueryFragment,
-    params?: readonly unknown[],
-    method?: 'all' | 'get' | 'run',
-    ctx?: Transaction,
-    loggerContext?: LoggingOptions,
-  ): Promise<T>;
-  /** @inheritDoc */
-  executeDump(dump: string): Promise<void>;
-  private stripTrailingSemicolon;
-  protected transformRawResult<T>(res: any, method: 'all' | 'get' | 'run'): T;
+    createKyselyDialect(overrides: PoolAttributes): Promise<OracleDialect>;
+    mapOptions(overrides: PoolAttributes): PoolAttributes;
+    execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(query: string | NativeQueryBuilder | RawQueryFragment, params?: readonly unknown[], method?: 'all' | 'get' | 'run', ctx?: Transaction, loggerContext?: LoggingOptions): Promise<T>;
+    /** @inheritDoc */
+    executeDump(dump: string): Promise<void>;
+    private stripTrailingSemicolon;
+    protected transformRawResult<T>(res: any, method: 'all' | 'get' | 'run'): T;
 }

package/OracleConnection.js

@@ -1,189 +1,187 @@
-import { AbstractSqlConnection, isRaw, NativeQueryBuilder, OracleDialect, Utils } from '@mikro-orm/sql';
+import { AbstractSqlConnection, isRaw, NativeQueryBuilder, OracleDialect, Utils, } from '@mikro-orm/sql';
 import { CompiledQuery } from 'kysely';
 import oracledb from 'oracledb';
 /** Oracle database connection using the `oracledb` driver. */
 export class OracleConnection extends AbstractSqlConnection {
-  async createKyselyDialect(overrides) {
-    const options = this.mapOptions(overrides);
-    const password = options.password;
-    const onCreateConnection = this.options.onCreateConnection ?? this.config.get('onCreateConnection');
-    const initialPassword = typeof password === 'function' ? await password() : password;
-    const poolOptions = {
-      ...options,
-      password: initialPassword,
-      sessionCallback: onCreateConnection,
-    };
-    // Retry pool creation for transient Oracle errors (e.g. ORA-01017 under load)
-    let pool;
-    const maxRetries = 3;
-    for (let attempt = 1; ; attempt++) {
-      try {
-        pool = await oracledb.createPool(poolOptions);
-        break;
-        /* v8 ignore start: transient Oracle pool-creation errors are not reproducible in tests */
-      } catch (e) {
-        if (attempt < maxRetries && (e.errorNum === 1017 || e.errorNum === 12514 || e.errorNum === 12541)) {
-          await new Promise(resolve => setTimeout(resolve, 250 * attempt));
-          continue;
+    async createKyselyDialect(overrides) {
+        const options = this.mapOptions(overrides);
+        const password = options.password;
+        const onCreateConnection = this.options.onCreateConnection ?? this.config.get('onCreateConnection');
+        const initialPassword = typeof password === 'function' ? await password() : password;
+        const poolOptions = {
+            ...options,
+            password: initialPassword,
+            sessionCallback: onCreateConnection,
+        };
+        // Retry pool creation for transient Oracle errors (e.g. ORA-01017 under load)
+        let pool;
+        const maxRetries = 3;
+        for (let attempt = 1;; attempt++) {
+            try {
+                pool = await oracledb.createPool(poolOptions);
+                break;
+                /* v8 ignore start: transient Oracle pool-creation errors are not reproducible in tests */
+            }
+            catch (e) {
+                if (attempt < maxRetries && (e.errorNum === 1017 || e.errorNum === 12514 || e.errorNum === 12541)) {
+                    await new Promise(resolve => setTimeout(resolve, 250 * attempt));
+                    continue;
+                }
+                throw e;
+            }
+            /* v8 ignore stop */
         }
-        throw e;
-      }
-      /* v8 ignore stop */
-    }
-    const executeOptions = {
-      fetchTypeHandler: metaData => {
-        const bigInt = metaData.dbType === oracledb.DB_TYPE_NUMBER && (metaData.precision ?? 0) > 10;
-        metaData.name = metaData.name.toLowerCase();
-        if (bigInt || metaData.dbType === oracledb.DB_TYPE_CLOB) {
-          return {
-            type: oracledb.DB_TYPE_VARCHAR,
-          };
-        }
-        if (metaData.dbType === oracledb.DB_TYPE_BLOB) {
-          return {
-            type: oracledb.BUFFER,
-          };
-        }
-        return undefined;
-      },
-    };
-    // When password is a callback, wrap the pool to resolve it per-connection.
-    // oracledb supports per-connection password override via getConnection({ password }).
-    const wrappedPool =
-      typeof password === 'function'
-        ? {
-            async getConnection() {
-              return pool.getConnection({ password: await password() });
+        const executeOptions = {
+            fetchTypeHandler: metaData => {
+                const bigInt = metaData.dbType === oracledb.DB_TYPE_NUMBER && (metaData.precision ?? 0) > 10;
+                metaData.name = metaData.name.toLowerCase();
+                if (bigInt || metaData.dbType === oracledb.DB_TYPE_CLOB) {
+                    return {
+                        type: oracledb.DB_TYPE_VARCHAR,
+                    };
+                }
+                if (metaData.dbType === oracledb.DB_TYPE_BLOB) {
+                    return {
+                        type: oracledb.BUFFER,
+                    };
+                }
+                return undefined;
             },
-            close: drainTime => pool.close(drainTime),
-          }
-        : pool;
-    return new OracleDialect({
-      pool: wrappedPool,
-      executeOptions: executeOptions,
-    });
-  }
-  mapOptions(overrides) {
-    const ret = { ...this.getConnectionOptions() };
-    const dbName = this.config.get('dbName');
-    const pool = this.config.get('pool');
-    ret.poolMin = pool?.min;
-    ret.poolMax = pool?.max;
-    ret.poolTimeout = pool?.idleTimeoutMillis;
-    const user = this.config.get('user', dbName);
-    ret.user = user.startsWith('"') || user === 'system' ? user : this.platform.quoteIdentifier(user);
-    ret.connectionString = this.options.clientUrl ?? this.platform.getDefaultClientUrl();
-    Reflect.deleteProperty(ret, 'database');
-    Reflect.deleteProperty(ret, 'port');
-    Reflect.deleteProperty(ret, 'host');
-    return Utils.mergeConfig(ret, overrides);
-  }
-  async execute(query, params = [], method = 'all', ctx, loggerContext) {
-    await this.ensureConnection();
-    if (query instanceof NativeQueryBuilder) {
-      query = query.toRaw();
-    }
-    if (isRaw(query)) {
-      params = query.params;
-      query = query.sql;
+        };
+        // When password is a callback, wrap the pool to resolve it per-connection.
+        // oracledb supports per-connection password override via getConnection({ password }).
+        const wrappedPool = typeof password === 'function'
+            ? {
+                async getConnection() {
+                    return pool.getConnection({ password: await password() });
+                },
+                close: (drainTime) => pool.close(drainTime),
+            }
+            : pool;
+        return new OracleDialect({
+            pool: wrappedPool,
+            executeOptions: executeOptions,
+        });
     }
-    query = this.stripTrailingSemicolon(query);
-    let last;
-    let rawQuery;
-    const lastParam = params[params.length - 1];
-    if (Utils.isObject(lastParam) && '__outBindings' in lastParam && lastParam.__outBindings) {
-      rawQuery = lastParam.__rawQuery;
-      const { __outBindings, ...rest } = lastParam;
-      last = rest;
-      params = [...params.slice(0, -1), last];
+    mapOptions(overrides) {
+        const ret = { ...this.getConnectionOptions() };
+        const dbName = this.config.get('dbName');
+        const pool = this.config.get('pool');
+        ret.poolMin = pool?.min;
+        ret.poolMax = pool?.max;
+        ret.poolTimeout = pool?.idleTimeoutMillis;
+        const user = this.config.get('user', dbName);
+        ret.user = user.startsWith('"') || user === 'system' ? user : this.platform.quoteIdentifier(user);
+        ret.connectionString = this.options.clientUrl ?? this.platform.getDefaultClientUrl();
+        Reflect.deleteProperty(ret, 'database');
+        Reflect.deleteProperty(ret, 'port');
+        Reflect.deleteProperty(ret, 'host');
+        return Utils.mergeConfig(ret, overrides);
     }
-    query = this.config.get('onQuery')(query, params);
-    const formatted = this.platform.formatQuery(query, params);
-    const sql = this.getSql(rawQuery ?? query, formatted, loggerContext);
-    return this.executeQuery(
-      sql,
-      async () => {
-        const compiled = CompiledQuery.raw(formatted, last);
-        if (ctx) {
-          const res = await ctx.executeQuery(compiled);
-          return this.transformRawResult(res, method);
+    async execute(query, params = [], method = 'all', ctx, loggerContext) {
+        await this.ensureConnection();
+        if (query instanceof NativeQueryBuilder) {
+            query = query.toRaw();
         }
-        const res = await this.getClient().executeQuery({
-          ...compiled,
-          autoCommit: true,
-        });
-        return this.transformRawResult(res, method);
-      },
-      { query, params, ...loggerContext },
-    );
-  }
-  /** @inheritDoc */
-  async executeDump(dump) {
-    await this.ensureConnection();
-    const lines = dump.split('\n').filter(i => i.trim());
-    for (let line of lines) {
-      if (line.startsWith('--')) {
-        continue;
-      }
-      line = this.stripTrailingSemicolon(line);
-      const raw = CompiledQuery.raw(line);
-      const now = Date.now();
-      try {
-        await this.getClient().executeQuery(raw);
-      } catch (e) {
-        this.logQuery(line, { took: Date.now() - now, level: 'error', query: line });
-        throw e;
-      }
-    }
-  }
-  stripTrailingSemicolon(sql) {
-    if (sql.endsWith(';') && !/end(\s+\w+)?;$/i.test(sql)) {
-      return sql.slice(0, -1);
+        if (isRaw(query)) {
+            params = query.params;
+            query = query.sql;
+        }
+        query = this.stripTrailingSemicolon(query);
+        let last;
+        let rawQuery;
+        const lastParam = params[params.length - 1];
+        if (Utils.isObject(lastParam) && '__outBindings' in lastParam && lastParam.__outBindings) {
+            rawQuery = lastParam.__rawQuery;
+            const { __outBindings, ...rest } = lastParam;
+            last = rest;
+            params = [...params.slice(0, -1), last];
+        }
+        query = this.config.get('onQuery')(query, params);
+        const formatted = this.platform.formatQuery(query, params);
+        const sql = this.getSql(rawQuery ?? query, formatted, loggerContext);
+        return this.executeQuery(sql, async () => {
+            const compiled = CompiledQuery.raw(formatted, last);
+            if (ctx) {
+                const res = await ctx.executeQuery(compiled);
+                return this.transformRawResult(res, method);
+            }
+            const res = await this.getClient().executeQuery({
+                ...compiled,
+                autoCommit: true,
+            });
+            return this.transformRawResult(res, method);
+        }, { query, params, ...loggerContext });
     }
-    return sql;
-  }
-  transformRawResult(res, method) {
-    if (method === 'get') {
-      return res.rows[0];
+    /** @inheritDoc */
+    async executeDump(dump) {
+        await this.ensureConnection();
+        const lines = dump.split('\n').filter(i => i.trim());
+        for (let line of lines) {
+            if (line.startsWith('--')) {
+                continue;
+            }
+            line = this.stripTrailingSemicolon(line);
+            const raw = CompiledQuery.raw(line);
+            const now = Date.now();
+            try {
+                await this.getClient().executeQuery(raw);
+            }
+            catch (e) {
+                this.logQuery(line, { took: Date.now() - now, level: 'error', query: line });
+                throw e;
+            }
+        }
     }
-    if (method === 'all') {
-      return res.rows;
+    stripTrailingSemicolon(sql) {
+        if (sql.endsWith(';') && !/end(\s+\w+)?;$/i.test(sql)) {
+            return sql.slice(0, -1);
+        }
+        return sql;
     }
-    if (res.numAffectedRows > 0n && res.outBinds) {
-      const keys = Object.keys(res.outBinds);
-      const rows = [];
-      res.rows = rows;
-      for (let i = 0; i < res.numAffectedRows; i++) {
-        const o = {};
-        for (const key of keys) {
-          o[key.replace(/^out_/, '')] = res.outBinds[key][i];
+    transformRawResult(res, method) {
+        if (method === 'get') {
+            return res.rows[0];
+        }
+        if (method === 'all') {
+            return res.rows;
+        }
+        if (res.numAffectedRows > 0n && res.outBinds) {
+            const keys = Object.keys(res.outBinds);
+            const rows = [];
+            res.rows = rows;
+            for (let i = 0; i < res.numAffectedRows; i++) {
+                const o = {};
+                for (const key of keys) {
+                    o[key.replace(/^out_/, '')] = res.outBinds[key][i];
+                }
+                rows.push(o);
+            }
+        }
+        else if (res.outBinds) {
+            const keys = Object.keys(res.outBinds);
+            const rows = [];
+            for (const key of keys) {
+                const [k, i] = key.split('__');
+                rows[+i] ??= {};
+                rows[+i][k.replace(/^out_/, '')] = res.outBinds[key];
+            }
+            res.rows = rows;
         }
-        rows.push(o);
-      }
-    } else if (res.outBinds) {
-      const keys = Object.keys(res.outBinds);
-      const rows = [];
-      for (const key of keys) {
-        const [k, i] = key.split('__');
-        rows[+i] ??= {};
-        rows[+i][k.replace(/^out_/, '')] = res.outBinds[key];
-      }
-      res.rows = rows;
+        const rowCount = res.rows.length;
+        /* v8 ignore start: internal result-shape branches depend on Oracle driver internals */
+        const hasEmptyCount = rowCount === 1 && '' in res.rows[0];
+        const emptyRow = hasEmptyCount && Number(res.rows[0]['']);
+        const affectedRows = hasEmptyCount
+            ? emptyRow
+            : res.numAffectedRows == null
+                ? rowCount
+                : Number(res.numAffectedRows ?? rowCount);
+        /* v8 ignore stop */
+        return {
+            affectedRows,
+            row: res.rows[0],
+            rows: res.rows,
+        };
     }
-    const rowCount = res.rows.length;
-    /* v8 ignore start: internal result-shape branches depend on Oracle driver internals */
-    const hasEmptyCount = rowCount === 1 && '' in res.rows[0];
-    const emptyRow = hasEmptyCount && Number(res.rows[0]['']);
-    const affectedRows = hasEmptyCount
-      ? emptyRow
-      : res.numAffectedRows == null
-        ? rowCount
-        : Number(res.numAffectedRows ?? rowCount);
-    /* v8 ignore stop */
-    return {
-      affectedRows,
-      row: res.rows[0],
-      rows: res.rows,
-    };
-  }
 }

package/OracleDriver.d.ts

@@ -1,17 +1,4 @@
-import {
-  type AnyEntity,
-  type Configuration,
-  type ConnectionType,
-  type Constructor,
-  type EntityDictionary,
-  type EntityName,
-  type FilterQuery,
-  type LoggingOptions,
-  type NativeInsertUpdateManyOptions,
-  type QueryResult,
-  type Transaction,
-  type UpsertManyOptions,
-} from '@mikro-orm/core';
+import { type AnyEntity, type Configuration, type ConnectionType, type Constructor, type EntityDictionary, type EntityName, type FilterQuery, type LoggingOptions, type NativeInsertUpdateManyOptions, type QueryResult, type Transaction, type UpsertManyOptions } from '@mikro-orm/core';
 import { AbstractSqlDriver, type SqlEntityManager } from '@mikro-orm/sql';
 import { OracleConnection } from './OracleConnection.js';
 import { OracleMikroORM } from './OracleMikroORM.js';
@@ -19,27 +6,10 @@ import { OracleQueryBuilder } from './OracleQueryBuilder.js';
 import { OraclePlatform } from './OraclePlatform.js';
 /** Database driver for Oracle. */
 export declare class OracleDriver extends AbstractSqlDriver<OracleConnection, OraclePlatform> {
-  constructor(config: Configuration);
-  createQueryBuilder<T extends AnyEntity<T>>(
-    entityName: EntityName<T>,
-    ctx?: Transaction,
-    preferredConnectionType?: ConnectionType,
-    convertCustomTypes?: boolean,
-    loggerContext?: LoggingOptions,
-    alias?: string,
-    em?: SqlEntityManager,
-  ): OracleQueryBuilder<T, any, any, any>;
-  nativeInsertMany<T extends object>(
-    entityName: EntityName<T>,
-    data: EntityDictionary<T>[],
-    options?: NativeInsertUpdateManyOptions<T>,
-  ): Promise<QueryResult<T>>;
-  nativeUpdateMany<T extends object>(
-    entityName: EntityName<T>,
-    where: FilterQuery<T>[],
-    data: EntityDictionary<T>[],
-    options?: NativeInsertUpdateManyOptions<T> & UpsertManyOptions<T>,
-  ): Promise<QueryResult<T>>;
-  /** @inheritDoc */
-  getORMClass(): Constructor<OracleMikroORM>;
+    constructor(config: Configuration);
+    createQueryBuilder<T extends AnyEntity<T>>(entityName: EntityName<T>, ctx?: Transaction, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions, alias?: string, em?: SqlEntityManager): OracleQueryBuilder<T, any, any, any>;
+    nativeInsertMany<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
+    nativeUpdateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T> & UpsertManyOptions<T>): Promise<QueryResult<T>>;
+    /** @inheritDoc */
+    getORMClass(): Constructor<OracleMikroORM>;
 }

package/OracleDriver.js

@@ -1,4 +1,4 @@
-import { isRaw, QueryFlag, Utils } from '@mikro-orm/core';
+import { isRaw, QueryFlag, Utils, } from '@mikro-orm/core';
 import { AbstractSqlDriver } from '@mikro-orm/sql';
 import { OracleConnection } from './OracleConnection.js';
 import { OracleMikroORM } from './OracleMikroORM.js';
@@ -6,77 +6,76 @@ import { OracleQueryBuilder } from './OracleQueryBuilder.js';
 import { OraclePlatform } from './OraclePlatform.js';
 /** Database driver for Oracle. */
 export class OracleDriver extends AbstractSqlDriver {
-  constructor(config) {
-    super(config, new OraclePlatform(), OracleConnection, ['kysely', 'oracledb']);
-  }
-  createQueryBuilder(entityName, ctx, preferredConnectionType, convertCustomTypes, loggerContext, alias, em) {
-    // do not compute the connectionType if EM is provided as it will be computed from it in the QB later on
-    const connectionType = em
-      ? preferredConnectionType
-      : this.resolveConnectionType({ ctx, connectionType: preferredConnectionType });
-    const qb = new OracleQueryBuilder(entityName, this.metadata, this, ctx, alias, connectionType, em, loggerContext);
-    if (!convertCustomTypes) {
-      qb.unsetFlag(QueryFlag.CONVERT_CUSTOM_TYPES);
+    constructor(config) {
+        super(config, new OraclePlatform(), OracleConnection, ['kysely', 'oracledb']);
     }
-    return qb;
-  }
-  async nativeInsertMany(entityName, data, options = {}) {
-    options.processCollections ??= true;
-    options.convertCustomTypes ??= true;
-    const meta = this.metadata.get(entityName);
-    const pks = this.getPrimaryKeyFields(meta);
-    const collections = options.processCollections ? data.map(d => this.extractManyToMany(meta, d)) : [];
-    const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes).withSchema(
-      this.getSchemaName(meta, options),
-    );
-    qb.insert(data);
-    const res = await this.rethrow(qb.execute('run'));
-    let pk;
-    if (pks.length > 1) {
-      // owner has composite pk
-      pk = data.map(d => Utils.getPrimaryKeyCond(d, pks));
-    } else {
-      res.row ??= {};
-      res.rows ??= [];
-      pk = data.map((d, i) => d[pks[0]] ?? res.rows[i]?.[pks[0]]).map(d => [d]);
-      res.insertId = res.insertId || res.row[pks[0]];
+    createQueryBuilder(entityName, ctx, preferredConnectionType, convertCustomTypes, loggerContext, alias, em) {
+        // do not compute the connectionType if EM is provided as it will be computed from it in the QB later on
+        const connectionType = em
+            ? preferredConnectionType
+            : this.resolveConnectionType({ ctx, connectionType: preferredConnectionType });
+        const qb = new OracleQueryBuilder(entityName, this.metadata, this, ctx, alias, connectionType, em, loggerContext);
+        if (!convertCustomTypes) {
+            qb.unsetFlag(QueryFlag.CONVERT_CUSTOM_TYPES);
+        }
+        return qb;
     }
-    for (let i = 0; i < collections.length; i++) {
-      await this.processManyToMany(meta, pk[i], collections[i], false, options);
+    async nativeInsertMany(entityName, data, options = {}) {
+        options.processCollections ??= true;
+        options.convertCustomTypes ??= true;
+        const meta = this.metadata.get(entityName);
+        const pks = this.getPrimaryKeyFields(meta);
+        const collections = options.processCollections ? data.map(d => this.extractManyToMany(meta, d)) : [];
+        const qb = this.createQueryBuilder(entityName, options.ctx, 'write', options.convertCustomTypes).withSchema(this.getSchemaName(meta, options));
+        qb.insert(data);
+        const res = await this.rethrow(qb.execute('run'));
+        let pk;
+        if (pks.length > 1) {
+            // owner has composite pk
+            pk = data.map(d => Utils.getPrimaryKeyCond(d, pks));
+        }
+        else {
+            res.row ??= {};
+            res.rows ??= [];
+            pk = data.map((d, i) => d[pks[0]] ?? res.rows[i]?.[pks[0]]).map(d => [d]);
+            res.insertId = res.insertId || res.row[pks[0]];
+        }
+        for (let i = 0; i < collections.length; i++) {
+            await this.processManyToMany(meta, pk[i], collections[i], false, options);
+        }
+        return res;
     }
-    return res;
-  }
-  async nativeUpdateMany(entityName, where, data, options = {}) {
-    const meta = this.metadata.get(entityName);
-    const returning = new Set();
-    const into = [];
-    const outBindingsMap = {};
-    for (const row of data) {
-      for (const k of Utils.keys(row)) {
-        if (isRaw(row[k])) {
-          returning.add(k);
+    async nativeUpdateMany(entityName, where, data, options = {}) {
+        const meta = this.metadata.get(entityName);
+        const returning = new Set();
+        const into = [];
+        const outBindingsMap = {};
+        for (const row of data) {
+            for (const k of Utils.keys(row)) {
+                if (isRaw(row[k])) {
+                    returning.add(k);
+                }
+            }
+        }
+        // reload generated columns and version fields
+        meta.props.filter(prop => prop.generated || prop.version || prop.primary).forEach(prop => returning.add(prop.name));
+        for (const propName of returning) {
+            const prop = meta.properties[propName];
+            into.push(`:out_${prop.fieldNames[0]}`);
+            outBindingsMap[`out_${prop.fieldNames[0]}`] = prop.runtimeType;
         }
-      }
+        const outBindings = this.platform.createOutBindings(outBindingsMap);
+        return super.nativeUpdateMany(entityName, where, data, options, (sql, params) => {
+            /* v8 ignore next 2: defensive guard — PKs are always added to `returning` above */
+            if (into.length === 0) {
+                return sql;
+            }
+            params.push(outBindings);
+            return `${sql} into ${into.join(', ')}`;
+        });
     }
-    // reload generated columns and version fields
-    meta.props.filter(prop => prop.generated || prop.version || prop.primary).forEach(prop => returning.add(prop.name));
-    for (const propName of returning) {
-      const prop = meta.properties[propName];
-      into.push(`:out_${prop.fieldNames[0]}`);
-      outBindingsMap[`out_${prop.fieldNames[0]}`] = prop.runtimeType;
+    /** @inheritDoc */
+    getORMClass() {
+        return OracleMikroORM;
     }
-    const outBindings = this.platform.createOutBindings(outBindingsMap);
-    return super.nativeUpdateMany(entityName, where, data, options, (sql, params) => {
-      /* v8 ignore next 2: defensive guard — PKs are always added to `returning` above */
-      if (into.length === 0) {
-        return sql;
-      }
-      params.push(outBindings);
-      return `${sql} into ${into.join(', ')}`;
-    });
-  }
-  /** @inheritDoc */
-  getORMClass() {
-    return OracleMikroORM;
-  }
 }

package/OracleExceptionConverter.d.ts

@@ -1,8 +1,8 @@
 import { ExceptionConverter, type Dictionary, type DriverException } from '@mikro-orm/core';
 /** Converts Oracle native errors into typed MikroORM driver exceptions. */
 export declare class OracleExceptionConverter extends ExceptionConverter {
-  /**
-   * @see https://docs.oracle.com/cd/B28359_01/server.111/b28278/toc.htm
-   */
-  convertException(exception: Error & Dictionary): DriverException;
+    /**
+     * @see https://docs.oracle.com/cd/B28359_01/server.111/b28278/toc.htm
+     */
+    convertException(exception: Error & Dictionary): DriverException;
 }