firebird-wasm 0.9.0 → 0.10.1

package/dist/firebird.js

@@ -1,10 +1,47 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FirebirdTransaction = exports.FirebirdLite = void 0;
+const os = __importStar(require("os"));
 const node_firebird_driver_1 = require("node-firebird-driver");
 const statement_types_1 = require("./statement-types");
+const field_types_1 = require("./browser/field-types");
+const value_types_1 = require("./browser/value-types");
 const sql_tag_1 = require("./sql-tag");
 const batch_block_1 = require("./batch-block");
+const littleEndian = os.endianness() === 'LE';
 /** `isc_info_sql_stmt_select`: the statement type the shared read transaction runs. */
 const STMT_SELECT = 1;
 let nativeDriver;
@@ -71,6 +108,10 @@ class FirebirdLite {
             throw new RangeError('statementCache is a whole number of statements, 0 or more');
         }
         this.statementCacheSize = size;
+        this.types = options.types;
+    }
+    serialize(params) {
+        return (0, value_types_1.applySerializers)(params, this.types?.serializers);
     }
     /**
      * Lazily initialize the native client and open (or create) the database.
@@ -130,22 +171,22 @@ class FirebirdLite {
                 return shared;
         }
         await this.endReadTransaction();
+        const serializedParams = this.serialize(statement.params);
         const txOptions = buildTransactionOptions(options);
         const transaction = await attachment.startTransaction(txOptions);
+        let rows;
+        let fields;
         try {
             const lease = await this.statements.acquire(transaction, statement.sql);
             const stmt = lease.stmt;
-            let rows;
-            let fields;
             // Released in `finally`, not after the fetch: a statement that throws on
             // execute — a lock conflict, an overflow, a wrong parameter count — would
             // otherwise leak its handle, and the retry loop such failures are usually
             // wrapped in leaks one per attempt until the attachment refuses more.
             let failed = true;
             try {
-                const columnLabels = await stmt.columnLabels;
-                fields = columnLabels.map((label) => ({ name: label }));
-                rows = shapeRows(await fetchRows(stmt, transaction, statement.params, fields.length), fields, rowMode);
+                fields = await outputFields(stmt);
+                rows = shapeRows(await fetchRows(stmt, transaction, serializedParams, fields, this.types), fields, rowMode);
                 failed = false;
             }
             finally {
@@ -154,12 +195,70 @@ class FirebirdLite {
             // After the statement is disposed, as before — the commit is the last
             // thing that happens on the success path.
             await transaction.commit();
-            return { rows, fields };
         }
         catch (err) {
             await transaction.rollback().catch(() => undefined);
             throw err;
         }
+        return (0, value_types_1.applyTypes)({ rows, fields }, this.types, rowMode);
+    }
+    queryStream(sql, paramsOrOptions = [], maybeOptions = {}) {
+        const { statement, options } = (0, sql_tag_1.resolveQueryCall)(sql, paramsOrOptions, maybeOptions);
+        const batchSize = (0, sql_tag_1.resolveBatchSize)(options.batchSize);
+        return this.streamQuery(statement, options, batchSize);
+    }
+    async *streamQuery(statement, options, batchSize) {
+        await this.ensureReady();
+        const rowMode = options.rowMode ?? 'object';
+        const attachment = this.attachment;
+        await this.endReadTransaction();
+        const serializedParams = this.serialize(statement.params);
+        const txOptions = buildTransactionOptions(options);
+        const transaction = await attachment.startTransaction(txOptions);
+        let engineFailed = false;
+        let lease;
+        let txFinished = false;
+        try {
+            try {
+                lease = await this.statements.acquire(transaction, statement.sql);
+            }
+            catch (err) {
+                engineFailed = true;
+                throw err;
+            }
+            const stmt = lease.stmt;
+            let fields;
+            try {
+                fields = await outputFields(stmt);
+            }
+            catch (err) {
+                engineFailed = true;
+                throw err;
+            }
+            yield* streamRows(stmt, transaction, serializedParams, fields, rowMode, batchSize, this.types, () => {
+                engineFailed = true;
+            });
+            const toRelease = lease;
+            lease = undefined;
+            await toRelease.release(false);
+            txFinished = true;
+            await transaction.commit();
+        }
+        finally {
+            if (lease) {
+                await lease.release(engineFailed);
+            }
+            if (!txFinished) {
+                if (engineFailed) {
+                    await transaction.rollback().catch(() => undefined);
+                }
+                else {
+                    await transaction
+                        .commit()
+                        .catch(() => transaction.rollback().catch(() => undefined));
+                }
+            }
+        }
     }
     /**
      * Run a SELECT in the shared read-only transaction, starting it if need be.
@@ -171,6 +270,7 @@ class FirebirdLite {
      * next read starts afresh, and is thrown.
      */
     async sharedRead(sql, params, rowMode) {
+        const serializedParams = this.serialize(params);
         const attachment = this.attachment;
         this.readTransaction ?? (this.readTransaction = await attachment.startTransaction({
             isolation: node_firebird_driver_1.TransactionIsolation.READ_COMMITTED,
@@ -189,16 +289,15 @@ class FirebirdLite {
         const stmt = lease.stmt;
         // A writing SELECT stays kept: only the transaction was wrong for it.
         let failed = false;
+        let fields;
+        let rawRows;
         try {
             if ((await stmt.type) !== STMT_SELECT) {
                 this.remember(sql);
                 return undefined;
             }
-            const fields = (await stmt.columnLabels).map((label) => ({
-                name: label,
-            }));
-            const rawRows = await fetchRows(stmt, transaction, params, fields.length);
-            return { rows: shapeRows(rawRows, fields, rowMode), fields };
+            fields = await outputFields(stmt);
+            rawRows = await fetchRows(stmt, transaction, serializedParams, fields, this.types);
         }
         catch (err) {
             // The native driver's errors carry only the message text.
@@ -213,6 +312,7 @@ class FirebirdLite {
         finally {
             await lease.release(failed);
         }
+        return (0, value_types_1.applyTypes)({ rows: shapeRows(rawRows, fields, rowMode), fields }, this.types, rowMode);
     }
     remember(sql) {
         if (this.ownTransaction.size >= 1024)
@@ -239,19 +339,16 @@ class FirebirdLite {
      *
      * ```ts
      * const shape = await db.describeQuery('SELECT id, name FROM items WHERE id = ?');
-     * // shape.fields        → [{ name: 'ID' }, { name: 'NAME' }]
+     * // shape.fields        → [{ name: 'ID', type: 496, typeName: 'INTEGER', ... }, ...]
      * // shape.statementType → 'SELECT'
      * ```
      *
      * The statement is prepared and disposed, so nothing runs: describing an
      * `INSERT` inserts nothing.
      *
-     * **`params` is `undefined` here.** The native driver exposes no input
-     * metadata — `Statement` offers `columnLabels`, `hasResultSet` and `type`
-     * and nothing about `?` placeholders — and an empty array would claim the
-     * statement takes none. `fields` carries names only, for the same reason
-     * `FieldInfo` does everywhere on this backend. The WASM backend reports both
-     * in full.
+     * **`params` is `undefined` here.** The native driver exposes no public input
+     * metadata, and an empty array would claim the statement takes none. `fields`
+     * carries the full {@link FieldInfo} from the prepared output metadata.
      */
     async describeQuery(sql) {
         await this.ensureReady();
@@ -261,11 +358,11 @@ class FirebirdLite {
         try {
             const stmt = await attachment.prepare(transaction, text);
             try {
-                const columnLabels = await stmt.columnLabels;
+                const fields = await outputFields(stmt);
                 const type = await stmt.type;
                 return {
                     params: undefined,
-                    fields: columnLabels.map((label) => ({ name: label })),
+                    fields,
                     statementType: (0, statement_types_1.statementKind)(type),
                     hasResultSet: stmt.hasResultSet,
                 };
@@ -294,7 +391,7 @@ class FirebirdLite {
         const transaction = await attachment.startTransaction(txOptions);
         // A shared read made from inside the callback starts the shared
         // transaction again; each statement here ends it first.
-        const tx = new FirebirdTransaction(attachment, transaction, () => this.endReadTransaction(), this.statements ?? undefined);
+        const tx = new FirebirdTransaction(attachment, transaction, () => this.endReadTransaction(), this.statements ?? undefined, this.types);
         let result;
         try {
             result = await fn(tx);
@@ -340,13 +437,17 @@ exports.FirebirdLite = FirebirdLite;
  * `FirebirdLite.transaction()`.
  */
 class FirebirdTransaction {
-    constructor(attachment, transaction, beforeStatement = async () => undefined, statements = new StatementCache(attachment, 0)) {
+    constructor(attachment, transaction, beforeStatement = async () => undefined, statements = new StatementCache(attachment, 0), types) {
         this.attachment = attachment;
         this.transaction = transaction;
         this.beforeStatement = beforeStatement;
         this.statements = statements;
+        this.types = types;
         this.finished = false;
     }
+    serialize(params) {
+        return (0, value_types_1.applySerializers)(params, this.types?.serializers);
+    }
     /** Whether this transaction has already been rolled back. */
     get isFinished() {
         return this.finished;
@@ -376,14 +477,15 @@ class FirebirdTransaction {
         this.assertUsable();
         await this.beforeStatement();
         const statement = (0, sql_tag_1.toStatement)(sql, params);
+        const serialized = this.serialize(statement.params);
         // With the cache off, a statement without parameters runs as it always
         // did. With it on, every statement goes through the cache, which is also
         // what sees DDL coming and empties itself first.
-        if (statement.params.length > 0 || this.statements.enabled) {
+        if (serialized.length > 0 || this.statements.enabled) {
             const lease = await this.statements.acquire(this.transaction, statement.sql);
             let failed = true;
             try {
-                await lease.stmt.execute(this.transaction, await bindParams(lease.stmt, this.transaction, statement.params));
+                await lease.stmt.execute(this.transaction, await bindParams(lease.stmt, this.transaction, serialized));
                 failed = false;
             }
             finally {
@@ -406,15 +508,23 @@ class FirebirdTransaction {
         }
         if (rows.length === 0)
             return;
+        const serializedRows = this.types?.serializers?.length
+            ? rows.map((row) => this.serialize(row))
+            : rows;
         const lease = await this.statements.acquire(this.transaction, sql);
         let failed = true;
         try {
-            const plan = rows.length > 1 ? await this.blockPlan(sql, lease.stmt) : undefined;
+            if (serializedRows.length > 1 &&
+                (await tryExecuteNativeBatch(lease.stmt, this.transaction, serializedRows))) {
+                failed = false;
+                return;
+            }
+            const plan = serializedRows.length > 1 ? await this.blockPlan(sql, lease.stmt) : undefined;
             if (plan) {
-                await this.executeInBlocks(lease.stmt, plan, rows);
+                await this.executeInBlocks(lease.stmt, plan, serializedRows);
             }
             else {
-                for (const row of rows) {
+                for (const row of serializedRows) {
                     await lease.stmt.execute(this.transaction, await bindParams(lease.stmt, this.transaction, row));
                 }
             }
@@ -434,7 +544,7 @@ class FirebirdTransaction {
         // INSERT, UPDATE, DELETE, EXECUTE PROCEDURE; nothing with a result.
         if (![2, 3, 4, 8].includes(type) || stmt.hasResultSet)
             return undefined;
-        if ((await stmt.columnLabels).length > 0)
+        if ((await outputFields(stmt)).length > 0)
             return undefined;
         const params = await inputParams(stmt);
         const offsets = (0, batch_block_1.placeholderOffsets)(sql);
@@ -500,6 +610,7 @@ class FirebirdTransaction {
         this.assertUsable();
         await this.beforeStatement();
         const statement = (0, sql_tag_1.toStatement)(sql, params);
+        const serialized = this.serialize(statement.params);
         const rowMode = options.rowMode ?? 'object';
         const lease = await this.statements.acquire(this.transaction, statement.sql);
         const stmt = lease.stmt;
@@ -507,18 +618,47 @@ class FirebirdTransaction {
         // throws must still be released. More so here, because a transaction
         // callback that catches its own errors goes on using the same attachment.
         let failed = true;
+        let fields;
+        let rawRows;
         try {
-            const columnLabels = await stmt.columnLabels;
-            const fields = columnLabels.map((label) => ({
-                name: label,
-            }));
-            const rawRows = await fetchRows(stmt, this.transaction, statement.params, fields.length);
+            fields = await outputFields(stmt);
+            rawRows = await fetchRows(stmt, this.transaction, serialized, fields, this.types);
             failed = false;
-            return { rows: shapeRows(rawRows, fields, rowMode), fields };
         }
         finally {
             await lease.release(failed);
         }
+        return (0, value_types_1.applyTypes)({ rows: shapeRows(rawRows, fields, rowMode), fields }, this.types, rowMode);
+    }
+    queryStream(sql, paramsOrOptions = [], maybeOptions = {}) {
+        this.assertUsable();
+        const { statement, options } = (0, sql_tag_1.resolveQueryCall)(sql, paramsOrOptions, maybeOptions);
+        const batchSize = (0, sql_tag_1.resolveBatchSize)(options.batchSize);
+        return this.streamQuery(statement, options.rowMode ?? 'object', batchSize);
+    }
+    async *streamQuery(statement, rowMode, batchSize) {
+        this.assertUsable();
+        await this.beforeStatement();
+        const serialized = this.serialize(statement.params);
+        let engineFailed = false;
+        const lease = await this.statements.acquire(this.transaction, statement.sql);
+        const stmt = lease.stmt;
+        try {
+            let fields;
+            try {
+                fields = await outputFields(stmt);
+            }
+            catch (err) {
+                engineFailed = true;
+                throw err;
+            }
+            yield* streamRows(stmt, this.transaction, serialized, fields, rowMode, batchSize, this.types, () => {
+                engineFailed = true;
+            });
+        }
+        finally {
+            await lease.release(engineFailed);
+        }
     }
 }
 exports.FirebirdTransaction = FirebirdTransaction;
@@ -535,10 +675,38 @@ async function bindingOf(stmt) {
         // Read before anything here rewrites the message; a statement is used
         // by one call at a time, so nothing else reads it meanwhile.
         binding = { params: await readInputParams(stmt), variants: new Map(), current: '' };
+        await setupOutput(stmt, binding);
         bindings.set(stmt, binding);
     }
     return binding;
 }
+/**
+ * Return a fresh copy of `stmt`'s output column metadata (`FieldInfo[]`).
+ *
+ * When the native driver's prepared output metadata is available, each entry
+ * carries `type`, `typeName`, `subType`, `scale`, `length` and `nullable`,
+ * matching `FirebirdBrowser`. Falls back to `stmt.fields` (for unit test stubs)
+ * or `stmt.columnLabels` (names only).
+ */
+async function outputFields(stmt) {
+    const binding = await bindingOf(stmt);
+    if (binding.fields) {
+        return binding.fields.map((f) => ({ ...f }));
+    }
+    const mockFields = stmt.fields;
+    if (Array.isArray(mockFields)) {
+        binding.fields = mockFields.map((f) => ({
+            ...f,
+            ...(f.type !== undefined && f.typeName === undefined
+                ? { typeName: (0, field_types_1.firebirdTypeName)(f.type, f.scale ?? 0) }
+                : {}),
+        }));
+        return binding.fields.map((f) => ({ ...f }));
+    }
+    const columnLabels = await stmt.columnLabels;
+    binding.fields = columnLabels.map((label) => ({ name: label }));
+    return binding.fields.map((f) => ({ ...f }));
+}
 /**
  * A statement's `?` parameters: its input metadata as the driver rewrote it
  * (CHAR as VARCHAR, the zoned types in their `_EX` forms), except that an
@@ -594,25 +762,397 @@ async function readInputParams(stmt) {
         return undefined;
     }
 }
-/** `SQL_BLOB`, without the nullable bit. */
-const SQL_BLOB = 520;
-/** `SQL_DOUBLE`: what the driver binds every integer and NUMERIC as. */
+// Firebird SQL type codes (without the nullable low bit).
+const SQL_TEXT = 452;
+const SQL_VARYING = 448;
+const SQL_SHORT = 500;
+const SQL_LONG = 496;
+const SQL_FLOAT = 482;
 const SQL_DOUBLE = 480;
+const SQL_D_FLOAT = 530;
+const SQL_TIMESTAMP = 510;
+const SQL_BLOB = 520;
+const SQL_TYPE_TIME = 560;
+const SQL_TYPE_DATE = 570;
+const SQL_INT64 = 580;
+const SQL_TIMESTAMP_TZ = 32754;
+const SQL_TIME_TZ = 32756;
+const SQL_INT128 = 32752;
+const SQL_DEC16 = 32760;
+const SQL_DEC34 = 32762;
+const SQL_BOOLEAN = 32764;
+const SQL_NULL = 32766;
 /** SMALLINT, INTEGER, BIGINT, and NUMERIC / DECIMAL kept in them. */
-const INTEGER_TYPES = new Set([500, 496, 580]);
-/** `SQL_VARYING`. */
-const SQL_VARYING = 448;
-/** Character set id of UTF8. */
+const INTEGER_TYPES = new Set([SQL_SHORT, SQL_LONG, SQL_INT64]);
+/** Character set ids from Firebird's `RDB$CHARACTER_SETS`. */
+const CHARSET_OCTETS = 1;
+const CS_UNICODE_FSS = 3;
 const CS_UTF8 = 4;
+/** `Number.MAX_SAFE_INTEGER` as a `bigint`: beyond this, IEEE-754 doubles round. */
+const SAFE_INT64 = 9007199254740991n;
+/**
+ * Firebird 4+ output types whose binary format needs `IUtil` (`IInt128`,
+ * `IDecFloat16`/`34`, `decodeTimeTz`/`decodeTimeStampTz`): coerced in the
+ * output message to `SQL_VARYING` so Firebird formats them directly.
+ */
+const COERCE_TO_VARYING = new Set([
+    SQL_INT128,
+    SQL_DEC16,
+    SQL_DEC34,
+    SQL_TIME_TZ,
+    SQL_TIMESTAMP_TZ,
+]);
 /**
  * DATE, TIME, TIMESTAMP, and TIME / TIMESTAMP WITH TIME ZONE in both forms
  * (the driver rewrites the zoned ones to their `_EX` forms).
  */
 const DATE_TIME_TYPES = new Set([570, 560, 510, 32756, 32754, 32750, 32748]);
 /** The types a string is sent to as text, for Firebird to convert. */
-const TEXT_TYPES = new Set([...DATE_TIME_TYPES, ...INTEGER_TYPES]);
+const TEXT_TYPES = new Set([
+    ...DATE_TIME_TYPES,
+    ...INTEGER_TYPES,
+    SQL_INT128,
+    SQL_DEC16,
+    SQL_DEC34,
+    SQL_BOOLEAN,
+]);
 /** Bytes a value takes as text: a timestamp with the longest zone name fits twice. */
 const TEXT_LENGTH = 128;
+/**
+ * Replace the driver's `outMetadata` and `dataReader` on `stmt` with ones built
+ * from Firebird's prepared output metadata.
+ *
+ * `node-firebird-driver-native`'s `fixMetadata` rewrites `SMALLINT`, `INTEGER`,
+ * `BIGINT`, `FLOAT`, `NUMERIC` and `DECIMAL` to `SQL_DOUBLE` (losing precision
+ * on `BIGINT` past 2^53 and turning exact `NUMERIC`/`DECIMAL` values into
+ * floats), decodes `DATE`/`TIME`/`TIMESTAMP` into local-timezone `Date`
+ * objects (truncating 100 µs fractions), and returns raw `Blob` handles that
+ * expire when `query()` commits its transaction. Keeping the prepared types and
+ * decoding them with the same rules as `fb_wasm_api.cpp` gives Node and
+ * browser queries identical wire values and `FieldInfo` metadata.
+ */
+async function setupOutput(stmt, binding) {
+    const internal = stmt;
+    const client = internal.attachment?.client;
+    if (typeof internal.statementHandle?.getOutputMetadataAsync !== 'function' ||
+        typeof client?.statusAction !== 'function') {
+        return;
+    }
+    if (!internal.outMetadata) {
+        binding.fields = [];
+        return;
+    }
+    try {
+        await client.statusAction(async (status) => {
+            const prepared = await internal.statementHandle.getOutputMetadataAsync(status);
+            if (!prepared) {
+                binding.fields = [];
+                return;
+            }
+            try {
+                const count = prepared.getCountSync(status);
+                if (count === 0) {
+                    binding.fields = [];
+                    return;
+                }
+                const fields = [];
+                const builder = prepared.getBuilderSync(status);
+                let outMetadata;
+                try {
+                    for (let i = 0; i < count; i++) {
+                        const rawType = prepared.getTypeSync(status, i);
+                        const type = rawType & ~1;
+                        const subType = prepared.getSubTypeSync(status, i);
+                        const scale = prepared.getScaleSync(status, i);
+                        const length = prepared.getLengthSync(status, i);
+                        const nullable = typeof prepared.isNullableSync === 'function'
+                            ? Boolean(prepared.isNullableSync(status, i))
+                            : (rawType & 1) !== 0;
+                        const name = typeof prepared.getAliasSync === 'function'
+                            ? prepared.getAliasSync(status, i)
+                            : '';
+                        fields.push({
+                            name,
+                            type,
+                            typeName: (0, field_types_1.firebirdTypeName)(type, scale),
+                            subType,
+                            scale,
+                            length,
+                            nullable,
+                        });
+                        if (COERCE_TO_VARYING.has(type)) {
+                            builder.setTypeSync(status, i, SQL_VARYING);
+                            builder.setSubTypeSync(status, i, 0);
+                            builder.setLengthSync(status, i, 64);
+                            builder.setCharSetSync(status, i, CS_UTF8);
+                            builder.setScaleSync(status, i, 0);
+                        }
+                        else if (type === SQL_D_FLOAT) {
+                            builder.setTypeSync(status, i, SQL_DOUBLE);
+                            builder.setLengthSync(status, i, 8);
+                            builder.setScaleSync(status, i, 0);
+                        }
+                    }
+                    outMetadata = builder.getMetadataSync(status);
+                }
+                finally {
+                    builder.releaseSync();
+                }
+                const descriptors = [];
+                for (let i = 0; i < count; i++) {
+                    descriptors.push({
+                        msgType: outMetadata.getTypeSync(status, i) & ~1,
+                        preparedType: fields[i].type,
+                        subType: fields[i].subType ?? 0,
+                        scale: fields[i].scale ?? 0,
+                        length: outMetadata.getLengthSync(status, i),
+                        preparedLength: fields[i].length ?? 0,
+                        charSet: outMetadata.getCharSetSync(status, i),
+                        preparedCharSet: prepared.getCharSetSync(status, i),
+                        offset: outMetadata.getOffsetSync(status, i),
+                        nullOffset: outMetadata.getNullOffsetSync(status, i),
+                    });
+                }
+                binding.fields = fields;
+                binding.outDescriptors = descriptors;
+                binding.originalOut = {
+                    outMetadata: internal.outMetadata,
+                    outBuffer: internal.outBuffer,
+                    dataReader: internal.dataReader,
+                };
+                binding.customOut = outMetadata;
+                hookDispose(internal, binding);
+                internal.outMetadata = outMetadata;
+                internal.outBuffer = new Uint8Array(outMetadata.getMessageLengthSync(status));
+                internal.dataReader = createOutputDataReader(descriptors);
+            }
+            finally {
+                prepared.releaseSync();
+            }
+        });
+    }
+    catch {
+        // Fall back to the driver's own output metadata if internals differ.
+    }
+}
+function createOutputDataReader(descriptors) {
+    return async (attachment, _transaction, buffer) => {
+        const dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+        const row = new Array(descriptors.length);
+        for (let i = 0; i < descriptors.length; i++) {
+            const d = descriptors[i];
+            if (dataView.getInt16(d.nullOffset, littleEndian) === -1) {
+                row[i] = null;
+            }
+            else {
+                row[i] = readColumnValue(d, attachment, buffer, dataView);
+            }
+        }
+        return row;
+    };
+}
+function readColumnValue(d, attachment, buffer, dataView) {
+    switch (d.msgType) {
+        case SQL_TEXT: {
+            const raw = buffer.subarray(d.offset, d.offset + d.length);
+            if ((d.preparedCharSet & 0xff) === CHARSET_OCTETS) {
+                return Buffer.from(raw);
+            }
+            const byteLen = charTextLength(raw, d.length, d.preparedCharSet);
+            return decodeText(raw.subarray(0, byteLen), d.preparedCharSet, attachment);
+        }
+        case SQL_VARYING: {
+            const varLength = dataView.getUint16(d.offset, littleEndian);
+            const raw = buffer.subarray(d.offset + 2, d.offset + 2 + varLength);
+            if ((d.preparedCharSet & 0xff) === CHARSET_OCTETS) {
+                return Buffer.from(raw);
+            }
+            const text = decodeText(raw, d.charSet, attachment);
+            if (d.preparedType === SQL_TIMESTAMP_TZ) {
+                return text.replace(/^(\d{4}-\d{2}-\d{2}) /, '$1T');
+            }
+            return text;
+        }
+        case SQL_SHORT: {
+            const val = dataView.getInt16(d.offset, littleEndian);
+            return d.scale !== 0 ? formatScaledDecimal(BigInt(val), d.scale) : val;
+        }
+        case SQL_LONG: {
+            const val = dataView.getInt32(d.offset, littleEndian);
+            return d.scale !== 0 ? formatScaledDecimal(BigInt(val), d.scale) : val;
+        }
+        case SQL_INT64: {
+            const val = dataView.getBigInt64(d.offset, littleEndian);
+            if (d.scale !== 0)
+                return formatScaledDecimal(val, d.scale);
+            return val >= -SAFE_INT64 && val <= SAFE_INT64 ? Number(val) : val.toString();
+        }
+        case SQL_FLOAT: {
+            const val = dataView.getFloat32(d.offset, littleEndian);
+            return Number.isFinite(val) ? Number(val.toPrecision(9)) : null;
+        }
+        case SQL_DOUBLE: {
+            const val = dataView.getFloat64(d.offset, littleEndian);
+            return Number.isFinite(val) ? val : null;
+        }
+        case SQL_BOOLEAN:
+            return dataView.getInt8(d.offset) !== 0;
+        case SQL_TYPE_DATE:
+            return formatDate(dataView.getInt32(d.offset, littleEndian));
+        case SQL_TYPE_TIME:
+            return formatTime(dataView.getUint32(d.offset, littleEndian));
+        case SQL_TIMESTAMP:
+            return `${formatDate(dataView.getInt32(d.offset, littleEndian))}T${formatTime(dataView.getUint32(d.offset + 4, littleEndian))}`;
+        case SQL_BLOB:
+            return new node_firebird_driver_1.Blob(attachment, buffer.slice(d.offset, d.offset + 8));
+        case SQL_NULL:
+        default:
+            return null;
+    }
+}
+/**
+ * How many bytes of a `CHAR(n)` buffer represent its `n` characters.
+ * Mirrors `charTextLength` in `fb_wasm_api.cpp`.
+ */
+function charTextLength(data, length, charSet) {
+    const cs = charSet & 0xff;
+    const bytesPerChar = cs === CS_UTF8 ? 4 : cs === CS_UNICODE_FSS ? 3 : 1;
+    if (bytesPerChar === 1)
+        return length;
+    const chars = Math.floor(length / bytesPerChar);
+    let pos = 0;
+    for (let n = 0; n < chars && pos < length; n++) {
+        const c = data[pos];
+        pos += c < 0x80 ? 1 : (c >> 5) === 0x6 ? 2 : (c >> 4) === 0xe ? 3 : (c >> 3) === 0x1e ? 4 : 1;
+    }
+    return pos < length ? pos : length;
+}
+function decodeText(bytes, charSet, attachment) {
+    const buf = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if ((charSet & 0xff) === 0) {
+        const noneCharset = attachment?.charSetForNONE;
+        if (noneCharset && noneCharset.toLowerCase() !== 'utf8' && noneCharset.toLowerCase() !== 'utf-8') {
+            try {
+                return new TextDecoder(noneCharset).decode(bytes);
+            }
+            catch {
+                // fall through to utf8
+            }
+        }
+    }
+    return buf.toString('utf8');
+}
+/** Firebird `ISC_DATE` (days since 1858-11-17) to `'YYYY-MM-DD'`. */
+function formatDate(iscDate) {
+    let nday = (iscDate + 2400001 - 1721119) | 0;
+    const century = ((4 * nday - 1) / 146097) | 0;
+    nday = (4 * nday - 1 - 146097 * century) | 0;
+    let d = (nday / 4) | 0;
+    nday = ((4 * d + 3) / 1461) | 0;
+    d = (4 * d + 3 - 1461 * nday) | 0;
+    d = ((d + 4) / 4) | 0;
+    let m = ((5 * d - 3) / 153) | 0;
+    d = (5 * d - 3 - 153 * m) | 0;
+    d = ((d + 5) / 5) | 0;
+    let y = (100 * century + nday) | 0;
+    if (m < 10) {
+        m += 3;
+    }
+    else {
+        m -= 9;
+        y += 1;
+    }
+    return `${String(y).padStart(4, '0')}-${String(m).padStart(2, '0')}-${String(d).padStart(2, '0')}`;
+}
+/** Firebird `ISC_TIME` (1/10000 s since midnight) to `'HH:MM:SS.ffff'`. */
+function formatTime(iscTime) {
+    const hours = Math.floor(iscTime / 36000000);
+    let rem = iscTime % 36000000;
+    const minutes = Math.floor(rem / 600000);
+    rem %= 600000;
+    const seconds = Math.floor(rem / 10000);
+    const fractions = rem % 10000;
+    return (`${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:` +
+        `${String(seconds).padStart(2, '0')}.${String(fractions).padStart(4, '0')}`);
+}
+/** Scaled integer (`NUMERIC` / `DECIMAL`) to exact decimal string. */
+function formatScaledDecimal(value, scale) {
+    if (scale >= 0) {
+        return value === 0n ? '0' : `${value}${'0'.repeat(scale)}`;
+    }
+    const negative = value < 0n;
+    const digits = (negative ? -value : value).toString();
+    const decimals = -scale;
+    const padded = digits.length <= decimals ? digits.padStart(decimals + 1, '0') : digits;
+    const dot = padded.length - decimals;
+    return `${negative ? '-' : ''}${padded.slice(0, dot)}.${padded.slice(dot)}`;
+}
+/**
+ * Resolve `SQL_BLOB` handles and `OCTETS` byte buffers in `rawRows` after a
+ * fetch call completes (when no pipelined `fetchNextAsync` call is in flight
+ * on the attachment).
+ */
+async function resolveOutputRows(stmt, transaction, fields, rawRows, types) {
+    if (rawRows.length === 0)
+        return;
+    const binaryBlobs = types?.binary === true;
+    const attachment = stmt.attachment;
+    const outDescriptors = bindings.get(stmt)?.outDescriptors;
+    for (const row of rawRows) {
+        for (let i = 0; i < row.length; i++) {
+            const cell = row[i];
+            if (cell === null || cell === undefined)
+                continue;
+            const field = fields[i];
+            const type = (field?.type ?? 0) & ~1;
+            if (cell instanceof node_firebird_driver_1.Blob ||
+                (type === SQL_BLOB &&
+                    typeof cell === 'object' &&
+                    !(cell instanceof Uint8Array) &&
+                    'id' in cell)) {
+                if (typeof attachment?.openBlob !== 'function')
+                    continue;
+                const bytes = await readBlobBytes(attachment, transaction, cell);
+                if (field?.subType === 1) {
+                    const charSet = outDescriptors?.[i]?.preparedCharSet ?? CS_UTF8;
+                    row[i] = decodeText(bytes, charSet, attachment);
+                }
+                else {
+                    row[i] = binaryBlobs ? new Uint8Array(bytes) : bytes.toString('base64');
+                }
+            }
+            else if (Buffer.isBuffer(cell) || cell instanceof Uint8Array) {
+                const buf = Buffer.isBuffer(cell)
+                    ? cell
+                    : Buffer.from(cell.buffer, cell.byteOffset, cell.byteLength);
+                if (type === SQL_BLOB && field?.subType === 1) {
+                    row[i] = buf.toString('utf8');
+                }
+                else {
+                    row[i] = binaryBlobs ? new Uint8Array(buf) : buf.toString('base64');
+                }
+            }
+        }
+    }
+}
+async function readBlobBytes(attachment, transaction, blob) {
+    const stream = await attachment.openBlob(transaction, blob);
+    try {
+        const chunks = [];
+        for (;;) {
+            const buffer = Buffer.alloc(64 * 1024);
+            const n = await stream.read(buffer);
+            if (n < 0)
+                break;
+            if (n > 0)
+                chunks.push(buffer.subarray(0, n));
+        }
+        return Buffer.concat(chunks);
+    }
+    finally {
+        await stream.close().catch(() => undefined);
+    }
+}
 /**
  * The parameters as the driver will take them, the statement made ready to
  * take them.
@@ -638,12 +1178,12 @@ const TEXT_LENGTH = 128;
  * so the same call now means the same there and here, to the last digit.
  * A `Date` still goes the driver's way.
  *
- * So does a string bound to a SMALLINT, INTEGER, BIGINT or NUMERIC parameter:
- * the driver binds those as doubles, and `'9007199254740993'` arrived as
- * 9007199254740992, `'0.1'` in a NUMERIC(18,17) as 0.10000000000000001.
- * A JS number still goes as a double (it is one); a string to a DOUBLE
- * PRECISION or FLOAT parameter is still converted by JS, which rounds
- * correctly.
+ * So does a string or `bigint` bound to a SMALLINT, INTEGER, BIGINT or
+ * NUMERIC parameter: the driver binds those as doubles, and
+ * `'9007199254740993'` arrived as 9007199254740992, `'0.1'` in a
+ * NUMERIC(18,17) as 0.10000000000000001. A JS number still goes as a double
+ * (it is one); a string to a DOUBLE PRECISION or FLOAT parameter is still
+ * converted by JS, which rounds correctly.
  */
 async function bindParams(stmt, transaction, given) {
     // Bytes as the driver takes them: a Buffer (the browser engine takes a
@@ -654,7 +1194,8 @@ async function bindParams(stmt, transaction, given) {
             : p instanceof Uint8Array && !Buffer.isBuffer(p) ? Buffer.from(p.buffer, p.byteOffset, p.byteLength) : p)
         : given;
     const binding = bindings.get(stmt);
-    if (!params.some((p) => typeof p === 'string' || Buffer.isBuffer(p)) && (!binding || binding.current === '')) {
+    if (!params.some((p) => typeof p === 'string' || typeof p === 'bigint' || Buffer.isBuffer(p)) &&
+        (!binding || binding.current === '')) {
         return params;
     }
     const described = (binding ?? (await bindingOf(stmt))).params;
@@ -663,7 +1204,11 @@ async function bindParams(stmt, transaction, given) {
     const text = [];
     const bound = [...params];
     for (let i = 0; i < bound.length; i++) {
-        const p = bound[i];
+        let p = bound[i];
+        if (typeof p === 'bigint') {
+            p = p.toString();
+            bound[i] = p;
+        }
         const type = (described[i]?.type ?? 0) & ~1;
         if (type === SQL_BLOB && (typeof p === 'string' || Buffer.isBuffer(p))) {
             bound[i] = await writeBlob(stmt, transaction, typeof p === 'string' ? Buffer.from(p, 'utf8') : p);
@@ -692,6 +1237,239 @@ async function writeBlob(stmt, transaction, bytes) {
     await stream.close();
     return stream.blob;
 }
+const XPB_BATCH = 5;
+const BATCH_VERSION1 = 1;
+const BATCH_TAG_RECORD_COUNTS = 2;
+const BATCH_TAG_BUFFER_BYTES_SIZE = 3;
+const BATCH_TAG_BLOB_POLICY = 4;
+const BATCH_BLOB_ID_ENGINE = 1;
+const BATCH_EXECUTE_FAILED = -1;
+/**
+ * Execute `rows` through Firebird 4+'s native `IBatch` interface
+ * (`statementHandle.createBatchAsync`, added in
+ * `asfernandes/node-firebird-drivers#178`).
+ *
+ * Returns `true` when the batch ran via `IBatch`, or `false` when the loaded
+ * `node-firebird-native-api` build or the connected server (e.g. Firebird 3)
+ * does not support `IBatch`, allowing `execBatch` to fall back to
+ * `EXECUTE BLOCK`.
+ */
+async function tryExecuteNativeBatch(stmt, transaction, rows) {
+    const internal = stmt;
+    const createBatchAsync = internal.statementHandle?.createBatchAsync;
+    const client = internal.attachment?.client;
+    const txHandle = transaction.transactionHandle;
+    if (typeof createBatchAsync !== 'function' ||
+        typeof client?.statusAction !== 'function' ||
+        txHandle === undefined) {
+        return false;
+    }
+    if (stmt.hasResultSet || (await outputFields(stmt)).length > 0) {
+        return false;
+    }
+    const described = await inputParams(stmt);
+    if (!described || described.length === 0) {
+        return false;
+    }
+    const paramCount = described.length;
+    for (const row of rows) {
+        if (row.length !== paramCount)
+            return false;
+    }
+    const textSet = new Set();
+    const blobCols = [];
+    for (let i = 0; i < paramCount; i++) {
+        const type = (described[i]?.type ?? 0) & ~1;
+        if (type === SQL_BLOB) {
+            blobCols.push(i);
+            continue;
+        }
+        if (!TEXT_TYPES.has(type))
+            continue;
+        let sawString = false;
+        let sawDate = false;
+        for (const row of rows) {
+            const v = row[i];
+            if (v === null || v === undefined)
+                continue;
+            if (typeof v === 'string' || typeof v === 'bigint') {
+                sawString = true;
+            }
+            else if (v instanceof Date || (typeof v === 'object' && v !== null && 'date' in v)) {
+                sawDate = true;
+            }
+        }
+        if (sawString && sawDate)
+            return false;
+        if (sawString)
+            textSet.add(i);
+    }
+    const textPositions = [...textSet].sort((a, b) => a - b);
+    if (!(await useMessage(stmt, textPositions))) {
+        return false;
+    }
+    const inMetadata = internal.inMetadata;
+    const inBuffer = internal.inBuffer;
+    const dataWriter = internal.dataWriter;
+    if (!inMetadata ||
+        !inBuffer ||
+        typeof inMetadata.getAlignedLengthSync !== 'function' ||
+        typeof dataWriter !== 'function') {
+        return false;
+    }
+    const hasBlobs = blobCols.length > 0;
+    let totalBlobBytes = 0;
+    const normalizedRows = new Array(rows.length);
+    const rowBlobs = hasBlobs ? new Array(rows.length) : undefined;
+    for (let r = 0; r < rows.length; r++) {
+        const src = rows[r];
+        const dst = new Array(paramCount);
+        const blobsForRow = hasBlobs ? new Array(paramCount).fill(null) : undefined;
+        for (let i = 0; i < paramCount; i++) {
+            let v = src[i];
+            if (v === undefined || v === null) {
+                dst[i] = null;
+                continue;
+            }
+            if (v instanceof ArrayBuffer) {
+                v = Buffer.from(v);
+            }
+            else if (v instanceof Uint8Array && !Buffer.isBuffer(v)) {
+                v = Buffer.from(v.buffer, v.byteOffset, v.byteLength);
+            }
+            else if (typeof v === 'bigint') {
+                v = v.toString();
+            }
+            if (hasBlobs && (described[i].type & ~1) === SQL_BLOB) {
+                if (typeof v === 'string') {
+                    const buf = Buffer.from(v, 'utf8');
+                    blobsForRow[i] = buf;
+                    totalBlobBytes += buf.byteLength;
+                    dst[i] = null;
+                    continue;
+                }
+                if (Buffer.isBuffer(v)) {
+                    blobsForRow[i] = v;
+                    totalBlobBytes += v.byteLength;
+                    dst[i] = null;
+                    continue;
+                }
+                return false;
+            }
+            if (textSet.has(i) && typeof v !== 'string') {
+                v = String(v);
+            }
+            dst[i] = v;
+        }
+        normalizedRows[r] = dst;
+        if (rowBlobs && blobsForRow)
+            rowBlobs[r] = blobsForRow;
+    }
+    return client.statusAction(async (status) => {
+        const stride = inMetadata.getAlignedLengthSync(status);
+        const msgLen = inMetadata.getMessageLengthSync(status);
+        if (stride <= 0 || msgLen <= 0)
+            return false;
+        const blobOffsets = hasBlobs
+            ? blobCols.map((col) => ({
+                col,
+                offset: inMetadata.getOffsetSync(status, col),
+                nullOffset: inMetadata.getNullOffsetSync(status, col),
+            }))
+            : [];
+        if (hasBlobs && typeof internal.statementHandle?.createBatchAsync === 'function') {
+            // Verify addBlobAsync will be present on the batch below.
+        }
+        const needed = stride * rows.length + totalBlobBytes + 4096;
+        let pb;
+        let parLength = 0;
+        let parBuffer;
+        try {
+            pb = client.util?.getXpbBuilderSync?.(status, XPB_BATCH, undefined, 0);
+            if (pb) {
+                pb.insertIntSync(status, BATCH_TAG_RECORD_COUNTS, 1);
+                if (hasBlobs) {
+                    pb.insertIntSync(status, BATCH_TAG_BLOB_POLICY, BATCH_BLOB_ID_ENGINE);
+                }
+                if (needed > 16 * 1024 * 1024) {
+                    pb.insertIntSync(status, BATCH_TAG_BUFFER_BYTES_SIZE, Math.min(256 * 1024 * 1024, needed));
+                }
+                parLength = pb.getBufferLengthSync(status);
+                parBuffer = pb.getBufferSync(status);
+            }
+            else {
+                const bytes = [BATCH_VERSION1, BATCH_TAG_RECORD_COUNTS, 4, 1, 0, 0, 0];
+                if (hasBlobs) {
+                    bytes.push(BATCH_TAG_BLOB_POLICY, 4, BATCH_BLOB_ID_ENGINE, 0, 0, 0);
+                }
+                const raw = new Uint8Array(bytes);
+                parLength = raw.byteLength;
+                parBuffer = raw;
+            }
+            let batch;
+            try {
+                batch = await createBatchAsync.call(internal.statementHandle, status, inMetadata, parLength, parBuffer);
+            }
+            catch {
+                // Unsupported by server (e.g. Firebird 3) or client library: fall back to EXECUTE BLOCK.
+                return false;
+            }
+            if (!batch)
+                return false;
+            if (hasBlobs && typeof batch.addBlobAsync !== 'function') {
+                await batch.closeAsync(status).catch(() => undefined);
+                return false;
+            }
+            try {
+                const messages = new Uint8Array(stride * rows.length);
+                const blobIdBuf = hasBlobs ? new Uint8Array(8) : undefined;
+                for (let r = 0; r < rows.length; r++) {
+                    inBuffer.fill(0);
+                    await dataWriter(internal.attachment, transaction, inBuffer, normalizedRows[r]);
+                    if (hasBlobs) {
+                        const blobsForRow = rowBlobs[r];
+                        for (const { col, offset, nullOffset } of blobOffsets) {
+                            const blobBytes = blobsForRow[col];
+                            if (!blobBytes)
+                                continue;
+                            blobIdBuf.fill(0);
+                            await batch.addBlobAsync(status, blobBytes.byteLength, blobBytes, blobIdBuf, 0, undefined);
+                            inBuffer[nullOffset] = 0;
+                            inBuffer[nullOffset + 1] = 0;
+                            inBuffer.set(blobIdBuf, offset);
+                        }
+                    }
+                    messages.set(inBuffer.subarray(0, msgLen), r * stride);
+                }
+                await batch.addAsync(status, rows.length, messages);
+                const completion = await batch.executeAsync(status, txHandle);
+                if (!completion) {
+                    throw new Error('IBatch.executeAsync returned no completion state');
+                }
+                try {
+                    const reported = completion.getSizeSync(status);
+                    for (let i = 0; i < reported; i++) {
+                        const state = completion.getStateSync(status, i);
+                        if (state === BATCH_EXECUTE_FAILED) {
+                            completion.getStatusSync(status, status, i);
+                            throw new Error(`IBatch execution failed at row ${i}`);
+                        }
+                    }
+                }
+                finally {
+                    completion.disposeSync();
+                }
+            }
+            finally {
+                await batch.closeAsync(status).catch(() => undefined);
+            }
+        }
+        finally {
+            pb?.disposeSync();
+        }
+        return true;
+    });
+}
 /**
  * Put in place the input message that takes the parameters at `positions`
  * as VARCHAR text and every other as the driver prepared it, making it the
@@ -721,7 +1499,7 @@ async function useMessage(stmt, positions) {
                 inBuffer: internal.inBuffer,
                 dataWriter: internal.dataWriter,
             };
-            releaseMessagesOnDispose(internal, binding);
+            hookDispose(internal, binding);
         }
         binding.variants.set(key, made);
         message = made;
@@ -777,13 +1555,17 @@ async function makeTextMessage(internal, binding, positions) {
     });
 }
 /**
- * Hand the driver back its own message when the statement is disposed, for
- * it to release as it always does, and release the ones made here.
+ * Hand the driver back its own input/output messages when the statement is
+ * disposed, for it to release as it always does, and release the ones made
+ * here.
  */
-function releaseMessagesOnDispose(internal, binding) {
+function hookDispose(internal, binding) {
+    if (binding.disposeHooked)
+        return;
     const dispose = internal.internalDispose;
     if (typeof dispose !== 'function')
         return;
+    binding.disposeHooked = true;
     internal.internalDispose = async function () {
         if (binding.original) {
             internal.inMetadata = binding.original.inMetadata;
@@ -794,6 +1576,15 @@ function releaseMessagesOnDispose(internal, binding) {
             message.inMetadata.releaseSync();
         binding.variants.clear();
         binding.current = '';
+        if (binding.customOut) {
+            if (binding.originalOut) {
+                internal.outMetadata = binding.originalOut.outMetadata;
+                internal.outBuffer = binding.originalOut.outBuffer;
+                internal.dataReader = binding.originalOut.dataReader;
+            }
+            binding.customOut.releaseSync();
+            binding.customOut = undefined;
+        }
         return dispose.call(this);
     };
 }
@@ -920,23 +1711,99 @@ class StatementCache {
  * `executeQuery` refused it outright inside a transaction. Anything else
  * runs and returns nothing.
  */
-async function fetchRows(stmt, transaction, params, columnCount) {
+async function fetchRows(stmt, transaction, params, fields, types) {
     params = await bindParams(stmt, transaction, params);
+    let rawRows;
     if (stmt.hasResultSet) {
         const resultSet = await stmt.executeQuery(transaction, params);
         // A failing fetch must still close.
         try {
-            return await resultSet.fetch();
+            rawRows = await resultSet.fetch();
         }
         finally {
             await resultSet.close().catch(() => undefined);
         }
     }
-    if (columnCount > 0) {
-        return [await stmt.executeSingleton(transaction, params)];
+    else if (fields.length > 0) {
+        rawRows = [await stmt.executeSingleton(transaction, params)];
+    }
+    else {
+        await stmt.execute(transaction, params);
+        return [];
+    }
+    await resolveOutputRows(stmt, transaction, fields, rawRows, types);
+    return rawRows;
+}
+/**
+ * Stream a prepared statement's result set in batches of up to `batchSize` rows.
+ */
+async function* streamRows(stmt, transaction, params, fields, rowMode, batchSize, types, onEngineError) {
+    let boundParams;
+    try {
+        boundParams = await bindParams(stmt, transaction, params);
+    }
+    catch (err) {
+        onEngineError();
+        throw err;
+    }
+    if (stmt.hasResultSet) {
+        let resultSet;
+        try {
+            resultSet = await stmt.executeQuery(transaction, boundParams);
+        }
+        catch (err) {
+            onEngineError();
+            throw err;
+        }
+        try {
+            while (true) {
+                let rawRows;
+                try {
+                    rawRows = await resultSet.fetch({ fetchSize: batchSize });
+                    await resolveOutputRows(stmt, transaction, fields, rawRows, types);
+                }
+                catch (err) {
+                    onEngineError();
+                    throw err;
+                }
+                if (rawRows.length === 0)
+                    break;
+                const batchFields = fields.map((f) => ({ ...f }));
+                yield (0, value_types_1.applyTypes)({
+                    rows: shapeRows(rawRows, batchFields, rowMode),
+                    fields: batchFields,
+                }, types, rowMode);
+            }
+        }
+        finally {
+            await resultSet.close().catch(() => undefined);
+        }
+        return;
+    }
+    if (fields.length > 0) {
+        let rawRows;
+        try {
+            rawRows = [await stmt.executeSingleton(transaction, boundParams)];
+            await resolveOutputRows(stmt, transaction, fields, rawRows, types);
+        }
+        catch (err) {
+            onEngineError();
+            throw err;
+        }
+        const batchFields = fields.map((f) => ({ ...f }));
+        yield (0, value_types_1.applyTypes)({
+            rows: shapeRows(rawRows, batchFields, rowMode),
+            fields: batchFields,
+        }, types, rowMode);
+        return;
+    }
+    try {
+        await stmt.execute(transaction, boundParams);
+    }
+    catch (err) {
+        onEngineError();
+        throw err;
     }
-    await stmt.execute(transaction, params);
-    return [];
 }
 /**
  * The driver hands back positional rows, so array mode is the shape that