node-firebird 2.3.2 → 2.3.3

package/poc/node_modules/node-firebird/lib/wire/connection.js

@@ -0,0 +1,2510 @@
+const Events = require('events');
+const os = require('os');
+const path = require('path');
+
+const {XdrWriter, BlrWriter, XdrReader, BitSet, BlrReader} = require('./serialize');
+const {doCallback, doError} = require('../callback');
+const srp = require('../srp');
+const crypt = require('../unix-crypt');
+const Const = require('./const');
+const Xsql = require('./xsqlvar');
+const ServiceManager = require('./service');
+const Database = require('./database');
+const Statement = require('./statement');
+const Transaction = require('./transaction');
+const {lookupMessages, noop, parseDate} = require('../utils');
+const Socket = require("./socket");
+
+/***************************************
+ *
+ *   Connection
+ *
+ ***************************************/
+
+class Connection {
+    constructor(host, port, callback, options, db, svc) {
+        var self = this;
+        this.db = db;
+        this.svc = svc
+        this._msg = new XdrWriter(32);
+        this._blr = new BlrWriter(32);
+        this._queue = [];
+        this._detachTimeout;
+        this._detachCallback;
+        this._detachAuto;
+        this._socket = new Socket(port, host);
+        this._pending = [];
+        this._isOpened = false;
+        this._isClosed = false;
+        this._isDetach = false;
+        this._isUsed = false;
+        this._pooled = options.isPool||false;
+        if (options && options.blobChunkSize > 65535) options.blobChunkSize = 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._messageFile = options.messageFile || path.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;
+            }
+        }
+    
+    
+    }
+
+
+    getCachedQuery(query) {
+        return this._cache_query ? this._cache_query[query] : null;
+    }
+
+
+    _bind_events(host, port, callback) {
+    
+        var self = this;
+    
+        self._socket.on('close', function() {
+    
+            if (!self._isOpened || self._isDetach) {
+                return;
+            }
+    
+            self._isOpened = false;
+    
+            if (!self.db) {
+                if (callback)
+                    callback(self.error);
+                return;
+            }
+    
+            self._retry_connection_id = setTimeout(function() {
+                self._socket.removeAllListeners();
+                self._socket = null;
+    
+                var ctx = new Connection(host, port, function(err) {
+                    ctx.connect(self.options, function(err) {
+    
+                        if (err) {
+                            self.db.emit('error', err);
+                            return;
+                        }
+    
+                        ctx.attach(self.options, function(err) {
+    
+                            if (err) {
+                                self.db.emit('error', err);
+                                return;
+                            }
+    
+                            ctx._queue = ctx._queue.concat(self._queue);
+                            ctx._pending = ctx._pending.concat(self._pending);
+                            self.db.emit('reconnect');
+    
+                        }, self.db);
+                    });
+    
+                    Object.assign(self, ctx);
+    
+                }, self.options, self.db);
+            }, self._retry_connection_interval);
+    
+        });
+    
+        self._socket.on('error', function(e) {
+    
+            self.error = e;
+    
+            if (self.db)
+                self.db.emit('error', e)
+    
+            if (callback)
+                callback(e);
+    
+        });
+    
+        self._socket.on('connect', function() {
+            self._isClosed = false;
+            self._isOpened = true;
+            if (callback)
+                callback();
+        });
+    
+        self._socket.on('data', function (data) {
+            var xdr;
+            var hadSavedBuffer = Boolean(self._xdr);
+    
+            if (!self._xdr) {
+                xdr = new XdrReader(data);
+            } else {
+                xdr = new XdrReader(Buffer.concat([self._xdr.buffer, data], self._xdr.buffer.length + data.length));
+                delete (self._xdr);
+            }
+
+            if (process.env.FIREBIRD_DEBUG) {
+                console.log('[fb-debug] data event: bytes=%d queue=%d pending=%d xdr.pos=%d savedBuf=%s',
+                    xdr.buffer.length, self._queue.length, self._pending.length, xdr.pos, hadSavedBuffer);
+            }
+    
+            while (xdr.pos < xdr.buffer.length) {
+                var cb = self._queue[0], pos = xdr.pos;
+    
+                decodeResponse(xdr, cb, self, self._lowercase_keys, function (err, obj) {
+    
+                    if (err) {
+                        if (err instanceof RangeError) {
+                            // Genuinely incomplete packet – buffer the remaining bytes
+                            // and wait for the next 'data' event to reassemble.
+                            xdr.buffer = xdr.buffer.slice(pos);
+                            xdr.pos = 0;
+                            self._xdr = xdr;
+
+                            if (process.env.FIREBIRD_DEBUG) {
+                                console.log('[fb-debug] incomplete packet: saved %d bytes at pos=%d queue=%d',
+                                    xdr.buffer.length, pos, self._queue.length);
+                            }
+
+                            if (self.accept && self.accept.protocolMinimumType === Const.ptype_lazy_send && self._queue.length > 0) {
+                                self._queue[0].lazy_count = 2;
+                            }
+                        } else {
+                            // Any other error (truly unknown opcode not handled above).
+                            // Save the buffer so it can be retried, but log a warning.
+                            if (process.env.FIREBIRD_DEBUG) {
+                                console.warn(`[fb-debug] unhandled protocol error: ${err.message} pos=${pos} bytes=${xdr.buffer.length} queue=${self._queue.length}`);
+                            }
+                            xdr.buffer = xdr.buffer.slice(pos);
+                            xdr.pos = 0;
+                            self._xdr = xdr;
+                        }
+                        return;
+                    }
+    
+                    // remove the op flag, needed for partial packet
+                    if (xdr.r) {
+                        delete (xdr.r);
+                    }
+
+                    // op_event / op_response_piggyback received on the main connection:
+                    // data has been consumed by decodeResponse but it does not belong to
+                    // any queued request – do NOT shift the queue or invoke any pending
+                    // callback.
+                    if (obj && obj._isOpEvent) {
+                        if (process.env.FIREBIRD_DEBUG) {
+                            console.log('[fb-debug] async opcode consumed (ignored): queue=%d xdr.pos=%d remaining=%d',
+                                self._queue.length, xdr.pos, xdr.buffer.length - xdr.pos);
+                        }
+                        return;
+                    }
+    
+                    self._queue.shift();
+                    self._pending.shift();
+    
+                    if (process.env.FIREBIRD_DEBUG) {
+                        console.log('[fb-debug] response dispatched: queue remaining=%d pending remaining=%d xdr.pos=%d',
+                            self._queue.length, self._pending.length, xdr.pos);
+                    }
+
+                    if (obj && obj.status) {
+                        obj.message = lookupMessages(obj.status);
+                        doCallback(obj, cb);
+                    } else {
+                        doCallback(obj, cb);
+                    }
+    
+                });
+    
+                if (xdr.pos === 0) {
+                    break;
+                }
+            }
+    
+            if (!self._detachAuto || self._pending.length !== 0) {
+                return;
+            }
+    
+            clearTimeout(self._detachTimeout);
+            self._detachTimeout = setTimeout(function () {
+                self.db.detach(self._detachCallback);
+                self._detachAuto = false;
+            }, 100);
+    
+        });
+    }
+
+
+    disconnect() {
+        this._socket.end();
+    }
+
+
+
+
+
+    sendOpContAuth(authData, authDataEnc, pluginName) {
+        var msg = this._msg;
+        msg.pos = 0;
+    
+        msg.addInt(Const.op_cont_auth);
+        msg.addString(authData, authDataEnc);
+        msg.addString(pluginName, Const.DEFAULT_ENCODING)
+        msg.addString(Const.AUTH_PLUGIN_LIST.join(','), Const.DEFAULT_ENCODING);
+        // msg.addInt(0); // p_list
+        msg.addInt(0); // keys
+    
+        this._socket.write(msg.getData());
+    }
+
+
+    sendOpCrypt(encryptPlugin) {
+        var msg = this._msg;
+        msg.pos = 0;
+
+        msg.addInt(Const.op_crypt);
+        msg.addString(encryptPlugin || 'Arc4', Const.DEFAULT_ENCODING);
+        msg.addString('Symmetric', Const.DEFAULT_ENCODING);
+
+        this._socket.write(msg.getData());
+    }
+
+
+    sendOpCryptKeyCallback(pluginData) {
+        var msg = this._msg;
+        msg.pos = 0;
+
+        msg.addInt(Const.op_crypt_key_callback);
+        msg.addBlr(pluginData); // Send the callback response data as a buffer
+
+        this._socket.write(msg.getData());
+    }
+
+
+    _queueEvent(callback, defer = false) {
+        var self = this;
+    
+        if (self._isClosed) {
+            if (callback)
+                callback(new Error('Connection is closed.'));
+            return;
+        }
+    
+        const canDefer = defer && this.accept.protocolVersion >= Const.PROTOCOL_VERSION11;
+    
+        self._socket.write(self._msg.getData(), canDefer);
+        if (canDefer && callback) {
+            callback();
+        } else {
+            self._queue.push(callback);
+        }
+    }
+
+
+    connect(options, callback) {
+        var pluginName = options.manager ? Const.AUTH_PLUGIN_LEGACY : options.pluginName || Const.AUTH_PLUGIN_LIST[0]; // TODO Srp for service
+        var msg = this._msg;
+        var blr = this._blr;
+    
+        this._pending.push('connect');
+        this._authStartTime = Date.now();
+    
+        msg.pos = 0;
+        blr.pos = 0;
+    
+        blr.addString(Const.CNCT_login, options.user, Const.DEFAULT_ENCODING);
+        blr.addString(Const.CNCT_plugin_name, pluginName, Const.DEFAULT_ENCODING);
+        blr.addString(Const.CNCT_plugin_list, Const.AUTH_PLUGIN_LIST.join(','), Const.DEFAULT_ENCODING);
+    
+        var specificData = '';
+        if (Const.AUTH_PLUGIN_SRP_LIST.indexOf(pluginName) > -1) {
+            const _t0 = Date.now();
+            this.clientKeys = srp.clientSeed();
+            if (process.env.FIREBIRD_DEBUG) {
+                console.log('[fb-debug] srp.clientSeed: %dms', Date.now() - _t0);
+            }
+            specificData = this.clientKeys.public.toString(16);
+            blr.addMultiblockPart(Const.CNCT_specific_data, specificData, Const.DEFAULT_ENCODING);
+        } else if (pluginName === Const.AUTH_PLUGIN_LEGACY) {
+            specificData = crypt.crypt(options.password, Const.LEGACY_AUTH_SALT).substring(2);
+            blr.addMultiblockPart(Const.CNCT_specific_data, specificData, Const.DEFAULT_ENCODING);
+        } else {
+            doError(new Error('Invalide auth plugin \'' + pluginName + '\''), callback);
+            return;
+        }
+        blr.addBytes([Const.CNCT_client_crypt, 4, options.wireCrypt !== undefined ? options.wireCrypt : Const.WIRE_CRYPT_ENABLE, 0, 0, 0]);
+        blr.addString(Const.CNCT_user, os.userInfo().username || 'Unknown', Const.DEFAULT_ENCODING);
+        blr.addString(Const.CNCT_host, os.hostname(), Const.DEFAULT_ENCODING);
+        blr.addBytes([Const.CNCT_user_verification, 0]);
+    
+        msg.addInt(Const.op_connect);
+        msg.addInt(Const.op_attach);
+        msg.addInt(Const.CONNECT_VERSION3);
+        msg.addInt(Const.ARCHITECTURE_GENERIC);
+        msg.addString(options.database || options.filename, Const.DEFAULT_ENCODING);
+        msg.addInt(Const.SUPPORTED_PROTOCOL.length);  // Count of Protocol version understood count.
+        msg.addBlr(this._blr);
+    
+        for (var protocol of Const.SUPPORTED_PROTOCOL) {
+            msg.addInt(protocol[0]); // Version
+            msg.addInt(protocol[1]); // Architecture
+            msg.addInt(protocol[2]); // Min type
+            if (protocol[0] >= Const.PROTOCOL_VERSION13 && options.wireCompression) {
+                msg.addInt(protocol[3] | Const.pflag_compress); // Max type with compress flag
+            } else {
+                msg.addInt(protocol[3]); // Max type
+            }
+            msg.addInt(protocol[4]); // Preference weight
+        }
+    
+        var self = this;
+        function cb(err, ret) {
+            if (err) {
+                doError(err, callback);
+                return;
+            }
+
+            // Check for pending accept from op_cond_accept flow
+            if (self._pendingAccept) {
+                ret = self._pendingAccept;
+                delete self._pendingAccept;
+            }
+
+            self.accept = ret;
+
+            // Wire encryption: send op_crypt if SRP session key is available
+            if (ret.sessionKey && ret.protocolVersion >= Const.PROTOCOL_VERSION13 &&
+                options.wireCrypt !== Const.WIRE_CRYPT_DISABLE) {
+                var keyBuf = Buffer.from(ret.sessionKey.toString(16).padStart(40, '0'), 'hex');
+                self.sendOpCrypt('Arc4');
+                self._socket.enableEncryption(keyBuf);
+                self._pending.push('crypt');
+                self._queue.push(function(cryptErr) {
+                    if (cryptErr) {
+                        doError(cryptErr, callback);
+                        return;
+                    }
+                    if (callback)
+                        callback(undefined, ret);
+                });
+                return;
+            }
+
+            if (callback)
+                callback(undefined, ret);
+        }
+    
+        if (process.env.FIREBIRD_DEBUG) {
+            console.log('[fb-debug] auth: op_connect sent plugin=%s t=%dms', pluginName, Date.now() - this._authStartTime);
+        }
+        this._queueEvent(cb);
+    }
+
+
+    attach(options, callback, db) {
+        this._lowercase_keys = options.lowercase_keys || Const.DEFAULT_LOWERCASE_KEYS;
+    
+        var database = options.database || options.filename;
+        if (database == null || database.length === 0) {
+            doError(new Error('No database specified'), callback);
+            return;
+        }
+    
+        var user = options.user || Const.DEFAULT_USER;
+        var password = options.password || Const.DEFAULT_PASSWORD;
+        var role = options.role;
+        var self = this;
+        var msg = this._msg;
+        var blr = this._blr;
+        msg.pos = 0;
+        blr.pos = 0;
+    
+        blr.addByte(Const.isc_dpb_version1);
+        blr.addString(Const.isc_dpb_lc_ctype, options.encoding || 'UTF8', Const.DEFAULT_ENCODING);
+        
+        // For Firebird 3+ (protocol 13+), add UTF-8 filename flag to ensure all DPB strings are handled with UTF-8
+        if (this.accept.protocolVersion >= Const.PROTOCOL_VERSION13) {
+            blr.addByte(Const.isc_dpb_utf8_filename);
+            blr.addByte(0);
+        }
+        
+        blr.addString(Const.isc_dpb_user_name, user, Const.DEFAULT_ENCODING);
+        if (options.password && !this.accept.authData) {
+            if (this.accept.protocolVersion < Const.PROTOCOL_VERSION13) {
+                if (this.accept.protocolVersion === Const.PROTOCOL_VERSION10) {
+                    blr.addString(Const.isc_dpb_password, password, Const.DEFAULT_ENCODING);
+                } else {
+                    blr.addString(Const.isc_dpb_password_enc, crypt.crypt(password, Const.LEGACY_AUTH_SALT).substring(2), Const.DEFAULT_ENCODING);
+                }
+            }
+        }
+    
+        if (role)
+            blr.addString(Const.isc_dpb_sql_role_name, role, Const.DEFAULT_ENCODING);
+    
+        blr.addBytes([Const.isc_dpb_process_id, 4]);
+        blr.addInt32(process.pid);
+    
+        let processName  = process.title || "";
+        blr.addString(Const.isc_dpb_process_name, processName.length > 255 ? processName.substring(processName.length - 255,  processName.length) : processName, Const.DEFAULT_ENCODING);
+    
+        if (this.accept.authData) {
+            blr.addString(Const.isc_dpb_specific_auth_data, this.accept.authData, Const.DEFAULT_ENCODING);
+        }
+
+        if (options.sessionTimeZone) {
+            blr.addString(Const.isc_dpb_session_time_zone, options.sessionTimeZone, Const.DEFAULT_ENCODING);
+        }
+    
+        msg.addInt(Const.op_attach);
+        msg.addInt(0);  // Database Object ID
+        msg.addString(database, Const.DEFAULT_ENCODING);
+        msg.addBlr(this._blr);
+    
+        function cb(err, ret) {
+            if (err) {
+                doError(err, callback);
+                return;
+            }
+    
+            self.dbhandle = ret.handle;
+            if (callback)
+                callback(undefined, ret);
+            if (!db)
+                ret.emit('attach', ret);
+        }
+    
+        // For reconnect
+        if (db) {
+            db.connection = this;
+            cb.response = db;
+        } else {
+            cb.response = new Database(this);
+            cb.response.removeAllListeners('error');
+            cb.response.on('error', noop);
+        }
+    
+        this._queueEvent(cb);
+    }
+
+
+    detach(callback) {
+    
+        var self = this;
+    
+        if (self._isClosed)
+            return;
+    
+        self._isUsed = false;
+        self._isDetach = true;
+    
+        var msg = self._msg;
+    
+        msg.pos = 0;
+        msg.addInt(Const.op_detach);
+        msg.addInt(0); // Database Object ID
+    
+        self._queueEvent(function(err, ret) {
+            clearTimeout(self._retry_connection_id);
+            delete(self.dbhandle);
+            if (callback)
+                callback(err, ret);
+        });
+    }
+
+
+    createDatabase(options, callback) {
+        var database = options.database || options.filename;
+        if (database == null || database.length === 0) {
+            doError(new Error('No database specified'), callback);
+            return;
+        }
+    
+        var user = options.user || Const.DEFAULT_USER;
+        var password = options.password || Const.DEFAULT_PASSWORD;
+        var pageSize = options.pageSize || Const.DEFAULT_PAGE_SIZE;
+        var role = options.role;
+        var blr = this._blr;
+    
+        blr.pos = 0;
+        blr.addByte(Const.isc_dpb_version1);
+        blr.addString(Const.isc_dpb_set_db_charset, 'UTF8', Const.DEFAULT_ENCODING);
+        blr.addString(Const.isc_dpb_lc_ctype, 'UTF8', Const.DEFAULT_ENCODING);
+        
+        // For Firebird 3+ (protocol 13+), add UTF-8 filename flag to ensure all DPB strings are handled with UTF-8
+        if (this.accept.protocolVersion >= Const.PROTOCOL_VERSION13) {
+            blr.addByte(Const.isc_dpb_utf8_filename);
+            blr.addByte(0);
+        }
+        
+        blr.addString(Const.isc_dpb_user_name, user, Const.DEFAULT_ENCODING);
+        if (this.accept.protocolVersion < Const.PROTOCOL_VERSION13) {
+            if (this.accept.protocolVersion === Const.PROTOCOL_VERSION10) {
+                blr.addString(Const.isc_dpb_password, password, Const.DEFAULT_ENCODING);
+            } else {
+                blr.addString(Const.isc_dpb_password_enc, crypt.crypt(password, Const.LEGACY_AUTH_SALT).substring(2), Const.DEFAULT_ENCODING);
+            }
+        }
+        if (role)
+            blr.addString(Const.isc_dpb_sql_role_name, role, Const.DEFAULT_ENCODING);
+    
+        blr.addBytes([Const.isc_dpb_process_id, 4]);
+        blr.addInt32(process.pid);
+    
+        let processName  = process.title || "";
+        blr.addString(Const.isc_dpb_process_name, processName.length > 255 ? processName.substring(processName.length - 255,  processName.length) : processName, Const.DEFAULT_ENCODING);
+    
+        if (this.accept.authData) {
+            blr.addString(Const.isc_dpb_specific_auth_data, this.accept.authData, Const.DEFAULT_ENCODING);
+        }
+
+        if (options.sessionTimeZone) {
+            blr.addString(Const.isc_dpb_session_time_zone, options.sessionTimeZone, Const.DEFAULT_ENCODING);
+        }
+    
+        blr.addNumeric(Const.isc_dpb_sql_dialect, 3);
+        blr.addNumeric(Const.isc_dpb_force_write, 1);
+        blr.addNumeric(Const.isc_dpb_overwrite, 1);
+        blr.addNumeric(Const.isc_dpb_page_size, pageSize);
+    
+        var msg = this._msg;
+        msg.pos = 0;
+        msg.addInt(Const.op_create);  // op_create
+        msg.addInt(0);          // Database Object ID
+        msg.addString(database, Const.DEFAULT_ENCODING);
+        msg.addBlr(blr);
+    
+        var self = this;
+    
+        function cb(err, ret) {
+    
+            if (ret)
+                self.dbhandle = ret.handle;
+
+            if (callback)
+                callback(err, ret);
+
+            if (!err && ret)
+                ret.emit('attach', ret);
+        }
+    
+        cb.response = new Database(this);
+        this._queueEvent(cb);
+    }
+
+
+    dropDatabase(callback) {
+        var msg = this._msg;
+        msg.pos = 0;
+    
+        msg.addInt(Const.op_drop_database);
+        msg.addInt(this.dbhandle);
+    
+        var self = this;
+        this._queueEvent(function(err) {
+            self.detach(function() {
+                self.disconnect();
+    
+                if (callback)
+                    callback(err);
+            });
+        });
+    }
+
+
+    throwClosed(callback) {
+        var err = new Error('Connection is closed.');
+        this.db.emit('error', err);
+        if (callback)
+            callback(err);
+        return this;
+    }
+
+
+    startTransaction(options, callback) {
+    
+        if (typeof(options) === 'function') {
+            var tmp = options;
+            options = callback;
+            callback = tmp;
+        }
+    
+        // Compatibility
+        if (Array.isArray(options)) {
+            options = {
+                isolation: options,
+                readOnly: (options === Const.ISOLATION_READ_COMMITTED_READ_ONLY),
+            };
+        }
+    
+        // Default options
+        options = Object.assign({
+            autoCommit: false,
+            autoUndo: true,
+            isolation: Const.ISOLATION_READ_COMMITTED,
+            ignoreLimbo: false,
+            //lock: [],
+            readOnly: false,
+            wait: true,
+            waitTimeout: 0,
+        }, options);
+    
+        if (this._isClosed)
+            return this.throwClosed(callback);
+    
+        // for auto detach
+        this._pending.push('startTransaction');
+    
+        var blr = this._blr;
+        var msg = this._msg;
+    
+        blr.pos = 0;
+        msg.pos = 0;
+    
+        blr.addByte(Const.isc_tpb_version3);
+        blr.addBytes(options.isolation);
+        blr.addByte(options.readOnly ? Const.isc_tpb_read : Const.isc_tpb_write);
+        if (options.wait) {
+            blr.addByte(Const.isc_tpb_wait);
+    
+            if (options.waitTimeout) {
+                blr.addNumeric(Const.isc_tpb_lock_timeout, options.waitTimeout);
+            }
+        } else {
+            blr.addByte(Const.isc_tpb_nowait);
+        }
+        if (!options.autoUndo) {
+            blr.addByte(Const.isc_tpb_no_auto_undo);
+        }
+        if (options.autoCommit) {
+            blr.addByte(Const.isc_tpb_autocommit);
+        }
+        if (options.ignoreLimbo) {
+            blr.addByte(Const.isc_tpb_ignore_limbo);
+        }
+        // TODO
+        /*if (options.lock.length) {
+            for (let table of options.lock) {
+                const lockMode = table.write ? Const.isc_tpb_lock_write : Const.isc_tpb_lock_read;
+                const lockType = table.protected ? Const.isc_tpb_protected : Const.isc_tpb_shared;
+    
+                blr.addString(lockMode, table.table || table, Const.DEFAULT_ENCODING);
+                blr.addByte(lockType);
+            }
+        }*/
+    
+        msg.addInt(Const.op_transaction);
+        msg.addInt(this.dbhandle);
+        msg.addBlr(blr);
+        callback.response = new Transaction(this);
+    
+        this.db.emit('transaction', options);
+        this._queueEvent(callback);
+    }
+
+
+    commit(transaction, callback) {
+    
+        if (this._isClosed)
+            return this.throwClosed(callback);
+    
+        // for auto detach
+        this._pending.push('commit');
+    
+        var msg = this._msg;
+        msg.pos = 0;
+        msg.addInt(Const.op_commit);
+        msg.addInt(transaction.handle);
+        this.db.emit('commit');
+        this._queueEvent(callback);
+    }
+
+
+    rollback(transaction, callback) {
+    
+        if (this._isClosed)
+            return this.throwClosed(callback);
+    
+        // for auto detach
+        this._pending.push('rollback');
+    
+        var msg = this._msg;
+        msg.pos = 0;
+        msg.addInt(Const.op_rollback);
+        msg.addInt(transaction.handle);
+        this.db.emit('rollback');
+        this._queueEvent(callback);
+    }
+
+
+    commitRetaining(transaction, callback) {
+    
+        if (this._isClosed)
+            throw new Error('Connection is closed.');
+    
+        // for auto detach
+        this._pending.push('commitRetaining');
+    
+        var msg = this._msg;
+        msg.pos = 0;
+        msg.addInt(Const.op_commit_retaining);
+        msg.addInt(transaction.handle);
+        this._queueEvent(callback);
+    }
+
+
+    rollbackRetaining(transaction, callback) {
+    
+        if (this._isClosed)
+            return this.throwClosed(callback);
+    
+        // for auto detach
+        this._pending.push('rollbackRetaining');
+    
+        var msg = this._msg;
+        msg.pos = 0;
+        msg.addInt(Const.op_rollback_retaining);
+        msg.addInt(transaction.handle);
+        this._queueEvent(callback);
+    }
+
+
+    allocateStatement(callback) {
+    
+        if (this._isClosed)
+            return this.throwClosed(callback);
+    
+        // for auto detach
+        this._pending.push('allocateStatement');
+    
+        var msg = this._msg;
+        msg.pos = 0;
+        msg.addInt(Const.op_allocate_statement);
+        msg.addInt(this.dbhandle);
+        callback.response = new Statement(this);
+        this._queueEvent(callback);
+    }
+
+
+    dropStatement(statement, callback) {
+    
+        if (this._isClosed)
+            return this.throwClosed(callback);
+    
+        // for auto detach
+        this._pending.push('dropStatement');
+    
+        var msg = this._msg;
+        msg.pos = 0;
+        msg.addInt(Const.op_free_statement);
+        msg.addInt(statement.handle);
+        msg.addInt(Const.DSQL_drop);
+    
+        this._queueEvent(callback, true);
+    }
+
+
+    closeStatement(statement, callback) {
+    
+        if (this._isClosed)
+            return this.throwClosed(callback);
+    
+        // for auto detach
+        this._pending.push('closeStatement');
+    
+        var msg = this._msg;
+        msg.pos = 0;
+        msg.addInt(Const.op_free_statement);
+        msg.addInt(statement.handle);
+        msg.addInt(Const.DSQL_close);
+    
+        this._queueEvent(callback, true);
+    }
+
+
+    allocateAndPrepareStatement(transaction, query, plan, callback) {
+        var self = this;
+        var mainCallback = function(err, ret) {
+            if (!err) {
+                mainCallback.response.handle = ret.handle;
+                describe(ret.buffer, mainCallback.response);
+                mainCallback.response.query = query;
+                self.db.emit('query', query);
+                ret = mainCallback.response;
+                self._setcachedquery(query, ret);
+            }
+    
+            if (callback)
+                callback(err, ret);
+        };
+    
+        // for auto detach
+        this._pending.push('allocateAndPrepareStatement');
+    
+        var msg = this._msg;
+        var blr = this._blr;
+    
+        msg.pos = 0;
+        blr.pos = 0;
+    
+        msg.addInt(Const.op_allocate_statement);
+        msg.addInt(this.dbhandle);
+        mainCallback.lazy_count = 1;
+    
+        blr.addBytes(Const.DESCRIBE);
+        if (plan)
+            blr.addByte(Const.isc_info_sql_get_plan);
+    
+        msg.addInt(Const.op_prepare_statement);
+        msg.addInt(transaction.handle);
+        msg.addInt(0xFFFF);
+        msg.addInt(3); // dialect = 3
+        msg.addString(query, Const.DEFAULT_ENCODING);
+        msg.addBlr(blr);
+        msg.addInt(65535); // buffer_length
+        mainCallback.lazy_count += 1;
+    
+        mainCallback.response = new Statement(this);
+        this._queueEvent(mainCallback);
+    }
+
+
+    prepare(transaction, query, plan, callback) {
+        var self = this;
+    
+        if (this.accept.protocolMinimumType === Const.ptype_lazy_send) { // V11 Statement or higher
+            self.allocateAndPrepareStatement(transaction, query, plan, callback);
+        } else { // V10 Statement
+            self.allocateStatement(function (err, statement) {
+                if (err) {
+                    doError(err, callback);
+                    return;
+                }
+    
+                self.prepareStatement(transaction, statement, query, plan, callback);
+            });
+        }
+    }
+
+
+
+    prepareStatement(transaction, statement, query, plan, callback) {
+    
+        if (this._isClosed)
+            return this.throwClosed(callback);
+    
+        var msg = this._msg;
+        var blr = this._blr;
+    
+        msg.pos = 0;
+        blr.pos = 0;
+    
+        if (plan instanceof Function) {
+            callback = plan;
+            plan = false;
+        }
+    
+        blr.addBytes(Const.DESCRIBE);
+    
+        if (plan)
+            blr.addByte(Const.isc_info_sql_get_plan);
+    
+        msg.addInt(Const.op_prepare_statement);
+        msg.addInt(transaction.handle);
+        msg.addInt(statement.handle);
+        msg.addInt(3); // dialect = 3
+        msg.addString(query, Const.DEFAULT_ENCODING);
+        msg.addBlr(blr);
+        msg.addInt(65535); // buffer_length
+    
+        var self = this;
+        this._queueEvent(function(err, ret) {
+    
+            if (!err) {
+                describe(ret.buffer, statement);
+                statement.query = query;
+                self.db.emit('query', query);
+                ret = statement;
+                self._setcachedquery(query, ret);
+            }
+    
+            if (callback)
+                callback(err, ret);
+        });
+    
+    }
+
+
+
+    executeStatement(transaction, statement, params, callback, custom) {
+    
+        if (this._isClosed)
+            return this.throwClosed(callback);
+    
+        // for auto detach
+        this._pending.push('executeStatement');
+    
+        if (params instanceof Function) {
+            callback = params;
+            params = undefined;
+        }
+    
+        var self = this;
+    
+        var op = Const.op_execute;
+        if (
+            this.accept.protocolVersion >= Const.PROTOCOL_VERSION13 &&
+            statement.type === Const.isc_info_sql_stmt_exec_procedure &&
+            statement.output.length
+        ) {
+            op = Const.op_execute2;
+        }
+    
+        function PrepareParams(params, input, callback) {
+
+            var value, meta;
+            var ret = new Array(params.length);
+
+            function putBlobData(index, value, callback) {
+    
+                self.createBlob2(transaction, function(err, blob) {
+    
+                    var b;
+                    var isStream = value.readable;
+    
+                    if (Buffer.isBuffer(value))
+                        b = value;
+                    else if (typeof(value) === 'string')
+                        b = Buffer.from(value, Const.DEFAULT_ENCODING);
+                    else if (!isStream)
+                        b = Buffer.from(JSON.stringify(value), Const.DEFAULT_ENCODING);
+    
+                    // Use configured transfer size or default to 1024
+                    var chunkSize = self.options.blobChunkSize || 1024;
+    
+                    if (Buffer.isBuffer(b)) {
+                        bufferReader(b, chunkSize, function (b, next) {
+                            self.batchSegments(blob, b, next);
+                        }, function() {
+                            ret[index] = new Xsql.SQLParamQuad(blob.oid);
+                            self.closeBlob(blob, callback, false);
+                        });
+                        return;
+                    }
+
+                    var isReading = false;
+                    var isEnd = false;
+
+                    value.on('data', function(chunk) {
+                        // Optimization: If chunk is smaller than transfer size, send directly
+                        if (chunk.length <= chunkSize) {
+                            self.batchSegments(blob, chunk, function () {
+                                if (isEnd && !isReading) {
+                                    ret[index] = new Xsql.SQLParamQuad(blob.oid);
+                                    self.closeBlob(blob, callback, false);
+                                }
+                            });
+                            return;
+                        }
+
+                        value.pause();
+                        isReading = true;
+                        bufferReader(chunk, chunkSize, function (b, next) {
+                            self.batchSegments(blob, b, next);
+                        }, function() {
+                            isReading = false;
+
+                            if (isEnd) {
+                                ret[index] = new Xsql.SQLParamQuad(blob.oid);
+                                self.closeBlob(blob, callback, false);
+                            } else
+                                value.resume();
+                        });
+                    });
+
+                    value.on('end', function() {
+                        isEnd = true;
+                        if (isReading)
+                            return;
+                        // If we are not currently reading (paused), close immediately
+                        // If we are reading, the callback in batchSegments/bufferReader will handle closure
+                        if (!isReading) {
+                            ret[index] = new Xsql.SQLParamQuad(blob.oid);
+                            self.closeBlob(blob, callback, false);
+                        }
+                    });
+                });
+            }
+    
+            function step(i) {
+                if (i === params.length) {
+                    callback(ret);
+                    return;
+                }
+
+                value = params[i];
+                meta = input[i];
+
+                if (value === null || value === undefined) {
+                    switch (meta.type) {
+                        case Const.SQL_VARYING:
+                        case Const.SQL_NULL:
+                        case Const.SQL_TEXT:
+                            ret[i] = new Xsql.SQLParamString(null);
+                            break;
+                        case Const.SQL_DOUBLE:
+                        case Const.SQL_FLOAT:
+                        case Const.SQL_D_FLOAT:
+                            ret[i] = new Xsql.SQLParamDouble(null);
+                            break;
+                        case Const.SQL_TYPE_DATE:
+                        case Const.SQL_TYPE_TIME:
+                        case Const.SQL_TIMESTAMP:
+                        case Const.SQL_TIME_TZ:
+                        case Const.SQL_TIME_TZ_EX:
+                        case Const.SQL_TIMESTAMP_TZ:
+                        case Const.SQL_TIMESTAMP_TZ_EX:
+                            ret[i] = new Xsql.SQLParamDate(null);
+                            break;
+                        case Const.SQL_BLOB:
+                        case Const.SQL_ARRAY:
+                        case Const.SQL_QUAD:
+                            ret[i] = new Xsql.SQLParamQuad(null);
+                            break;
+                        case Const.SQL_LONG:
+                        case Const.SQL_SHORT:
+                        case Const.SQL_INT64:
+                        case Const.SQL_BOOLEAN:
+                            ret[i] = new Xsql.SQLParamInt(null);
+                            break;
+                        default:
+                            ret[i] = null;
+                    }
+                    step(i + 1);
+                } else {
+                    switch (meta.type) {
+                        case Const.SQL_BLOB:
+                            putBlobData(i, value, function() { step(i + 1); });
+                            break;
+
+                        case Const.SQL_TIMESTAMP:
+                        case Const.SQL_TYPE_DATE:
+                        case Const.SQL_TYPE_TIME:
+                        case Const.SQL_TIME_TZ:
+                        case Const.SQL_TIME_TZ_EX:
+                        case Const.SQL_TIMESTAMP_TZ:
+                        case Const.SQL_TIMESTAMP_TZ_EX:
+                            if (value instanceof Date)
+                                ret[i] = new Xsql.SQLParamDate(value);
+                            else if (typeof(value) === 'string')
+                                ret[i] = new Xsql.SQLParamDate(parseDate(value));
+                            else
+                                ret[i] = new Xsql.SQLParamDate(new Date(value));
+
+                            step(i + 1);
+                            break;
+
+                        default:
+                            switch (typeof value) {
+                                case 'bigint':
+                                    ret[i] = new Xsql.SQLParamInt128(value);
+                                    break;
+                                case 'number':
+                                    if (value % 1 === 0) {
+                                        if (value >= Const.MIN_INT && value <= Const.MAX_INT)
+                                            ret[i] = new Xsql.SQLParamInt(value);
+                                        else
+                                            ret[i] = new Xsql.SQLParamInt64(value);
+                                    } else
+                                        ret[i] = new Xsql.SQLParamDouble(value);
+                                    break;
+                                case 'string':
+                                    ret[i] = new Xsql.SQLParamString(value);
+                                    break;
+                                case 'boolean':
+                                    ret[i] = new Xsql.SQLParamBool(value);
+                                    break;
+                                default:
+                                    //throw new Error('Unexpected parametter: ' + JSON.stringify(params) + ' - ' + JSON.stringify(input));
+                                    ret[i] = new Xsql.SQLParamString(value.toString());
+                                    break;
+                            }
+                            step(i + 1);
+                    }
+                }
+            }
+
+            step(0);
+        }
+    
+        var input = statement.input;
+    
+        if (input.length) {
+    
+            if (!(params instanceof Array)) {
+                if (params !== undefined)
+                    params = [params];
+                else
+                    params = [];
+            }
+    
+            if (params.length !== input.length) {
+                self._pending.pop();
+                callback(new Error('Expected parameters: (params=' + params.length + ' vs. expected=' + input.length + ') - ' + statement.query));
+                return;
+            }
+    
+            PrepareParams(params, input, function(prms) {
+                self.sendExecute(op, statement, transaction, callback, prms);
+            });
+    
+            return;
+        }
+    
+        this.sendExecute(op, statement, transaction, callback);
+    }
+
+
+    sendExecute(op, statement, transaction, callback, parameters) {
+        var msg = this._msg;
+        var blr = this._blr;
+        msg.pos = 0;
+        blr.pos = 0;
+    
+        msg.addInt(op);
+        msg.addInt(statement.handle);
+        msg.addInt(transaction.handle);
+    
+        if (parameters && parameters.length) {
+            CalcBlr(blr, parameters);
+            msg.addBlr(blr);    // params blr
+            msg.addInt(0); // message number
+            msg.addInt(1); // param count
+    
+            if (this.accept.protocolVersion >= Const.PROTOCOL_VERSION13) {
+                // start with null indicator bitmap
+                var nullBits = new BitSet();
+    
+                for (var i = 0; i < parameters.length; i++) {
+                    nullBits.set(i, (parameters[i].value === null) & 1);
+                }
+    
+                var nullBuffer = nullBits.toBuffer();
+                var requireBytes = Math.floor((parameters.length + 7) / 8);
+                var remainingBytes = requireBytes - nullBuffer.length;
+    
+                if (nullBuffer.length) {
+                    msg.addBuffer(nullBuffer);
+                }
+                if (remainingBytes > 0) {
+                    msg.addBuffer(Buffer.alloc(remainingBytes));
+                }
+                msg.addAlignment(requireBytes);
+    
+                for(var i = 0; i < parameters.length; i++) {
+                    if (parameters[i].value !== null) {
+                        parameters[i].encode(msg);
+                    }
+                }
+            } else {
+                for(var i = 0; i < parameters.length; i++) {
+                    parameters[i].encode(msg);
+                    if (parameters[i].value !== null) {
+                        msg.addInt(0);
+                    }
+                }
+            }
+        } else {
+            msg.addBlr(blr);    // empty
+            msg.addInt(0); // message number
+            msg.addInt(0); // param count
+        }
+    
+        if (op === Const.op_execute2) {
+            var outputBlr = new BlrWriter(32);
+    
+            if (statement.output && statement.output.length) {
+                CalcBlr(outputBlr, statement.output);
+                msg.addBlr(outputBlr);
+            } else {
+                msg.addBlr(outputBlr); // empty
+            }
+            msg.addInt(0); // out_message_number = out_message_type
+        }
+
+        if (this.accept.protocolVersion >= Const.PROTOCOL_VERSION16) {
+            // TODO impl statement timout
+            msg.addInt(statement.options?.timeout || 0); // p_sqldata_timeout
+        }
+    
+        callback.statement = statement;
+        this._queueEvent(callback);
+    }
+
+
+
+
+    fetch(statement, transaction, count, callback) {
+    
+        var msg = this._msg;
+        var blr = this._blr;
+    
+        msg.pos = 0;
+        blr.pos = 0;
+    
+        if (count instanceof Function) {
+            callback = count;
+            count = Const.DEFAULT_FETCHSIZE;
+        }
+    
+        msg.addInt(Const.op_fetch);
+        msg.addInt(statement.handle);
+        CalcBlr(blr, statement.output);
+        msg.addBlr(blr);
+        msg.addInt(0); // message number
+        msg.addInt(count || Const.DEFAULT_FETCHSIZE); // fetch count
+    
+        callback.statement = statement;
+        this._queueEvent(callback);
+    }
+
+
+    fetchAll(statement, transaction, callback) {
+        const self = this;
+        const custom = statement.options || {};
+        const asStream = custom.asStream && custom.on;
+        const data = asStream ? null : [];
+        let streamIndex = 0;
+        const loop = (err, ret) => {
+            if (err) {
+                callback(err);
+                return;
+            }
+
+            if (ret && ret.data && ret.data.length) {
+                const arrPromise = (ret.arrBlob || []).map((value) => value(transaction));
+
+                Promise.all(arrPromise).then((arrBlob) => {
+                    for (let i = 0; i < arrBlob.length; i++) {
+                        const blob = arrBlob[i];
+                        ret.data[blob.row][blob.column] = blob.value;
+                    }
+
+                    doSynchronousLoop(ret.data, (row, _i, next) => {
+                        const pos = asStream ? streamIndex++ : (data.push(row) - 1);
+                        if (asStream) {
+                            executeStreamRow(custom, row, pos, statement.output, next);
+                        } else {
+                            next();
+                        }
+                    }, (streamErr) => {
+                        if (streamErr) {
+                            callback(streamErr);
+                            return;
+                        }
+
+                        if (ret.fetched) {
+                            callback(undefined, data || []);
+                        } else {
+                            self.fetch(statement, transaction, Const.DEFAULT_FETCHSIZE, loop);
+                        }
+                    });
+                }).catch(callback);
+                return;
+            }
+
+            if (ret && ret.fetched) {
+                callback(undefined, data || []);
+            } else {
+                self.fetch(statement, transaction, Const.DEFAULT_FETCHSIZE, loop);
+            }
+        };
+
+        this.fetch(statement, transaction, Const.DEFAULT_FETCHSIZE, loop);
+    }
+
+
+
+    openBlob(blob, transaction, callback) {
+        var msg = this._msg;
+        msg.pos = 0;
+        msg.addInt(Const.op_open_blob);
+        msg.addInt(transaction.handle);
+        msg.addQuad(blob);
+        this._queueEvent(callback);
+    }
+
+
+    closeBlob(blob, callback, defer = true) {
+        var msg = this._msg;
+        msg.pos = 0;
+        msg.addInt(Const.op_close_blob);
+        msg.addInt(blob.handle);
+        this._queueEvent(callback, defer);
+    }
+
+
+    getSegment(blob, callback) {
+        var msg = this._msg;
+        msg.pos = 0;
+        msg.addInt(Const.op_get_segment);
+        msg.addInt(blob.handle);
+        msg.addInt(1024); // buffer length
+        msg.addInt(0); // ???
+        this._queueEvent(callback);
+    }
+
+
+    createBlob2(transaction, callback) {
+        var msg = this._msg;
+        msg.pos = 0;
+        msg.addInt(Const.op_create_blob2);
+        msg.addInt(0);
+        msg.addInt(transaction.handle);
+        msg.addInt(0);
+        msg.addInt(0);
+        this._queueEvent(callback);
+    }
+
+
+    batchSegments(blob, buffer, callback) {
+        var msg = this._msg;
+        var blr = this._blr;
+        msg.pos = 0;
+        blr.pos = 0;
+        msg.addInt(Const.op_batch_segments);
+        msg.addInt(blob.handle);
+        msg.addInt(buffer.length + 2);
+        blr.addBuffer(buffer);
+        msg.addBlr(blr);
+        this._queueEvent(callback);
+    }
+
+
+    svcattach(options, callback, svc) {
+        this._lowercase_keys = options.lowercase_keys || Const.DEFAULT_LOWERCASE_KEYS;
+        var database = options.database || options.filename;
+        var user = options.user || Const.DEFAULT_USER;
+        var password = options.password || Const.DEFAULT_PASSWORD;
+        var role = options.role;
+        var msg = this._msg;
+        var blr = this._blr;
+        msg.pos = 0;
+        blr.pos = 0;
+    
+        blr.addBytes([Const.isc_dpb_version2, Const.isc_dpb_version2]);
+        blr.addString(Const.isc_dpb_lc_ctype, 'UTF8', Const.DEFAULT_ENCODING);
+        
+        // For Firebird 3+ (protocol 13+), add UTF-8 filename flag to ensure all DPB strings are handled with UTF-8
+        if (this.accept.protocolVersion >= Const.PROTOCOL_VERSION13) {
+            blr.addByte(Const.isc_dpb_utf8_filename);
+            blr.addByte(0);
+        }
+        
+        blr.addString(Const.isc_dpb_user_name, user, Const.DEFAULT_ENCODING);
+        blr.addString(Const.isc_dpb_password, password, Const.DEFAULT_ENCODING);
+        blr.addByte(Const.isc_dpb_dummy_packet_interval);
+        blr.addByte(4);
+        blr.addBytes([120, 10, 0, 0]); // FROM DOT NET PROVIDER
+        if (role)
+            blr.addString(Const.isc_dpb_sql_role_name, role, Const.DEFAULT_ENCODING);
+    
+        msg.addInt(Const.op_service_attach);
+        msg.addInt(0);
+        msg.addString(Const.DEFAULT_SVC_NAME, Const.DEFAULT_ENCODING); // only local for moment
+        msg.addBlr(this._blr);
+    
+        var self = this;
+    
+        function cb(err, ret) {
+    
+            if (err) {
+                doError(err, callback);
+                return;
+            }
+    
+            self.svchandle = ret.handle;
+            if (callback)
+                callback(undefined, ret);
+        }
+    
+        // For reconnect
+        if (svc) {
+            svc.connection = this;
+            cb.response = svc;
+        } else {
+            cb.response = new ServiceManager(this);
+            cb.response.removeAllListeners('error');
+            cb.response.on('error', noop);
+        }
+    
+        this._queueEvent(cb);
+    }
+
+
+    svcstart(spbaction, callback) {
+        var msg = this._msg;
+        var blr = this._blr;
+        msg.pos = 0;
+        msg.addInt(Const.op_service_start);
+        msg.addInt(this.svchandle);
+        msg.addInt(0)
+        msg.addBlr(spbaction);
+        this._queueEvent(callback);
+    }
+
+
+    svcquery(spbquery, resultbuffersize, timeout,callback) {
+        if (resultbuffersize > Const.MAX_BUFFER_SIZE) {
+            doError(new Error('Buffer is too big'), callback);
+            return;
+        }
+    
+        var msg = this._msg;
+        var blr = this._blr;
+        msg.pos = 0;
+        blr.pos = 0;
+        blr.addByte(Const.isc_spb_current_version);
+        //blr.addByteInt32(Const.isc_info_svc_timeout, timeout);
+        msg.addInt(Const.op_service_info);
+        msg.addInt(this.svchandle);
+        msg.addInt(0);
+        msg.addBlr(blr);
+        blr.pos = 0
+        blr.addBytes(spbquery);
+        msg.addBlr(blr);
+        msg.addInt(resultbuffersize);
+        this._queueEvent(callback);
+    }
+
+
+    svcdetach(callback) {
+        var self = this;
+    
+        if (self._isClosed)
+            return;
+    
+        self._isUsed = false;
+        self._isDetach = true;
+    
+        var msg = self._msg;
+    
+        msg.pos = 0;
+        msg.addInt(Const.op_service_detach);
+        msg.addInt(this.svchandle); // Database Object ID
+    
+        self._queueEvent(function (err, ret) {
+            delete (self.svchandle);
+            if (callback)
+                callback(err, ret);
+        });
+    }
+
+
+
+    auxConnection(callback) {
+        var self = this;
+        if (self._isClosed)
+            return this.throwClosed(callback);
+        var msg = self._msg;
+        msg.pos = 0;
+        msg.addInt(Const.op_connect_request);
+        msg.addInt(1); // async
+        msg.addInt(self.dbhandle);
+        msg.addInt(0);
+        if (process.env.FIREBIRD_DEBUG) {
+            console.log('[fb-debug] auxConnection: sending op_connect_request(53) dbhandle=%d queue_before=%d xdr_saved=%s',
+                self.dbhandle, self._queue.length, Boolean(self._xdr));
+        }
+        function cb(err, ret) {
+    
+            if (err) {
+                if (process.env.FIREBIRD_DEBUG) {
+                    console.log('[fb-debug] auxConnection: op_connect_request error: %s queue=%d', err.message, self._queue.length);
+                }
+                doError(err, callback);
+                return;
+            }
+    
+            var socket_info = {
+                family: ret.buffer.readInt16BE(0),
+                port: ret.buffer.readUInt16BE(2),
+                host: ret.buffer.readUInt8(4) + '.' + ret.buffer.readUInt8(5) + '.' + ret.buffer.readUInt8(6) + '.' + ret.buffer.readUInt8(7)
+            }
+
+            if (process.env.FIREBIRD_DEBUG) {
+                console.log('[fb-debug] auxConnection: op_response ok → aux family=%d port=%d host=%s queue=%d',
+                    socket_info.family, socket_info.port, socket_info.host, self._queue.length);
+            }
+    
+            callback(undefined, socket_info);
+        }
+        this._queueEvent(cb);
+    }
+
+
+    queEvents(events, eventid, callback) {
+        var self = this;
+        if (this._isClosed)
+            return this.throwClosed(callback);
+        var msg = this._msg;
+        var blr = this._blr;
+        blr.pos = 0;
+        msg.pos = 0;
+        msg.addInt(Const.op_que_events);
+        msg.addInt(this.dbhandle);
+        // prepare EPB
+        blr.addByte(1) // epb_version
+        for (var event in events) {
+            var event_buffer = Buffer.from(event, 'UTF8');
+            blr.addByte(event_buffer.length);
+            blr.addBytes(event_buffer);
+            blr.addInt32(events[event]);
+        }
+        msg.addBlr(blr);    // epb    
+        msg.addInt(0);    // ast
+        msg.addInt(0);   // args
+        msg.addInt(eventid);
+        
+        function cb(err, ret) {
+            if (err) {
+                doError(err, callback);
+                return;
+            }
+            
+            callback(null, ret);
+        }
+        
+        this._queueEvent(cb);
+    }
+
+
+    closeEvents(eventid, callback) {
+        var self = this;
+        if (this._isClosed)
+            return this.throwClosed(callback);
+        var msg = self._msg;
+        msg.pos = 0;
+        msg.addInt(Const.op_cancel_events);
+        msg.addInt(self.dbhandle);
+        msg.addInt(eventid);
+    
+        function cb(err, ret) {
+            if (err) {
+                doError(err, callback);
+                return;
+            }
+    
+            callback(null);
+        }
+    
+        this._queueEvent(cb);
+    }
+
+}
+
+// Reverse-lookup table: opcode number → name for FIREBIRD_DEBUG trace logging.
+const opcodeNames = Object.fromEntries(
+    Object.entries(Const).filter(([k]) => k.startsWith('op_')).map(([k, v]) => [v, k])
+);
+
+function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
+    try {
+        do {
+            var r = data.r || data.readInt();
+        } while (r === Const.op_dummy);
+
+        if (process.env.FIREBIRD_DEBUG) {
+            console.log('[fb-debug] decodeResponse: opcode=%d(%s) pos=%d buflen=%d',
+                r, opcodeNames[r] || 'unknown', data.pos, data.buffer.length);
+        }
+
+        var item, op, response;
+
+        switch (r) {
+            case Const.op_response:
+
+                if (callback) {
+                    response = callback.response || {};
+                } else {
+                    response = {};
+                }
+
+                let loop = function (err) {
+                    if (err) {
+                        return cb(err);
+                    } else {
+                        if (callback && callback.lazy_count) {
+                            callback.lazy_count--;
+                            if (callback.lazy_count > 0) {
+                                r = data.readInt(); // Read new op
+                                parseOpResponse(data, response, loop);
+                            } else {
+                                cb(null, response);
+                            }
+                        } else {
+                            cb(null, response);
+                        }
+                    }
+                };
+                // Parse normal and lazy response
+                return parseOpResponse(data, response, loop);
+            case Const.op_fetch_response:
+            case Const.op_sql_response:
+                var statement = callback.statement;
+                var output = statement.output;
+                var custom = statement.options || {};
+                var isOpFetch = r === Const.op_fetch_response;
+                var _xdrpos;
+                statement.nbrowsfetched = statement.nbrowsfetched || 0;
+
+                if (isOpFetch && data.fop) { // could be set when a packet is not complete
+                    data.readBuffer(68); // ??
+                    op = data.readInt(); // ??
+                    data.fop = false;
+                    if (op === Const.op_response) {
+                        return parseOpResponse(data, {}, cb);
+                    }
+                }
+
+                if (!isOpFetch) {
+                    data.fstatus = 0;
+                }
+
+                data.fstatus = data.fstatus !== undefined ? data.fstatus : data.readInt();
+                data.fcount = data.fcount !== undefined ? data.fcount : data.readInt();
+                data.fcolumn = data.fcolumn || 0;
+                data.frow = data.frow || (custom.asObject ? {} : new Array(output.length));
+                data.frows = data.frows || [];
+
+                if (custom.asObject && !data.fcols) {
+                    if (lowercase_keys) {
+                        data.fcols = output.map((column) => column.alias.toLowerCase());
+                    } else {
+                        data.fcols = output.map((column) => column.alias);
+                    }
+                }
+
+                const arrBlob = [];
+                const lowerV13 = statement.connection.accept.protocolVersion <  Const.PROTOCOL_VERSION13;
+
+                while (data.fcount && (data.fstatus !== 100)) {
+                    let nullBitSet;
+                    if (!lowerV13) {
+                        const nullBitsLen = Math.floor((output.length + 7) / 8);
+                        nullBitSet = new BitSet(data.readBuffer(nullBitsLen, false));
+                        data.readBuffer((4 - nullBitsLen) & 3, false); // Skip padding
+                    }
+
+                    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;
+                            }
+
+                            continue;
+                        }
+
+                        try {
+                            _xdrpos = data.pos;
+                            const key = custom.asObject ? data.fcols[data.fcolumn] : data.fcolumn;
+                            const row = data.frows.length;
+                            let value = item.decode(data, lowerV13);
+
+                            if (item.type === Const.SQL_BLOB && value !== null) {
+                                if (item.subType === Const.isc_blob_text && cnx.options.blobAsText) {
+                                    value = fetch_blob_async_transaction(statement, value, key, row);
+                                    arrBlob.push(value);
+                                } else {
+                                    value = fetch_blob_async(statement, value, key, row);
+                                }
+                            }
+
+                            data.frow[key] = value;
+                        } catch (e) {
+                            // uncomplete packet read
+                            data.pos = _xdrpos;
+                            data.r = r;
+                            return cb(new Error('Packet is not complete'));
+                        }
+
+                    }
+
+                    data.fcolumn = 0;
+                    // ToDo: emit "row" with blob subtype string decoded
+                    // use: data.frow['fieldBlob'](transaction?).then(({ value }) => console.log(value))
+                    // arg "transaction" is optional
+                    statement.connection.db.emit('row', data.frow, statement.nbrowsfetched, custom.asObject);
+                    data.frows.push(data.frow);
+                    data.frow = custom.asObject ? {} : new Array(output.length);
+
+                    try {
+                        _xdrpos = data.pos;
+                        if (isOpFetch) {
+                            delete data.fstatus;
+                            delete data.fcount;
+                            op = data.readInt(); // ??
+                            if (op === Const.op_response) {
+                                return parseOpResponse(data, {}, cb);
+                            }
+                            data.fstatus = data.readInt();
+                            data.fcount = data.readInt();
+                        } else {
+                            data.fcount--;
+                            if (r === Const.op_sql_response) {
+                                op = data.readInt();
+                                if (op === Const.op_response) {
+                                    parseOpResponse(data, {});
+                                }
+                            }
+                        }
+                    } catch (e) {
+                        if (_xdrpos === data.pos) {
+                            data.fop = true;
+                        }
+                        data.r = r;
+                        return cb(new Error("Packet is not complete"));
+                    }
+                    statement.nbrowsfetched++;
+                }
+
+                // 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});
+            case Const.op_accept:
+            case Const.op_cond_accept:
+            case Const.op_accept_data:
+                let accept = {
+                    protocolVersion: data.readInt(),
+                    protocolArchitecture: data.readInt(),
+                    protocolMinimumType: data.readInt(),
+                    compress: false,
+                    pluginName: '',
+                    authData: '',
+                    sessionKey: ''
+                };
+
+                accept.compress = (accept.protocolMinimumType & Const.pflag_compress) !== 0;
+                accept.protocolMinimumType = accept.protocolMinimumType & Const.ptype_mask;
+                //accept.compress = (accept.acceptType & pflag_compress) !== 0; // TODO Handle zlib compression
+                if (accept.protocolVersion < 0) {
+                    accept.protocolVersion = (accept.protocolVersion & Const.FB_PROTOCOL_MASK) | Const.FB_PROTOCOL_FLAG;
+                }
+
+                if (r === Const.op_cond_accept || r === Const.op_accept_data) {
+                    var d = new BlrReader(data.readArray());
+                    accept.pluginName = data.readString(Const.DEFAULT_ENCODING);
+                    var is_authenticated = data.readInt();
+                    var keys = data.readString(Const.DEFAULT_ENCODING); // keys
+
+                    if (is_authenticated === 0) {
+                        if (cnx.options.pluginName && cnx.options.pluginName !== accept.pluginName) {
+                            doError(new Error('Server don\'t accept plugin : ' + cnx.options.pluginName + ', but support : ' + accept.pluginName), callback);
+                        }
+
+                        if (Const.AUTH_PLUGIN_SRP_LIST.indexOf(accept.pluginName) !== -1) {
+                            var crypto = {
+                                Srp: 'sha1',
+                                Srp256: 'sha256'
+                            };
+                            accept.srpAlgo = crypto[accept.pluginName];
+
+                            // TODO : Fallback Srp256 to Srp ?
+                            /*if (!d.buffer) {
+                                cnx.sendOpContAuth(
+                                    cnx.clientKeys.public.toString(16),
+                                    DEFAULT_ENCODING,
+                                    accept.pluginName
+                                );
+
+                                return cb(new Error('login'));
+                            }*/
+
+                            // Check buffer contains salt
+                            var saltLen = d.buffer.readUInt16LE(0);
+                            if (saltLen > 32 * 2) {
+                                console.log('salt to long'); // TODO : Throw error
+                            }
+
+                            // Check buffer contains key
+                            var keyLen = d.buffer.readUInt16LE(saltLen + 2);
+                            var keyStart = saltLen + 4;
+                            if (d.buffer.length - keyStart !== keyLen) {
+                                console.log('key error'); // TODO : Throw error
+                            }
+
+                            // Server keys
+                            cnx.serverKeys = {
+                                salt: d.buffer.slice(2, saltLen + 2).toString('utf8'),
+                                public: BigInt('0x' + d.buffer.slice(keyStart, d.buffer.length).toString('utf8'))
+                            };
+
+                            const _t1 = Date.now();
+                            var proof = srp.clientProof(
+                                cnx.options.user.toUpperCase(),
+                                cnx.options.password,
+                                cnx.serverKeys.salt,
+                                cnx.clientKeys.public,
+                                cnx.serverKeys.public,
+                                cnx.clientKeys.private,
+                                accept.srpAlgo
+                            );
+                            if (process.env.FIREBIRD_DEBUG) {
+                                console.log('[fb-debug] srp.clientProof(%s): %dms', accept.srpAlgo, Date.now() - _t1);
+                            }
+
+                            accept.authData = proof.authData.toString(16);
+                            accept.sessionKey = proof.clientSessionKey;
+                        } else if (accept.pluginName === Const.AUTH_PLUGIN_LEGACY) {
+                            accept.authData = crypt.crypt(cnx.options.password, Const.LEGACY_AUTH_SALT).substring(2);
+                        } else {
+                            return cb(new Error('Unknow auth plugin : ' + accept.pluginName));
+                        }
+                    } else {
+                        accept.authData = '';
+                        accept.sessionKey = '';
+                    }
+                }
+
+                if (accept.compress) {
+                    cnx._socket.enableCompression();
+                }
+
+                if (process.env.FIREBIRD_DEBUG) {
+                    console.log('[fb-debug] auth: %s received plugin=%s proto=%d t=%dms',
+                        r === Const.op_cond_accept ? 'op_cond_accept' : r === Const.op_accept_data ? 'op_accept_data' : 'op_accept',
+                        accept.pluginName, accept.protocolVersion,
+                        cnx._authStartTime ? Date.now() - cnx._authStartTime : -1);
+                }
+
+                // For op_cond_accept: send op_cont_auth and wait for response
+                if (r === Const.op_cond_accept && accept.authData) {
+                    cnx._pendingAccept = accept;
+                    if (process.env.FIREBIRD_DEBUG) {
+                        console.log('[fb-debug] auth: sending op_cont_auth plugin=%s t=%dms',
+                            accept.pluginName, cnx._authStartTime ? Date.now() - cnx._authStartTime : -1);
+                    }
+                    cnx.sendOpContAuth(
+                        accept.authData,
+                        Const.DEFAULT_ENCODING,
+                        accept.pluginName
+                    );
+                    return; // Don't call cb - queue stays for op_response
+                }
+
+                return cb(undefined, accept);
+            case Const.op_cont_auth:
+                var d = new BlrReader(data.readArray());
+                var pluginName = data.readString(Const.DEFAULT_ENCODING);
+                data.readString(Const.DEFAULT_ENCODING); // plist
+                data.readString(Const.DEFAULT_ENCODING); // pkey
+
+                if (process.env.FIREBIRD_DEBUG) {
+                    console.log('[fb-debug] auth: op_cont_auth received plugin=%s pendingAccept=%s t=%dms',
+                        pluginName,
+                        cnx._pendingAccept ? cnx._pendingAccept.pluginName : 'none',
+                        cnx._authStartTime ? Date.now() - cnx._authStartTime : -1);
+                }
+
+                // During SRP mutual authentication, the server sends op_cont_auth
+                // with its proof (M2) after receiving the client's proof (M1).
+                // When we have an active auth exchange for this plugin, just wait
+                // for the subsequent op_accept instead of treating it as an error.
+                if (cnx._pendingAccept && cnx._pendingAccept.pluginName === pluginName) {
+                    if (process.env.FIREBIRD_DEBUG) {
+                        console.log('[fb-debug] auth: server SRP proof (M2) received, waiting for op_accept t=%dms',
+                            cnx._authStartTime ? Date.now() - cnx._authStartTime : -1);
+                    }
+                    return; // Server SRP proof received - wait for op_accept
+                }
+
+                // Firebird 4/5 (protocols 16/17) chained-auth: after the client sends
+                // the SRP M1 proof, the server sends op_cont_auth with Legacy_Auth.
+                // SRP has already established the session key; the server additionally
+                // requires a Legacy_Auth verification step before sending op_accept.
+                // Respond with Legacy_Auth credentials and wait for op_accept.
+                if (cnx._pendingAccept && pluginName === Const.AUTH_PLUGIN_LEGACY) {
+                    if (process.env.FIREBIRD_DEBUG) {
+                        console.log('[fb-debug] auth: SRP+Legacy_Auth chained-auth (proto %d), sending Legacy_Auth credentials t=%dms',
+                            cnx._pendingAccept.protocolVersion,
+                            cnx._authStartTime ? Date.now() - cnx._authStartTime : -1);
+                    }
+                    var legacyAuthData = crypt.crypt(cnx.options.password, Const.LEGACY_AUTH_SALT).substring(2);
+                    cnx.sendOpContAuth(legacyAuthData, Const.DEFAULT_ENCODING, pluginName);
+                    return; // wait for op_accept
+                }
+
+                if (!cnx.options.pluginName) {
+                    if (cnx.accept && cnx.accept.pluginName === pluginName) {
+                        // Erreur plugin not able to connect
+                        return cb(new Error("Unable to connect with plugin " + cnx.accept.pluginName));
+                    }
+
+                    if (pluginName === Const.AUTH_PLUGIN_LEGACY) { // Fallback to LegacyAuth
+                        cnx.accept.pluginName = pluginName;
+                        cnx.accept.authData = crypt.crypt(cnx.options.password, Const.LEGACY_AUTH_SALT).substring(2);
+
+                        cnx.sendOpContAuth(
+                            cnx.accept.authData,
+                            Const.DEFAULT_ENCODING,
+                            pluginName
+                        );
+
+                        return {error: new Error('login')};
+                    }
+                }
+
+                // Server sent op_cont_auth but we don't know how to handle it.
+                if (process.env.FIREBIRD_DEBUG) {
+                    console.warn('[fb-debug] auth: op_cont_auth unhandled plugin=%s pendingAccept=%s options.plugin=%s t=%dms',
+                        pluginName,
+                        cnx._pendingAccept ? cnx._pendingAccept.pluginName : 'none',
+                        cnx.options.pluginName || 'none',
+                        cnx._authStartTime ? Date.now() - cnx._authStartTime : -1);
+                }
+                return cb(new Error('Unhandled server op_cont_auth for plugin: ' + pluginName));
+            case Const.op_crypt_key_callback:
+                // Database encryption key callback
+                // Read server data (plugin data sent by server)
+                var serverPluginData = data.readArray();
+                
+                // Get client response from dbCryptConfig option
+                var clientPluginData = parseDbCryptConfig(cnx.options.dbCryptConfig);
+                
+                // Create a BlrWriter to send the response
+                // Note: BlrWriter needs initial buffer size allocation
+                var responseBlr = new BlrWriter(clientPluginData.length + 4);
+                responseBlr.addBytes(clientPluginData);
+                
+                // Send the response back to the server
+                cnx.sendOpCryptKeyCallback(responseBlr);
+                
+                // Don't call cb - wait for next operation (likely op_response or another op_crypt_key_callback)
+                return;
+            case Const.op_event:
+                // op_event may occasionally arrive on the main connection
+                // (e.g. Firebird routing an async notification here instead of
+                // the dedicated aux socket).  Consume all its fields so the
+                // buffer position advances correctly, then signal the data
+                // handler to skip queue manipulation for this frame.
+                //
+                // Firebird wire protocol – op_event payload (remote protocol):
+                //   p_event_database : Int32  – database handle
+                //   p_event_items    : Array  – event parameter block (EPB)
+                //   p_event_ast      : Int64  – AST routine pointer (0 for remote)
+                //   p_event_rid      : Int32  – remote event ID
+                {
+                    const evtDb = data.readInt();    // p_event_database
+                    data.readArray();               // p_event_items (EPB buffer)
+                    data.readInt64();               // p_event_ast
+                    const evtRid = data.readInt();  // p_event_rid
+                    if (process.env.FIREBIRD_DEBUG) {
+                        console.log('[fb-debug] op_event on main connection: db=%d rid=%d (consumed, not queued)', evtDb, evtRid);
+                    }
+                }
+                return cb(null, { _isOpEvent: true });
+            case Const.op_response_piggyback:
+                // Firebird 5 (Protocol 16/17) sends op_response_piggyback (72)
+                // as an unsolicited cleanup notification after certain operations
+                // (e.g. after the EventConnection aux socket is torn down).
+                // It has the same wire layout as op_response but does NOT
+                // correspond to any queued client request.  Parse and discard it
+                // so that the xdr buffer position advances correctly, then signal
+                // the data handler to skip queue manipulation.
+                //
+                // Wire layout (identical to op_response):
+                //   handle  : Int32
+                //   object  : Quad (2x Int32)
+                //   data    : Array
+                //   status  : status-vector ending with isc_arg_end
+                parseOpResponse(data, {}, function(err) {
+                    if (process.env.FIREBIRD_DEBUG) {
+                        if (err) {
+                            console.warn('[fb-debug] op_response_piggyback parse error:', err.message);
+                        } else {
+                            console.log('[fb-debug] op_response_piggyback consumed (unsolicited Firebird 5 cleanup)');
+                        }
+                    }
+                });
+                return cb(null, { _isOpEvent: true });
+            default:
+                if (process.env.FIREBIRD_DEBUG) {
+                    console.warn('[fb-debug] unknown opcode=%d at pos=%d buflen=%d queue=%d',
+                        r, data.pos, data.buffer.length, cnx && cnx._queue ? cnx._queue.length : 0);
+                }
+                return cb(new Error('Unexpected:' + r));
+        }
+    } catch (err) {
+        if (process.env.FIREBIRD_DEBUG) {
+            console.warn('[fb-debug] decodeResponse exception: %s (RangeError=%s) pos=%d buflen=%d',
+                err.message, err instanceof RangeError, data.pos, data.buffer.length);
+        }
+        if (err instanceof RangeError) {
+            return cb(err);
+        }
+        throw err;
+    }
+}
+
+function parseOpResponse(data, response, cb) {
+    var handle = data.readInt();
+
+    if (!response.handle) {
+        response.handle = handle;
+    }
+
+    var oid = data.readQuad();
+    if (oid.low || oid.high) {
+        response.oid = oid;
+    }
+
+    var buf = data.readArray();
+    if (buf) {
+        response.buffer = buf;
+    }
+
+    var num, op, item = {};
+    while (true) {
+        op = data.readInt();
+
+        switch (op) {
+            case Const.isc_arg_end:
+                return cb ? cb(undefined, response) : response;
+            case Const.isc_arg_gds:
+                num = data.readInt();
+                if (!num) {
+                    break;
+                }
+
+                item = {gdscode: num};
+
+                if (response.status) {
+                    response.status.push(item);
+                } else {
+                    response.status = [item];
+                }
+
+                break;
+            case Const.isc_arg_string:
+            case Const.isc_arg_interpreted:
+            case Const.isc_arg_sql_state:
+                if (item.params) {
+                    var str = data.readString(Const.DEFAULT_ENCODING);
+                    item.params.push(str);
+                } else {
+                    item.params = [data.readString(Const.DEFAULT_ENCODING)];
+                }
+
+                break;
+            case Const.isc_arg_number:
+                num = data.readInt();
+
+                if (item.params) {
+                    item.params.push(num);
+                } else {
+                    item.params = [num];
+                }
+
+                if (item.gdscode === Const.isc_sqlerr) {
+                    response.sqlcode = num;
+                }
+
+                break;
+            default:
+                if (cb) {
+                    cb(new Error('Unexpected: ' + op))
+                } else {
+                    throw new Error('Unexpected: ' + op);
+                }
+        }
+    }
+}
+
+function describe(buff, statement) {
+    var br = new BlrReader(buff);
+    var parameters = null;
+    var type, param;
+
+    while (br.pos < br.buffer.length) {
+        switch (br.readByteCode()) {
+            case Const.isc_info_sql_stmt_type:
+                statement.type = br.readInt();
+                break;
+            case Const.isc_info_sql_get_plan:
+                statement.plan = br.readString(Const.DEFAULT_ENCODING);
+                break;
+            case Const.isc_info_sql_select:
+                statement.output = parameters = [];
+                break;
+            case Const.isc_info_sql_bind:
+                statement.input = parameters = [];
+                break;
+            case Const.isc_info_sql_num_variables:
+                br.readInt(); // eat int
+                break;
+            case Const.isc_info_sql_describe_vars:
+                if (!parameters) {return}
+                br.readInt(); // eat int ?
+                var finishDescribe = false;
+                param = null;
+                while (!finishDescribe){
+                    switch (br.readByteCode()) {
+                        case Const.isc_info_sql_describe_end:
+                            break;
+                        case Const.isc_info_sql_sqlda_seq:
+                            var num = br.readInt();
+                            break;
+                        case Const.isc_info_sql_type:
+                            type = br.readInt();
+                            switch (type&~1) {
+                                case Const.SQL_VARYING:   param = new Xsql.SQLVarString(); break;
+                                case Const.SQL_NULL:      param = new Xsql.SQLVarNull(); break;
+                                case Const.SQL_TEXT:      param = new Xsql.SQLVarText(); break;
+                                case Const.SQL_DOUBLE:    param = new Xsql.SQLVarDouble(); break;
+                                case Const.SQL_FLOAT:
+                                case Const.SQL_D_FLOAT:   param = new Xsql.SQLVarFloat(); break;
+                                case Const.SQL_TYPE_DATE: param = new Xsql.SQLVarDate(); break;
+                                case Const.SQL_TYPE_TIME: param = new Xsql.SQLVarTime(); break;
+                                case Const.SQL_TIMESTAMP: param = new Xsql.SQLVarTimeStamp(); break;
+                                case Const.SQL_TIME_TZ:   param = new Xsql.SQLVarTimeTz(); break;
+                                case Const.SQL_TIME_TZ_EX: param = new Xsql.SQLVarTimeTzEx(); break;
+                                case Const.SQL_TIMESTAMP_TZ: param = new Xsql.SQLVarTimeStampTz(); break;
+                                case Const.SQL_TIMESTAMP_TZ_EX: param = new Xsql.SQLVarTimeStampTzEx(); break;
+                                case Const.SQL_BLOB:      param = new Xsql.SQLVarBlob(); break;
+                                case Const.SQL_ARRAY:     param = new Xsql.SQLVarArray(); break;
+                                case Const.SQL_QUAD:      param = new Xsql.SQLVarQuad(); break;
+                                case Const.SQL_LONG:      param = new Xsql.SQLVarInt(); break;
+                                case Const.SQL_SHORT:     param = new Xsql.SQLVarShort(); break;
+                                case Const.SQL_INT64:     param = new Xsql.SQLVarInt64(); break;
+                                case Const.SQL_INT128:     param = new Xsql.SQLVarInt128(); break;
+                                case Const.SQL_DEC16:     param = new Xsql.SQLVarDecFloat16(); break;
+                                case Const.SQL_DEC34:     param = new Xsql.SQLVarDecFloat34(); break;
+                                case Const.SQL_BOOLEAN:   param = new Xsql.SQLVarBoolean(); break;
+                                default:
+                                    throw new Error('Unexpected');
+                            }
+                            parameters[num-1] = param;
+                            param.type = type;
+                            param.nullable = Boolean(param.type & 1);
+                            param.type &= ~1;
+                            break;
+                        case Const.isc_info_sql_sub_type:
+                            param.subType = br.readInt();
+                            break;
+                        case Const.isc_info_sql_scale:
+                            param.scale = br.readInt();
+                            break;
+                        case Const.isc_info_sql_length:
+                            param.length = br.readInt();
+                            break;
+                        case Const.isc_info_sql_null_ind:
+                            param.nullable = Boolean(br.readInt());
+                            break;
+                        case Const.isc_info_sql_field:
+                            param.field = br.readString(Const.DEFAULT_ENCODING);
+                            break;
+                        case Const.isc_info_sql_relation:
+                            param.relation = br.readString(Const.DEFAULT_ENCODING);
+                            break;
+                        case Const.isc_info_sql_owner:
+                            param.owner = br.readString(Const.DEFAULT_ENCODING);
+                            break;
+                        case Const.isc_info_sql_alias:
+                            param.alias = br.readString(Const.DEFAULT_ENCODING);
+                            break;
+                        case Const.isc_info_sql_relation_alias:
+                            param.relationAlias = br.readString(Const.DEFAULT_ENCODING);
+                            break;
+                        case Const.isc_info_truncated:
+                            throw new Error('Truncated');
+                        default:
+                            finishDescribe = true;
+                            br.pos--;
+                    }
+                }
+        }
+    }
+}
+
+function CalcBlr(blr, xsqlda) {
+    blr.addBytes([Const.blr_version5, Const.blr_begin, Const.blr_message, 0]); // + message number
+    blr.addWord(xsqlda.length * 2);
+
+    for (var i = 0, length = xsqlda.length; i < length; i++) {
+        xsqlda[i].calcBlr(blr);
+        blr.addByte(Const.blr_short);
+        blr.addByte(0);
+    }
+
+    blr.addByte(Const.blr_end);
+    blr.addByte(Const.blr_eoc);
+}
+
+function fetch_blob_async_transaction(statement, id, column, row) {
+    const infoValue = { row, column, value: '' };
+
+    return (transactionArg) => {
+        const singleTransaction = transactionArg === undefined;
+
+        let promiseTransaction;
+        if (singleTransaction) {
+            promiseTransaction = new Promise((resolve, reject) => {
+                statement.connection.startTransaction(Const.ISOLATION_READ_UNCOMMITTED, (err, transaction) => {
+                    if (err) {
+                        return reject(err);
+                    }
+                    resolve(transaction);
+                });
+            });
+        } else {
+            promiseTransaction = Promise.resolve(transactionArg);
+        }
+
+        return promiseTransaction.then((transaction) => {
+            return new Promise((resolve, reject) => {
+                statement.connection._pending.push('openBlob');
+                statement.connection.openBlob(id, transaction, (err, blob) => {
+
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+
+                    const read = () => {
+                        statement.connection.getSegment(blob, (err, ret) => {
+
+                            if (err) {
+                                if (singleTransaction) {
+                                    transaction.rollback(() => reject(err));
+                                } else {
+                                    reject(err);
+                                }
+                                return;
+                            }
+
+                            if (ret.buffer) {
+                                const blr = new BlrReader(ret.buffer);
+                                const data = blr.readSegment();
+                                infoValue.value += data.toString(Const.DEFAULT_ENCODING);
+                            }
+
+                            if (ret.handle !== 2) {
+                                read();
+                                return;
+                            }
+
+                            statement.connection.closeBlob(blob);
+                            if (singleTransaction) {
+                                transaction.commit((err) => {
+                                    if (err) {
+                                        reject(err);
+                                    } else {
+                                        resolve(infoValue);
+                                    }
+                                });
+                            } else {
+                                resolve(infoValue);
+                            }
+                        });
+                    };
+
+                    read();
+                });
+            });
+        });
+    };
+}
+
+function fetch_blob_async(statement, id, name, row) {
+    const cbTransaction = (transaction, close, callback) => {
+        statement.connection._pending.push('openBlob');
+        statement.connection.openBlob(id, transaction, (err, blob) => {
+            let e = new Events.EventEmitter();
+
+            e.pipe = (stream) => {
+                e.on('data', (chunk) => {
+                    stream.write(chunk);
+                });
+                e.on('end', () => {
+                    stream.end();
+                });
+            };
+
+            if (err) {
+                return callback(err, name, e, row);
+            }
+
+            const read = () => {
+                statement.connection.getSegment(blob, (err, ret) => {
+
+                    if (err) {
+                        transaction.rollback(() => {
+                            e.emit('error', err);
+                        });
+                        return;
+                    }
+
+                    if (ret.buffer) {
+                        const blr = new BlrReader(ret.buffer);
+                        const data = blr.readSegment();
+
+                        e.emit('data', data);
+                    }
+
+                    if (ret.handle !== 2) {
+                        read();
+                        return;
+                    }
+
+                    statement.connection.closeBlob(blob);
+                    if (close) {
+                        transaction.commit((err) => {
+                            if (err) {
+                                e.emit('error', err);
+                            } else {
+                                e.emit('end');
+                            }
+                            e = null;
+                        });
+                    } else {
+                        e.emit('end');
+                        e = null;
+                    }
+                });
+            };
+
+            callback(err, name, e, row);
+            read();
+        });
+    };
+
+    return (transaction, callback) => {
+        // callback(error, nameField, eventEmitter, row)
+        const singleTransaction = callback === undefined;
+        if (singleTransaction) {
+            callback = transaction;
+            statement.connection.startTransaction(Const.ISOLATION_READ_UNCOMMITTED, (err, transaction) => {
+                if (err) {
+                    callback(err);
+                    return;
+                }
+                cbTransaction(transaction, singleTransaction, callback);
+            });
+        } else {
+            cbTransaction(transaction, singleTransaction, callback);
+        }
+    };
+}
+
+function doSynchronousLoop(data, processData, done) {
+    if (!data || !data.length) {
+        done();
+        return;
+    }
+
+    const loop = (index) => {
+        processData(data[index], index, (err) => {
+            if (err) {
+                done(err);
+                return;
+            }
+
+            const nextIndex = index + 1;
+            if (nextIndex < data.length) {
+                loop(nextIndex);
+            } else {
+                done();
+            }
+        });
+    };
+
+    loop(0);
+}
+
+function executeStreamRow(custom, row, index, output, next) {
+    let done = false;
+    const finish = (err) => {
+        if (done) {
+            return;
+        }
+        done = true;
+        next(err);
+    };
+
+    try {
+        const ret = custom.on(row, index, output, finish);
+        if (custom.on.length < 4) {
+            if (ret && typeof ret.then === 'function') {
+                ret.then(() => finish()).catch(finish);
+            } else {
+                finish();
+            }
+        } else if (ret && typeof ret.then === 'function') {
+            ret.catch(finish);
+        }
+    } catch (err) {
+        finish(err);
+    }
+}
+
+function bufferReader(buffer, max, writer, cb, beg, end) {
+
+    if (!beg)
+        beg = 0;
+
+    if (!end)
+        end = max;
+
+    if (end >= buffer.length)
+        end = undefined;
+
+    var b = buffer.slice(beg, end);
+
+    writer(b, function() {
+
+        if (end === undefined) {
+            cb();
+            return;
+        }
+
+        bufferReader(buffer, max, writer, cb, beg + max, end + max);
+    });
+}
+
+/**
+ * Parse dbCryptConfig option and convert to bytes.
+ * Supports:
+ * - "base64:<value>" - decodes base64 to bytes
+ * - plain string - encodes as UTF-8
+ * - undefined/null/empty - returns empty buffer
+ */
+function parseDbCryptConfig(config) {
+    if (!config) {
+        return Buffer.alloc(0);
+    }
+
+    // Check if it's a base64 encoded value
+    if (config.startsWith('base64:')) {
+        const base64Value = config.substring(7);
+        try {
+            return Buffer.from(base64Value, 'base64');
+        } catch (e) {
+            console.error('Failed to decode base64 dbCryptConfig, returning empty buffer:', e);
+            return Buffer.alloc(0);
+        }
+    }
+
+    // Plain string - encode as UTF-8
+    return Buffer.from(config, 'utf8');
+}
+
+module.exports = Connection;