@mikro-orm/sql 7.1.0-dev.11 → 7.1.0-dev.12

package/AbstractSqlConnection.d.ts

@@ -60,7 +60,7 @@ export declare abstract class AbstractSqlConnection extends Connection {
     /** Executes a SQL query and returns the result based on the method: `'all'` for rows, `'get'` for single row, `'run'` for affected count. */
     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>;
     /** Executes a SQL query and returns an async iterable that yields results row by row. */
-    stream<T extends EntityData<AnyEntity>>(query: string | NativeQueryBuilder | RawQueryFragment, params?: readonly unknown[], ctx?: Transaction<Kysely<any>>, loggerContext?: LoggingOptions): AsyncIterableIterator<T>;
+    stream<T extends EntityData<AnyEntity>>(query: string | NativeQueryBuilder | RawQueryFragment, params?: readonly unknown[], ctx?: Transaction<Kysely<any>>, loggerContext?: LoggingOptions, chunkSize?: number): AsyncIterableIterator<T>;
     /** @inheritDoc */
     executeDump(dump: string): Promise<void>;
     protected getSql(query: string, formatted: string, context?: LogContext): string;

package/AbstractSqlConnection.js

@@ -190,7 +190,7 @@ export class AbstractSqlConnection extends Connection {
         }, { ...q, ...loggerContext });
     }
     /** Executes a SQL query and returns an async iterable that yields results row by row. */
-    async *stream(query, params = [], ctx, loggerContext) {
+    async *stream(query, params = [], ctx, loggerContext, chunkSize) {
         await this.ensureConnection();
         const q = this.prepareQuery(query, params);
         const sql = this.getSql(q.query, q.formatted, loggerContext);
@@ -203,7 +203,7 @@ export class AbstractSqlConnection extends Connection {
             parameters: [],
         };
         try {
-            const res = (ctx ?? this.getClient()).getExecutor().stream(compiled, 1);
+            const res = (ctx ?? this.getClient()).getExecutor().stream(compiled, chunkSize ?? 100);
             this.logQuery(sql, {
                 sql,
                 params,

package/AbstractSqlDriver.d.ts

@@ -31,7 +31,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected findFromVirtual<T extends object>(entityName: EntityName<T>, where: ObjectQuery<T>, options: FindOptions<T, any> | CountOptions<T, any>, type: QueryType): Promise<EntityData<T>[] | number>;
     protected streamFromVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T, any>): AsyncIterableIterator<EntityData<T>>;
     protected wrapVirtualExpressionInSubquery<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any>, type: QueryType): Promise<T[] | number>;
-    protected wrapVirtualExpressionInSubqueryStream<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>, type: QueryType.SELECT): AsyncIterableIterator<T>;
+    protected wrapVirtualExpressionInSubqueryStream<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: StreamOptions<T, any, any, any>, type: QueryType.SELECT): AsyncIterableIterator<T>;
     /**
      * Virtual entities have no PKs, so to-many populate joins can't be deduplicated.
      * Force balanced strategy to load to-many relations via separate queries.

package/AbstractSqlDriver.js

@@ -231,7 +231,7 @@ export class AbstractSqlDriver extends DatabaseDriver {
         native.from(raw(`(${expression})${asKeyword}${this.platform.quoteIdentifier(qb.alias)}`));
         const query = native.compile();
         const connectionType = this.resolveConnectionType({ ctx: options.ctx, connectionType: options.connectionType });
-        const res = this.getConnection(connectionType).stream(query.sql, query.params, options.ctx, options.loggerContext);
+        const res = this.getConnection(connectionType).stream(query.sql, query.params, options.ctx, options.loggerContext, options.chunkSize);
         for await (const row of res) {
             yield this.mapResult(row, meta);
         }

package/dialects/oracledb/OracleDialect.d.ts

@@ -46,7 +46,7 @@ declare class OracleConnection implements DatabaseConnection {
         sql: string;
         bindParams: unknown[];
     };
-    streamQuery<R>(compiledQuery: CompiledQuery, _chunkSize?: number): AsyncIterableIterator<QueryResult<R>>;
+    streamQuery<R>(compiledQuery: CompiledQuery, chunkSize?: number): AsyncIterableIterator<QueryResult<R>>;
     get connection(): OraclePoolConnection;
 }
 declare class OracleDriver implements Driver {

package/dialects/oracledb/OracleDialect.js

@@ -66,13 +66,14 @@ class OracleConnection {
             bindParams: query.parameters,
         };
     }
-    async *streamQuery(compiledQuery, _chunkSize) {
+    async *streamQuery(compiledQuery, chunkSize) {
         const { sql, bindParams } = this.formatQuery(compiledQuery);
         const result = await this.#connection.execute(sql, bindParams, {
             resultSet: true,
             autoCommit: compiledQuery.autoCommit,
             outFormat: OUT_FORMAT_OBJECT,
             ...this.#executeOptions,
+            ...(chunkSize != null ? { fetchArraySize: chunkSize } : {}),
         });
         const rs = result.resultSet;
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.0-dev.11",
+  "version": "7.1.0-dev.12",
   "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.11"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.11"
+    "@mikro-orm/core": "7.1.0-dev.12"
   },
   "engines": {
     "node": ">= 22.17.0"

package/query/QueryBuilder.d.ts

@@ -11,6 +11,20 @@ export interface ExecuteOptions {
     mergeResults?: boolean;
 }
 export interface QBStreamOptions {
+    /**
+     * How many rows to fetch in one round-trip.
+     * Lower values will result in more queries and network bandwidth, but less memory usage.
+     * Higher values will result in fewer queries and network bandwidth, but higher memory usage.
+     * Note that the results are iterated one row at a time regardless of this value.
+     *
+     * Honored on PostgreSQL (cursor-based fetch), MSSQL (tedious stream chunk size)
+     * and Oracle (mapped to `fetchArraySize`). Ignored on MySQL, MariaDB, SQLite and
+     * libSQL, where the underlying driver already streams row-by-row with no batching
+     * knob.
+     *
+     * @default 100 on dialects that honor it.
+     */
+    chunkSize?: number;
     /**
      * Results are mapped to entities, if you set `mapResults: false` you will get POJOs instead.
      *

package/query/QueryBuilder.js

@@ -1064,9 +1064,10 @@ export class QueryBuilder {
         options ??= {};
         options.mergeResults ??= true;
         options.mapResults ??= true;
+        const chunkSize = options.chunkSize ?? 100;
         const query = this.toQuery();
         const loggerContext = { id: this.em?.id, ...this.loggerContext };
-        const res = this.getConnection().stream(query.sql, query.params, this.context, loggerContext);
+        const res = this.getConnection().stream(query.sql, query.params, this.context, loggerContext, chunkSize);
         const meta = this.mainAlias.meta;
         if (options.rawResults || !meta) {
             yield* res;