node-firebird 2.11.0 → 2.13.0

package/lib/wire/codepages.js

@@ -0,0 +1,137 @@
+"use strict";
+/***************************************
+ *
+ *   Single-byte codepage codecs (WIN125x, ISO8859_x, KOI8, DOS866)
+ *
+ *   Node's Buffer only decodes utf8/latin1/ascii natively. These
+ *   codepages are decoded through the WHATWG TextDecoder (backed by
+ *   ICU — present in every official Node build) and encoded through
+ *   reverse tables built from the same decoder at first use, so the
+ *   two directions can never disagree. Issues #319/#301/#422.
+ *
+ ***************************************/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.charsetWidthById = charsetWidthById;
+exports.getCodec = getCodec;
+/** Firebird charset name → WHATWG encoding label (single-byte only). */
+const ICU_LABELS = Object.freeze({
+    WIN1250: 'windows-1250',
+    WIN1251: 'windows-1251',
+    WIN1253: 'windows-1253',
+    WIN1254: 'windows-1254',
+    WIN1255: 'windows-1255',
+    WIN1256: 'windows-1256',
+    WIN1257: 'windows-1257',
+    WIN1258: 'windows-1258',
+    ISO8859_2: 'iso-8859-2',
+    ISO8859_3: 'iso-8859-3',
+    ISO8859_4: 'iso-8859-4',
+    ISO8859_5: 'iso-8859-5',
+    ISO8859_6: 'iso-8859-6',
+    ISO8859_7: 'iso-8859-7',
+    ISO8859_8: 'iso-8859-8',
+    ISO8859_9: 'iso-8859-9',
+    ISO8859_13: 'iso-8859-13',
+    KOI8R: 'koi8-r',
+    KOI8U: 'koi8-u',
+    DOS866: 'ibm866',
+});
+/**
+ * Bytes-per-character by Firebird charset id (RDB$CHARACTER_SETS —
+ * verified against a live server). Everything not listed (NONE, ASCII,
+ * ISO8859_x, WIN125x, DOS*, KOI8*, CYRL, TIS620, …) is single-byte.
+ */
+const CHARSET_WIDTH_BY_ID = Object.freeze({
+    3: 3, // UNICODE_FSS
+    4: 4, // UTF8
+    5: 2, // SJIS_0208
+    6: 2, // EUCJ_0208
+    44: 2, // KSC_5601
+    56: 2, // BIG_5
+    57: 2, // GB_2312
+    67: 2, // GBK
+    68: 2, // CP943C
+    69: 4, // GB18030
+});
+function charsetWidthById(id) {
+    if (id === undefined) {
+        return 1;
+    }
+    return CHARSET_WIDTH_BY_ID[id] || 1;
+}
+const cache = new Map();
+function buildCodec(name) {
+    const label = ICU_LABELS[name];
+    if (!label) {
+        return null;
+    }
+    let decoder;
+    try {
+        decoder = new TextDecoder(label);
+    }
+    catch {
+        // Node built with small-icu: legacy encodings unavailable
+        return null;
+    }
+    // Build both directions from the decoder, one byte at a time — every
+    // byte of a single-byte codepage maps to exactly one BMP character
+    // (undefined bytes decode to U+FFFD, which is kept for decoding but
+    // never used for the reverse map).
+    const toCode = new Uint16Array(256);
+    const toByte = new Map();
+    const one = Buffer.alloc(1);
+    for (let i = 0; i < 256; i++) {
+        one[0] = i;
+        const ch = decoder.decode(one);
+        toCode[i] = ch.charCodeAt(0);
+        if (ch !== '�' && !toByte.has(ch)) {
+            toByte.set(ch, i);
+        }
+    }
+    return {
+        name,
+        decode(buffer) {
+            // batch through fromCharCode instead of per-byte string concat —
+            // wide CHAR columns and text blobs decode in O(chunks) allocations
+            const codes = new Array(buffer.length);
+            for (let i = 0; i < buffer.length; i++) {
+                codes[i] = toCode[buffer[i]];
+            }
+            const CHUNK = 4096;
+            if (codes.length <= CHUNK) {
+                return String.fromCharCode(...codes);
+            }
+            let out = '';
+            for (let i = 0; i < codes.length; i += CHUNK) {
+                out += String.fromCharCode(...codes.slice(i, i + CHUNK));
+            }
+            return out;
+        },
+        encode(value) {
+            const out = Buffer.alloc(value.length);
+            for (let i = 0; i < value.length; i++) {
+                const b = toByte.get(value[i]);
+                // unmappable characters become '?' — the convention every
+                // codepage transcoder (incl. iconv) uses by default
+                out[i] = b === undefined ? 0x3f : b;
+            }
+            return out;
+        },
+    };
+}
+/**
+ * Codec for a Firebird charset name, or null when the charset is unknown,
+ * natively handled by Buffer, or the ICU tables are unavailable. Cached.
+ */
+function getCodec(charsetName) {
+    if (!charsetName) {
+        return null;
+    }
+    const name = String(charsetName).toUpperCase();
+    let codec = cache.get(name);
+    if (codec === undefined) {
+        codec = buildCodec(name);
+        cache.set(name, codec);
+    }
+    return codec;
+}

