node-firebird 2.8.1 → 2.10.0

package/lib/wire/connection.js

@@ -61,6 +61,112 @@ function parseValueIfJson(value, options) {
     }
     return value;
 }
+/**
+ * Resolve the prepared-statement cache limit from the connection options:
+ * `statementCacheSize` (new), or the legacy `cacheQuery`/`maxCachedQuery`
+ * pair (which had no eviction; it now gets a bounded LRU). 0 = disabled.
+ */
+/**
+ * Build the isc_dpb_search_path value from the defaultSchema / searchPath
+ * options (Firebird 6.0 / protocol 20+). There is no "default schema" DPB
+ * tag in Firebird: CURRENT_SCHEMA is simply the first existing schema of
+ * the search path, so defaultSchema is implemented by putting it at the
+ * front of the list. When only defaultSchema is given, PUBLIC is kept as a
+ * fallback so unqualified names outside the new schema still resolve (the
+ * server always appends SYSTEM itself). Returns null when neither option
+ * is set.
+ */
+function buildSchemaSearchPath(options) {
+    var list = [];
+    if (options.searchPath) {
+        list = Array.isArray(options.searchPath)
+            ? options.searchPath.slice()
+            : String(options.searchPath).split(',').map(function (s) { return s.trim(); }).filter(Boolean);
+    }
+    var def = options.defaultSchema;
+    if (def) {
+        if (list.length === 0) {
+            // defaultSchema alone: keep PUBLIC as a fallback after it
+            list = def === 'PUBLIC' ? ['PUBLIC'] : [def, 'PUBLIC'];
+        }
+        else {
+            // explicit searchPath: respect it, just move defaultSchema first
+            list = [def].concat(list.filter(function (s) { return s !== def; }));
+        }
+    }
+    return list.length ? list.join(',') : null;
+}
+function statementCacheLimit(options) {
+    const size = options && options.statementCacheSize;
+    if (size && size > 0) {
+        return Math.floor(size);
+    }
+    if (options && options.cacheQuery) {
+        const legacy = options.maxCachedQuery;
+        return legacy && legacy > 0 ? Math.floor(legacy) : 100;
+    }
+    return 0;
+}
+const SQL_TYPE_NAMES = {
+    [const_1.default.SQL_TEXT]: 'TEXT',
+    [const_1.default.SQL_VARYING]: 'VARYING',
+    [const_1.default.SQL_SHORT]: 'SHORT',
+    [const_1.default.SQL_LONG]: 'LONG',
+    [const_1.default.SQL_FLOAT]: 'FLOAT',
+    [const_1.default.SQL_DOUBLE]: 'DOUBLE',
+    [const_1.default.SQL_D_FLOAT]: 'D_FLOAT',
+    [const_1.default.SQL_TIMESTAMP]: 'TIMESTAMP',
+    [const_1.default.SQL_BLOB]: 'BLOB',
+    [const_1.default.SQL_ARRAY]: 'ARRAY',
+    [const_1.default.SQL_QUAD]: 'QUAD',
+    [const_1.default.SQL_TYPE_TIME]: 'TIME',
+    [const_1.default.SQL_TYPE_DATE]: 'DATE',
+    [const_1.default.SQL_INT64]: 'INT64',
+    [const_1.default.SQL_INT128]: 'INT128',
+    [const_1.default.SQL_TIMESTAMP_TZ]: 'TIMESTAMP_TZ',
+    [const_1.default.SQL_TIMESTAMP_TZ_EX]: 'TIMESTAMP_TZ_EX',
+    [const_1.default.SQL_TIME_TZ]: 'TIME_TZ',
+    [const_1.default.SQL_TIME_TZ_EX]: 'TIME_TZ_EX',
+    [const_1.default.SQL_DEC16]: 'DEC16',
+    [const_1.default.SQL_DEC34]: 'DEC34',
+    [const_1.default.SQL_BOOLEAN]: 'BOOLEAN',
+    [const_1.default.SQL_NULL]: 'NULL',
+};
+/**
+ * Run the user's typeCast hook (options.typeCast) for one column value.
+ * The hook receives the column metadata and a next() returning the value
+ * the driver would produce by default (after blobAsText/jsonAsObject);
+ * whatever it returns becomes the value in the row. Rows may be decoded
+ * more than once when a response spans TCP packets, so the hook must be
+ * a pure function of its inputs.
+ */
+function applyTypeCast(options, meta, defaultValue) {
+    const typeCast = options && options.typeCast;
+    if (typeof typeCast !== 'function') {
+        return defaultValue;
+    }
+    const column = {
+        type: meta.type,
+        typeName: SQL_TYPE_NAMES[meta.type] || 'UNKNOWN',
+        subType: meta.subType,
+        scale: meta.scale,
+        length: meta.length,
+        field: meta.field,
+        relation: meta.relation,
+        alias: meta.alias,
+    };
+    // A hook exception must never escape into the row-decode loop: there it
+    // would be mistaken for an incomplete packet and desync the response
+    // queue (the same failure mode as issue #341). Fall back to the default
+    // value instead and tell the user.
+    try {
+        return typeCast(column, function () { return defaultValue; });
+    }
+    catch (err) {
+        console.warn('[node-firebird] typeCast hook threw for column "%s" (%s): %s — using default value', column.alias || column.field, column.typeName, err && err.message);
+        return defaultValue;
+    }
+}
 /***************************************
  *
  *   Connection
@@ -69,6 +175,8 @@ function parseValueIfJson(value, options) {
 class Connection {
     constructor(host, port, callback, options, db, svc) {
         var self = this;
+        // db is absent for service-manager connections; the wire core only
+        // touches it on database attachments, where it is always set
         this.db = db;
         this.svc = svc;
         this._msg = new serialize_1.XdrWriter(32);
@@ -77,35 +185,78 @@ class Connection {
         this._detachTimeout;
         this._detachCallback;
         this._detachAuto;
-        this._socket = new socket_1.default(port, host);
+        this._socket = new socket_1.default(port, host, options.enableKeepAlive !== false, options.keepAliveInitialDelay);
         this._pending = [];
         this._isOpened = false;
         this._isClosed = false;
         this._isDetach = false;
         this._isUsed = false;
         this._pooled = options.isPool || false;
-        if (options && options.blobChunkSize > 65535)
+        // Credentials may be absent (e.g. a traditional host:database
+        // connection string) — apply the driver defaults once here, so every
+        // auth path (op_connect CNCT block, SRP proof, legacy cont_auth) sees
+        // the same values.
+        if (options && !options.user)
+            options.user = const_1.default.DEFAULT_USER;
+        if (options && !options.password)
+            options.password = const_1.default.DEFAULT_PASSWORD;
+        if (options && options.blobChunkSize && options.blobChunkSize > 65535)
             options.blobChunkSize = 65535;
-        if (options && options.blobReadChunkSize > 65535)
+        if (options && options.blobReadChunkSize && options.blobReadChunkSize > 65535)
             options.blobReadChunkSize = 65535;
         this.options = options;
         this._bind_events(host, port, callback);
         this.error;
         this._retry_connection_id;
         this._retry_connection_interval = options.retryConnectionInterval || 1000;
-        this._max_cached_query = options.maxCachedQuery || -1;
-        this._cache_query = options.cacheQuery ? {} : null;
+        this._statementCacheSize = statementCacheLimit(options);
+        this._statementCache = this._statementCacheSize > 0 ? new Map() : null;
         this._messageFile = options.messageFile || path_1.default.join(__dirname, 'firebird.msg');
     }
-    _setcachedquery(query, statement) {
-        if (this._cache_query) {
-            if (this._max_cached_query === -1 || this._max_cached_query > Object.keys(this._cache_query).length) {
-                this._cache_query[query] = statement;
-            }
+    /**
+     * Take an idle prepared statement for `query` out of the cache, or null.
+     * The statement leaves the cache while in use, so concurrent callers of
+     * the same query never share a server-side cursor — they simply prepare
+     * a fresh statement and the spare is dropped when released.
+     */
+    takeCachedStatement(query) {
+        const cache = this._statementCache;
+        if (!cache) {
+            return null;
+        }
+        const statement = cache.get(query);
+        if (!statement) {
+            return null;
         }
+        cache.delete(query);
+        return statement;
     }
-    getCachedQuery(query) {
-        return this._cache_query ? this._cache_query[query] : null;
+    /**
+     * Return a statement after use. With the statement cache enabled the
+     * statement goes back into the cache as most-recently-used (closing its
+     * cursor but keeping the prepared handle), evicting the least-recently
+     * used statement over the limit. Failed statements, DDL and spares for
+     * an already-cached query are dropped instead.
+     */
+    releaseStatement(statement, callback) {
+        const cache = this._statementCache;
+        const cacheable = cache &&
+            statement.query &&
+            !statement._failed &&
+            statement.type !== const_1.default.isc_info_sql_stmt_ddl &&
+            !cache.has(statement.query);
+        if (!cacheable) {
+            this.dropStatement(statement, callback);
+            return;
+        }
+        cache.set(statement.query, statement);
+        while (cache.size > this._statementCacheSize) {
+            const oldestKey = cache.keys().next().value;
+            const oldest = cache.get(oldestKey);
+            cache.delete(oldestKey);
+            this.dropStatement(oldest, undefined);
+        }
+        this.closeStatement(statement, callback);
     }
     // Reject every request that is still awaiting a server response (e.g. a
     // transaction.commit() sent right before the server went away) instead of
@@ -139,6 +290,8 @@ class Connection {
             self._rejectPending(lostError);
             self._retry_connection_id = setTimeout(function () {
                 self._socket.removeAllListeners();
+                // transiently null while the replacement Connection is built
+                // (restored by the Object.assign(self, ctx) below)
                 self._socket = null;
                 var ctx = new Connection(host, port, function (err) {
                     ctx.connect(self.options, function (err) {
@@ -339,8 +492,17 @@ class Connection {
         }
         const canDefer = defer && this.accept.protocolVersion >= const_1.default.PROTOCOL_VERSION11;
         self._socket.write(self._msg.getData(), canDefer);
-        if (canDefer && callback) {
-            callback();
+        if (canDefer) {
+            // A deferred packet sits in the socket buffer until the next
+            // non-deferred write flushes it, but the server still answers it
+            // with its own op_response (delivered along with that next
+            // exchange). Queue a placeholder to consume that response —
+            // otherwise the queue pairs it with the NEXT request and every
+            // later response is off by one. The op itself is fire-and-forget,
+            // so complete the caller right away.
+            self._queue.push(undefined);
+            if (callback)
+                callback();
         }
         else {
             self._queue.push(callback);
@@ -384,10 +546,17 @@ class Connection {
         msg.addInt(const_1.default.CONNECT_VERSION3);
         msg.addInt(const_1.default.ARCHITECTURE_GENERIC);
         msg.addString(options.database || options.filename, const_1.default.DEFAULT_ENCODING);
-        var maxProtocols = options.maxNegotiatedProtocols !== undefined ? options.maxNegotiatedProtocols : 10;
+        // Send the full list by default. Servers parse every entry and ignore
+        // versions they do not know (verified back to Firebird 2.5), so the
+        // list length itself is harmless; the option remains as an escape
+        // hatch to cap negotiation at an older protocol.
+        var maxProtocols = options.maxNegotiatedProtocols !== undefined ? options.maxNegotiatedProtocols : const_1.default.SUPPORTED_PROTOCOL.length;
         var protocolsToSend = const_1.default.SUPPORTED_PROTOCOL;
         if (protocolsToSend.length > maxProtocols) {
-            protocolsToSend = protocolsToSend.slice(-maxProtocols);
+            // keep the FIRST N entries: the list is ordered oldest→newest, so
+            // capping the count caps the newest protocol offered (e.g. 10 =
+            // stop at protocol 19, the documented pre-Firebird-6 behavior)
+            protocolsToSend = protocolsToSend.slice(0, maxProtocols);
         }
         msg.addInt(protocolsToSend.length); // Count of Protocol version understood count.
         msg.addBlr(this._blr);
@@ -523,21 +692,9 @@ class Connection {
             blr.addNumeric(const_1.default.isc_dpb_max_inline_blob_size, options.maxInlineBlobSize);
         }
         // Firebird 6.0 SQL Schema parameters (Protocol 20+).
-        // These DPB tags configure the session's current schema and the
-        // schema search path for unqualified object name resolution.
         if (this.accept.protocolVersion >= const_1.default.PROTOCOL_VERSION20) {
-            if (options.defaultSchema) {
-                // Sets CURRENT_SCHEMA for the session.  Equivalent to issuing
-                // SET SCHEMA <name> immediately after connecting.
-                blr.addString(const_1.default.isc_dpb_default_schema, options.defaultSchema, const_1.default.DEFAULT_ENCODING);
-            }
-            if (options.searchPath) {
-                // Comma-separated ordered schema name list, like PostgreSQL's
-                // search_path.  Unqualified object references are resolved by
-                // scanning schemas in this order.
-                const sp = Array.isArray(options.searchPath)
-                    ? options.searchPath.join(',')
-                    : String(options.searchPath);
+            const sp = buildSchemaSearchPath(options);
+            if (sp) {
                 blr.addString(const_1.default.isc_dpb_search_path, sp, const_1.default.DEFAULT_ENCODING);
             }
         }
@@ -637,16 +794,17 @@ class Connection {
         }
         // Firebird 6.0 SQL Schema parameters (Protocol 20+).
         if (this.accept.protocolVersion >= const_1.default.PROTOCOL_VERSION20) {
-            if (options.defaultSchema) {
-                blr.addString(const_1.default.isc_dpb_default_schema, options.defaultSchema, const_1.default.DEFAULT_ENCODING);
-            }
-            if (options.searchPath) {
-                const sp = Array.isArray(options.searchPath)
-                    ? options.searchPath.join(',')
-                    : String(options.searchPath);
+            const sp = buildSchemaSearchPath(options);
+            if (sp) {
                 blr.addString(const_1.default.isc_dpb_search_path, sp, const_1.default.DEFAULT_ENCODING);
             }
         }
+        if (options.owner) {
+            // Firebird 6.0+ (issue #7718): create the database owned by a
+            // different user (requires superuser rights). Older servers
+            // ignore unknown DPB tags, so this is safe to always send.
+            blr.addString(const_1.default.isc_dpb_owner, options.owner, const_1.default.DEFAULT_ENCODING);
+        }
         blr.addNumeric(const_1.default.isc_dpb_sql_dialect, 3);
         blr.addNumeric(const_1.default.isc_dpb_force_write, 1);
         blr.addNumeric(const_1.default.isc_dpb_overwrite, 1);
@@ -690,6 +848,8 @@ class Connection {
             callback(err);
         return this;
     }
+    /** `options` is a resolved options object, a bare isolation array, or
+     *  the callback itself when no options are given. */
     startTransaction(options, callback) {
         if (typeof (options) === 'function') {
             var tmp = options;
@@ -851,7 +1011,6 @@ class Connection {
                 mainCallback.response.query = query;
                 self.db.emit('query', query);
                 ret = mainCallback.response;
-                self._setcachedquery(query, ret);
             }
             if (callback)
                 callback(err, ret);
@@ -879,6 +1038,12 @@ class Connection {
         msg.addString(query, const_1.default.DEFAULT_ENCODING);
         msg.addBlr(blr);
         msg.addInt(65535); // buffer_length
+        if (this.accept.protocolVersion >= const_1.default.PROTOCOL_VERSION20) {
+            // p_sqlst_flags (IStatement::PREPARE_* bits, none needed) — the
+            // server blocks reading this field if it is missing, which was
+            // the protocol-20 "prepare hang"
+            msg.addInt(0);
+        }
         mainCallback.lazy_count += 1;
         mainCallback.response = new statement_1.default(this);
         this._queueEvent(mainCallback);
@@ -898,6 +1063,7 @@ class Connection {
             });
         }
     }
+    /** `plan` may be the callback itself when no plan flag is given. */
     prepareStatement(transaction, statement, query, plan, callback) {
         if (this._isClosed)
             return this.throwClosed(callback);
@@ -920,6 +1086,9 @@ class Connection {
         msg.addString(query, const_1.default.DEFAULT_ENCODING);
         msg.addBlr(blr);
         msg.addInt(65535); // buffer_length
+        if (this.accept.protocolVersion >= const_1.default.PROTOCOL_VERSION20) {
+            msg.addInt(0); // p_sqlst_flags (see allocateAndPrepareStatement)
+        }
         var self = this;
         this._queueEvent(function (err, ret) {
             if (!err) {
@@ -927,7 +1096,6 @@ class Connection {
                 statement.query = query;
                 self.db.emit('query', query);
                 ret = statement;
-                self._setcachedquery(query, ret);
             }
             if (callback)
                 callback(err, ret);
@@ -985,7 +1153,7 @@ class Connection {
         }
         var self = this;
         var encoders = built.encoders;
-        var chunkSize = options.chunkSize > 0 ? options.chunkSize : 500;
+        var chunkSize = options.chunkSize && options.chunkSize > 0 ? options.chunkSize : 500;
         var chunkCount = Math.ceil(rows.length / chunkSize);
         var failure = null;
         var completion = null;
@@ -1043,6 +1211,7 @@ class Connection {
                 msg.addInt(statement.handle);
                 msg.addInt(end - start);
                 for (var i = start; i < end; i++) {
+                    // validated as an array of input.length values above
                     var row = rows[i];
                     var nullBits = new serialize_1.BitSet();
                     for (var j = 0; j < input.length; j++) {
@@ -1114,6 +1283,7 @@ class Connection {
             }
         }
     }
+    /** `params` may be the callback itself when the statement has no parameters. */
     executeStatement(transaction, statement, params, callback, custom) {
         if (this._isClosed)
             return this.throwClosed(callback);
@@ -1425,6 +1595,7 @@ class Connection {
         callback.statement = statement;
         this._queueEvent(callback);
     }
+    /** `count` may be the callback itself when no fetch size is given. */
     fetch(statement, transaction, count, callback) {
         var msg = this._msg;
         var blr = this._blr;
@@ -1528,7 +1699,7 @@ class Connection {
                 readBlobsSequentially(0, []).then((arrBlob) => {
                     for (let i = 0; i < arrBlob.length; i++) {
                         const blob = arrBlob[i];
-                        ret.data[blob.row][blob.column] = parseValueIfJson(blob.value, statement.connection.options);
+                        ret.data[blob.row][blob.column] = applyTypeCast(statement.connection.options, blob.meta || {}, parseValueIfJson(blob.value, statement.connection.options));
                     }
                     doSynchronousLoop(ret.data, (row, _i, next) => {
                         const pos = asStream ? streamIndex++ : (data.push(row) - 1);
@@ -1895,12 +2066,25 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
             }
             case const_1.default.op_fetch_response:
             case const_1.default.op_sql_response:
+                // fetch/sql_response entries always carry their statement
                 var statement = callback.statement;
                 var output = statement.output;
                 var custom = statement.options || {};
                 var isOpFetch = r === const_1.default.op_fetch_response;
                 var _xdrpos;
                 statement.nbrowsfetched = statement.nbrowsfetched || 0;
+                // The f* decode state is only meaningful within a single
+                // decode call: incomplete packets are re-decoded from scratch
+                // on a fresh XdrReader (see the 'data' handler). State left by
+                // an earlier packet in the same data event (e.g. fstatus=100 /
+                // fcount=0 from a completed fetch) would make this decode
+                // consume just the opcode and desync every later response.
+                delete data.fstatus;
+                delete data.fcount;
+                delete data.fcolumn;
+                delete data.frow;
+                delete data.frows;
+                delete data.fcols;
                 if (isOpFetch && data.fop) { // could be set when a packet is not complete
                     data.readBuffer(68); // ??
                     op = data.readInt(); // ??
@@ -1927,6 +2111,13 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                 }
                 const arrBlob = [];
                 const lowerV13 = statement.connection.accept.protocolVersion < const_1.default.PROTOCOL_VERSION13;
+                // op_sql_response (op_execute2) is always followed by an
+                // op_response carrying the execute status vector. The row loop
+                // below consumes it after the last row, but with zero rows
+                // (e.g. INSERT ... RETURNING failing on a constraint) it stays
+                // in the buffer, shifting every later response to the wrong
+                // callback and poisoning the connection (issue #341).
+                var sqlResponseTrailerPending = !isOpFetch && !data.fcount;
                 while (data.fcount && (data.fstatus !== 100)) {
                     let nullBitSet;
                     if (!lowerV13) {
@@ -1937,12 +2128,8 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                     for (let length = output.length; data.fcolumn < length; data.fcolumn++) {
                         item = output[data.fcolumn];
                         if (!lowerV13 && nullBitSet.get(data.fcolumn)) {
-                            if (custom.asObject) {
-                                data.frow[data.fcols[data.fcolumn]] = null;
-                            }
-                            else {
-                                data.frow[data.fcolumn] = null;
-                            }
+                            const nullKey = custom.asObject ? data.fcols[data.fcolumn] : data.fcolumn;
+                            data.frow[nullKey] = applyTypeCast(cnx.options, item, null);
                             continue;
                         }
                         try {
@@ -1950,16 +2137,23 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                             const key = custom.asObject ? data.fcols[data.fcolumn] : data.fcolumn;
                             const row = data.frows.length;
                             let value = item.decode(data, lowerV13, cnx.options);
+                            // text blobs resolved by blobAsText run through the
+                            // typeCast hook once the text arrives (see fetchAll),
+                            // not here where the value is still a pending fetch
+                            let pendingTextBlob = false;
                             if (item.type === const_1.default.SQL_BLOB && value !== null) {
                                 if (item.subType === const_1.default.isc_blob_text && cnx.options.blobAsText) {
-                                    value = fetch_blob_async_transaction(statement, value, key, row);
+                                    value = fetch_blob_async_transaction(statement, value, key, row, item);
                                     arrBlob.push(value);
+                                    pendingTextBlob = true;
                                 }
                                 else {
                                     value = fetch_blob_async(statement, value, key, row);
                                 }
                             }
-                            data.frow[key] = parseValueIfJson(value, cnx.options);
+                            data.frow[key] = pendingTextBlob
+                                ? value
+                                : applyTypeCast(cnx.options, item, parseValueIfJson(value, cnx.options));
                         }
                         catch (e) {
                             // uncomplete packet read
@@ -2006,6 +2200,16 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                     }
                     statement.nbrowsfetched++;
                 }
+                if (sqlResponseTrailerPending) {
+                    op = data.readInt();
+                    if (op === const_1.default.op_response) {
+                        response = {};
+                        parseOpResponse(data, response);
+                        if (response.status) {
+                            return cb(null, response);
+                        }
+                    }
+                }
                 // ToDo: emit "result" with blob subtype string decoded
                 statement.connection.db.emit('result', data.frows, arrBlob);
                 return cb(null, { data: data.frows, fetched: Boolean(!isOpFetch || data.fstatus === 100), arrBlob });
@@ -2340,6 +2544,17 @@ function readStatusVector(data) {
                     result.sqlcode = n;
                 }
                 break;
+            case const_1.default.isc_arg_warning:
+                // A warning attached to a SUCCESS vector (e.g. "parallel
+                // workers value capped"). Keep it out of `status` so the
+                // operation is not mistaken for a failure; later string/
+                // number items attach to the warning entry.
+                var wnum = data.readInt();
+                item = { gdscode: wnum };
+                if (wnum) {
+                    (result.warnings = result.warnings || []).push(item);
+                }
+                break;
             default:
                 throw new Error('Unexpected status vector item: ' + op);
         }
@@ -2400,13 +2615,25 @@ function parseOpResponse(data, response, cb) {
                     response.sqlcode = num;
                 }
                 break;
+            case const_1.default.isc_arg_warning:
+                // A warning attached to a SUCCESS response (e.g. Firebird's
+                // "parallel workers value capped" on attach). Keep it out of
+                // `status` so the response is not mistaken for an error;
+                // later string/number items attach to the warning entry.
+                num = data.readInt();
+                item = { gdscode: num };
+                if (num) {
+                    (response.warnings = response.warnings || []).push(item);
+                }
+                break;
             default:
+                // Stop parsing: continuing the loop after an unknown item
+                // re-read the same bytes forever (the caller resets the
+                // reader position when the error is delivered).
                 if (cb) {
-                    cb(new Error('Unexpected: ' + op));
-                }
-                else {
-                    throw new Error('Unexpected: ' + op);
+                    return cb(new Error('Unexpected: ' + op));
                 }
+                throw new Error('Unexpected: ' + op);
         }
     }
 }
@@ -2443,6 +2670,8 @@ function describe(buff, statement) {
                         case const_1.default.isc_info_sql_describe_end:
                             break;
                         case const_1.default.isc_info_sql_sqlda_seq:
+                            // describe output always encodes the sequence as a
+                            // 1/2/4-byte int, so readInt cannot return undefined
                             var num = br.readInt();
                             break;
                         case const_1.default.isc_info_sql_type:
@@ -2518,6 +2747,8 @@ function describe(buff, statement) {
                                 default:
                                     throw new Error('Unexpected');
                             }
+                            // isc_info_sql_sqlda_seq always precedes the type
+                            // item in the describe stream, so num is set here
                             parameters[num - 1] = param;
                             param.type = type;
                             param.nullable = Boolean(param.type & 1);
@@ -2788,8 +3019,8 @@ function CalcBlr(blr, xsqlda) {
     blr.addByte(const_1.default.blr_end);
     blr.addByte(const_1.default.blr_eoc);
 }
-function fetch_blob_async_transaction(statement, id, column, row) {
-    const infoValue = { row, column, value: '' };
+function fetch_blob_async_transaction(statement, id, column, row, meta) {
+    const infoValue = { row, column, value: '', meta };
     return (transactionArg) => {
         const cacheKey = `${id.high}:${id.low}`;
         if (statement.connection._inlineBlobs && statement.connection._inlineBlobs.has(cacheKey)) {

package/lib/wire/const.d.ts

@@ -324,10 +324,18 @@ declare const Const: Readonly<{
     isc_dpb_reset_icu: number;
     isc_dpb_map_attach: number;
     isc_dpb_session_time_zone: number;
+    isc_dpb_set_db_replica: number;
+    isc_dpb_set_bind: number;
+    isc_dpb_decfloat_round: number;
+    isc_dpb_decfloat_traps: number;
+    isc_dpb_clear_map: number;
+    isc_dpb_upgrade_db: number;
     isc_dpb_parallel_workers: number;
+    isc_dpb_worker_attach: number;
+    isc_dpb_owner: number;
+    isc_dpb_max_blob_cache_size: number;
     isc_dpb_max_inline_blob_size: number;
     isc_dpb_search_path: number;
-    isc_dpb_default_schema: number;
     CNCT_user: number;
     CNCT_passwd: number;
     CNCT_host: number;

package/lib/wire/const.js

@@ -236,7 +236,8 @@ const SUPPORTED_PROTOCOL = [
     [protocol.PROTOCOL_VERSION16, connect.ARCHITECTURE_GENERIC, acceptType.ptype_lazy_send, acceptType.ptype_lazy_send, 7],
     [protocol.PROTOCOL_VERSION17, connect.ARCHITECTURE_GENERIC, acceptType.ptype_lazy_send, acceptType.ptype_lazy_send, 8],
     [protocol.PROTOCOL_VERSION18, connect.ARCHITECTURE_GENERIC, acceptType.ptype_lazy_send, acceptType.ptype_lazy_send, 9],
-    [protocol.PROTOCOL_VERSION19, connect.ARCHITECTURE_GENERIC, acceptType.ptype_lazy_send, acceptType.ptype_lazy_send, 10]
+    [protocol.PROTOCOL_VERSION19, connect.ARCHITECTURE_GENERIC, acceptType.ptype_lazy_send, acceptType.ptype_lazy_send, 10],
+    [protocol.PROTOCOL_VERSION20, connect.ARCHITECTURE_GENERIC, acceptType.ptype_lazy_send, acceptType.ptype_lazy_send, 11]
 ];
 const authPlugin = {
     AUTH_PLUGIN_LEGACY: 'Legacy_Auth',
@@ -430,16 +431,27 @@ const dpb = {
     isc_dpb_reset_icu: 89,
     isc_dpb_map_attach: 90,
     isc_dpb_session_time_zone: 91,
-    isc_dpb_parallel_workers: 92,
-    isc_dpb_max_inline_blob_size: 93,
-    // Firebird 6.0 SQL Schema parameters
+    // Firebird 4.0
+    isc_dpb_set_db_replica: 92,
+    isc_dpb_set_bind: 93,
+    isc_dpb_decfloat_round: 94,
+    isc_dpb_decfloat_traps: 95,
+    isc_dpb_clear_map: 96,
+    // Firebird 5.0
+    isc_dpb_upgrade_db: 97,
+    isc_dpb_parallel_workers: 100,
+    isc_dpb_worker_attach: 101,
+    // Firebird 6.0
+    // isc_dpb_owner sets the owner of a newly created database to a user
+    // other than the connecting one (create only; requires superuser).
+    isc_dpb_owner: 102,
+    isc_dpb_max_blob_cache_size: 103,
+    isc_dpb_max_inline_blob_size: 104, // Firebird 5.0.3+
     // isc_dpb_search_path sets the comma-separated ordered list of schema
     // names to search for unqualified object names (similar to PostgreSQL
-    // search_path).  Available on Protocol 20+ (Firebird 6.0).
-    isc_dpb_search_path: 94,
-    // isc_dpb_default_schema overrides the session's current schema
-    // (CURRENT_SCHEMA) at connection time.  Available on Protocol 20+.
-    isc_dpb_default_schema: 95,
+    // search_path). CURRENT_SCHEMA is the first existing schema of the list.
+    // Available on Protocol 20+ (Firebird 6.0).
+    isc_dpb_search_path: 105,
 };
 const cnct = {
     CNCT_user: 1, // User name