package/lib/wire/connection.d.ts

@@ -78,6 +78,17 @@ declare class Connection {
      */
     releaseStatement(statement: Statement, callback?: QueueCallback): void;
     _rejectPending(err: any): void;
+    /**
+     * Deliver a connection-level error to 'error' listeners — and ONLY to
+     * listeners. Emitting an unlistened 'error' makes Node throw the error
+     * object as an uncaught exception; for errors that originate in
+     * background contexts (the reconnect timer, socket-level failures whose
+     * operations are separately rejected via _rejectPending) that crashes
+     * the process — or, under a test runner, fails whatever unrelated test
+     * happens to be running. The failing operations themselves always
+     * still receive their error through their own callbacks.
+     */
+    _emitError(err: any): void;
     _bind_events(host: string, port: number, callback: SimpleCallback | undefined): void;
     disconnect(): void;
     sendOpContAuth(authData: string, authDataEnc: BufferEncoding, pluginName: string): void;
@@ -120,24 +131,53 @@ declare class Connection {
      * gets an in-order response (op_batch_cs for exec), so the regular
      * response queue keeps everything in sync.
      *
-     * rows: array of parameter arrays, one per record. BLOB/ARRAY columns
-     * are not supported yet. The callback receives a completion object:
-     * { recordCount, updateCounts, errors: [{recordNumber, error}],
-     *   errorRecordNumbers, success }.
+     * rows: array of parameter arrays, one per record. BLOB columns accept
+     * Buffers, strings, JSON-able objects or pre-created blob quad ids —
+     * values are uploaded as transaction blobs first (all initiated
+     * back-to-back so they pipeline) and the batch messages reference their
+     * ids. ARRAY columns are not supported. The callback receives a
+     * completion object: { recordCount, updateCounts, errors:
+     * [{recordNumber, error}], errorRecordNumbers, success }.
      */
     executeBatch(transaction: Transaction, statement: Statement, rows: QueryParams[], callback: BatchCb | undefined, options?: BatchOptions): this | undefined;
+    /** Encode and send the batch packets (rows are fully materialized:
+     *  blob values already replaced by quad ids by executeBatch). */
+    _executeBatchEncoded(transaction: Transaction, statement: Statement, rows: any[][], callback: BatchCb | undefined, options: BatchOptions): void;
     /** `params` may be the callback itself when the statement has no parameters. */
     executeStatement(transaction: Transaction, statement: Statement, params: any, callback?: QueueCallback, custom?: InternalQueryOptions): this | undefined;
     sendExecute(op: number, statement: Statement, transaction: Transaction, callback: QueueCallback | undefined, parameters?: any[]): void;
     /** `count` may be the callback itself when no fetch size is given. */
     fetch(statement: Statement, transaction: Transaction, count: any, callback?: QueueCallback): void;
     fetchScroll(statement: Statement, transaction: Transaction, direction: string | number, offset: any, count: any, callback?: QueueCallback): void;
+    /**
+     * Query runtime information about a prepared statement via op_info_sql
+     * (e.g. Const.RECORDS_INFO for the per-verb DML row counts). The
+     * response is a plain op_response whose buffer holds the info clusters.
+     */
+    statementInfo(statement: Statement, items: number[], callback?: QueueCallback): this | undefined;
+    /**
+     * Resolve the pending blobAsText fetches of a decoded row batch
+     * (ret.arrBlob) and write the text back into ret.data. Reads run
+     * sequentially to respect Firebird's per-connection open-blob-handle
+     * limit (issue #387). Used by fetchAll for cursors and by
+     * transaction.execute for op_execute2 singletons (EXECUTE PROCEDURE /
+     * RETURNING — issue #305, whose blobs never resolved before).
+     */
+    resolveTextBlobs(transaction: Transaction, ret: any, callback: (err?: any) => void): void;
     fetchAll(statement: Statement, transaction: Transaction, callback: Callback<any[]>): void;
     openBlob(blob: Quad, transaction: Transaction, callback: QueueCallback): void;
     closeBlob(blob: any, callback?: QueueCallback, defer?: boolean): void;
     getSegment(blob: any, callback: QueueCallback): void;
     createBlob2(transaction: Transaction, callback: QueueCallback): void;
     batchSegments(blob: any, buffer: Buffer, callback: QueueCallback): void;
+    /**
+     * Create a transaction blob, upload `value` (Buffer, string, or a
+     * JSON-able object) and deliver its quad id. executeBatch's blob
+     * pre-pass uses this: batch messages reference pre-created transaction
+     * blobs (the batch parameter buffer's default BLOB_NONE policy), just
+     * like the classic execute path stores blob params.
+     */
+    uploadBlob(transaction: Transaction, value: any, callback: (err: any, oid?: any) => void): void;
     svcattach(options: InternalOptions, callback?: Callback<ServiceManager>, svc?: ServiceManager): void;
     svcstart(spbaction: BlrWriter, callback: QueueCallback | undefined): void;
     svcquery(spbquery: number[], resultbuffersize: number, timeout: number | undefined, callback: QueueCallback | undefined): void;