node-firebird 1.1.9 → 2.0.0

package/lib/wire/connection.js

@@ -1,5 +1,4 @@
 const Events = require('events');
-const net = require('net');
 const os = require('os');
 const path = require('path');
 const BigInt = require('big-integer');
@@ -15,6 +14,7 @@ const Database = require('./database');
 const Statement = require('./statement');
 const Transaction = require('./transaction');
 const {lookupMessages, noop, parseDate} = require('../utils');
+const Socket = require("./socket");
 
 /***************************************
  *
@@ -22,182 +22,1518 @@ const {lookupMessages, noop, parseDate} = require('../utils');
  *
  ***************************************/
 
-var Connection = function (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 = net.createConnection(port, host);
-    this._pending = [];
-    this._isOpened = false;
-    this._isClosed = false;
-    this._isDetach = false;
-    this._isUsed = false;
-    this._pooled = options.isPool||false;
-    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');
-};
-
-Connection.prototype._setcachedquery = function (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;
+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;
+    
+            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);
+            }
+    
+            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) {
+                        xdr.buffer = xdr.buffer.slice(pos);
+                        xdr.pos = 0;
+                        self._xdr = xdr;
+    
+                        if (self.accept.protocolMinimumType === Const.ptype_lazy_send && self._queue.length > 0) {
+                            self._queue[0].lazy_count = 2;
+                        }
+                        return;
+                    }
+    
+                    // remove the op flag, needed for partial packet
+                    if (xdr.r) {
+                        delete (xdr.r);
+                    }
+    
+                    self._queue.shift();
+                    self._pending.shift();
+    
+                    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');
+    
+        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) {
+            this.clientKeys = srp.clientSeed();
+            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;
+            }
 
-Connection.prototype.getCachedQuery = function (query) {
-    return this._cache_query ? this._cache_query[query] : null;
-};
+            // Check for pending accept from op_cond_accept flow
+            if (self._pendingAccept) {
+                ret = self._pendingAccept;
+                delete self._pendingAccept;
+            }
 
-Connection.prototype._bind_events = function(host, port, callback) {
+            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(srp.hexPad(ret.sessionKey.toString(16)), '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;
+            }
 
-    var self = this;
+            if (callback)
+                callback(undefined, ret);
+        }
+    
+        this._queueEvent(cb);
+    }
 
-    self._socket.on('close', function() {
 
-        if (!self._isOpened || self._isDetach) {
+    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);
+        }
+    
+        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);
+        }
+    
+        // 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);
+    }
 
-        self._isOpened = false;
 
-        if (!self.db) {
+    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(self.error);
+                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);
+        }
+    
+        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;
+    
+            setImmediate(function() {
+                if (self.db)
+                    self.db.emit('attach', ret);
+            });
+    
+            if (callback)
+                callback(err, ret);
+        }
+    
+        cb.response = new Database(this);
+        this._queueEvent(cb);
+    }
+
 
-        self._retry_connection_id = setTimeout(function() {
-            self._socket.removeAllListeners();
-            self._socket = null;
+    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);
+            });
+        });
+    }
 
-            var ctx = new Connection(host, port, function(err) {
-                ctx.connect(self.options, function(err) {
 
-                    if (err) {
-                        self.db.emit('error', 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);
+            var wait = params.length;
+    
+            function done() {
+                wait--;
+                if (wait === 0)
+                    callback(ret);
+            }
+    
+            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);
+                        });
                         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);
+                                }
+                            });
+                            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);
+                            } 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);
+                        }
+                    });
+                });
+            }
+    
+            for (var i = 0, length = params.length; i < length; i++) {
+                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:
+                            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;
+                    }
+                    done();
+                } else {
+                    switch (meta.type) {
+                        case Const.SQL_BLOB:
+                            putBlobData(i, value, done);
+                            break;
+    
+                        case Const.SQL_TIMESTAMP:
+                        case Const.SQL_TYPE_DATE:
+                        case Const.SQL_TYPE_TIME:
+    
+                            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));
+    
+                            done();
+                            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;
+                            }
+                            done();
+                    }
+                }
+            }
+        }
+    
+        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);
+    }
 
-                    ctx.attach(self.options, function(err) {
 
-                        if (err) {
-                            self.db.emit('error', err);
+    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
+        }
+    
+        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 data = [];
+        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;
+                    }
+
+                    const custom = statement.custom || {};
+                    const asStream = custom.asStream && custom.on;
+
+                    doSynchronousLoop(ret.data, (row, i, next) => {
+                        const pos = data.push(row) - 1;
+                        if (asStream) {
+                            executeStreamRow(custom, row, pos, statement.output, next);
+                        } else {
+                            next();
+                        }
+                    }, (streamErr) => {
+                        if (streamErr) {
+                            callback(streamErr);
                             return;
                         }
 
-                        ctx._queue = ctx._queue.concat(self._queue);
-                        ctx._pending = ctx._pending.concat(self._pending);
-                        self.db.emit('reconnect');
+                        if (ret.fetched) {
+                            callback(undefined, data);
+                        } else {
+                            self.fetch(statement, transaction, Const.DEFAULT_FETCHSIZE, loop);
+                        }
+                    });
+                }).catch(callback);
+                return;
+            }
 
-                    }, self.db);
-                });
+            if (ret && ret.fetched) {
+                callback(undefined, data);
+            } else {
+                self.fetch(statement, transaction, Const.DEFAULT_FETCHSIZE, loop);
+            }
+        };
 
-                Object.assign(self, ctx);
+        this.fetch(statement, transaction, Const.DEFAULT_FETCHSIZE, loop);
+    }
 
-            }, self.options, self.db);
-        }, self._retry_connection_interval);
 
-    });
 
-    self._socket.on('error', function(e) {
+    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);
+    }
+
 
-        self.error = e;
+    closeBlob(blob, callback) {
+        var msg = this._msg;
+        msg.pos = 0;
+        msg.addInt(Const.op_close_blob);
+        msg.addInt(blob.handle);
+        this._queueEvent(callback, true);
+    }
 
-        if (self.db)
-            self.db.emit('error', e)
 
-        if (callback)
-            callback(e);
+    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);
+    }
 
-    });
 
-    self._socket.on('connect', function() {
-        self._isClosed = false;
-        self._isOpened = true;
-        if (callback)
-            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);
+    }
 
-    self._socket.on('data', function (data) {
-        var xdr;
 
-        if (!self._xdr) {
-            xdr = new XdrReader(data);
+    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 {
-            xdr = new XdrReader(Buffer.concat([self._xdr.buffer, data], self._xdr.buffer.length + data.length));
-            delete (self._xdr);
+            cb.response = new ServiceManager(this);
+            cb.response.removeAllListeners('error');
+            cb.response.on('error', noop);
         }
+    
+        this._queueEvent(cb);
+    }
 
-        while (xdr.pos < xdr.buffer.length) {
-            var cb = self._queue[0], pos = xdr.pos;
 
-            decodeResponse(xdr, cb, self, self._lowercase_keys, function (err, obj) {
+    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);
+    }
 
-                if (err) {
-                    xdr.buffer = xdr.buffer.slice(pos);
-                    xdr.pos = 0;
-                    self._xdr = xdr;
 
-                    if (self.accept.protocolMinimumType === Const.ptype_lazy_send && self._queue.length > 0) {
-                        self._queue[0].lazy_count = 2;
-                    }
-                    return;
-                }
+    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);
+    }
 
-                // remove the op flag, needed for partial packet
-                if (xdr.r) {
-                    delete (xdr.r);
-                }
 
-                self._queue.shift();
-                self._pending.shift();
+    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);
+        });
+    }
 
-                if (obj && obj.status) {
-                    obj.message = lookupMessages(obj.status);
-                    doCallback(obj, cb);
-                } else {
-                    doCallback(obj, cb);
-                }
 
-            });
 
-            if (xdr.pos === 0) {
-                break;
+    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);
+        function cb(err, ret) {
+    
+            if (err) {
+                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)
+            }
+    
+            callback(undefined, socket_info);
         }
+        this._queueEvent(cb);
+    }
 
-        if (!self._detachAuto || self._pending.length !== 0) {
-            return;
-        }
 
-        clearTimeout(self._detachTimeout);
-        self._detachTimeout = setTimeout(function () {
-            self.db.detach(self._detachCallback);
-            self._detachAuto = false;
-        }, 100);
+    queEvents(events, eventid, callback) {
+        var self = this;
+        console.log('[Connection] queEvents called, eventid:', eventid, 'events:', Object.keys(events), 'isClosed:', this._isClosed);
+        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);
+        
+        console.log('[Connection] queEvents: Message prepared, queuing event');
+        function cb(err, ret) {
+            console.log('[Connection] queEvents callback invoked, err:', err, 'ret:', ret);
+            if (err) {
+                doError(err, callback);
+                return;
+            }
+            
+            callback(null, ret);
+        }
+        
+        this._queueEvent(cb);
+        console.log('[Connection] queEvents: Event queued');
+    }
 
-    });
-}
 
-Connection.prototype.disconnect = function() {
-    this._socket.end();
-};
+    closeEvents(eventid, callback) {
+        var self = this;
+        console.log('[Connection] closeEvents called, eventid:', eventid, 'isClosed:', this._isClosed);
+        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) {
+            console.log('[Connection] closeEvents callback invoked, err:', err);
+            if (err) {
+                doError(err, callback);
+                return;
+            }
+    
+            callback(null);
+        }
+    
+        this._queueEvent(cb);
+        console.log('[Connection] closeEvents: Event queued');
+    }
 
+}
 
 function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
     try {
@@ -368,12 +1704,14 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                     protocolVersion: data.readInt(),
                     protocolArchitecture: data.readInt(),
                     protocolMinimumType: data.readInt(),
+                    compress: false,
                     pluginName: '',
                     authData: '',
                     sessionKey: ''
                 };
 
-                accept.protocolMinimumType = accept.protocolMinimumType & 0xFF;
+                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;
@@ -450,6 +1788,21 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                     }
                 }
 
+                if (accept.compress) {
+                    cnx._socket.enableCompression();
+                }
+
+                // For op_cond_accept: send op_cont_auth and wait for response
+                if (r === Const.op_cond_accept && accept.authData) {
+                    cnx._pendingAccept = accept;
+                    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());
@@ -459,595 +1812,127 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
 
                 if (!cnx.options.pluginName) {
                     if (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')};
-                    }
-                }
-
-                return data.accept;
-            default:
-                return cb(new Error('Unexpected:' + r));
-        }
-    } catch (err) {
-        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);
-                }
-        }
-    }
-}
-
-Connection.prototype.sendOpContAuth = function(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());
-}
-
-Connection.prototype._queueEvent = function(callback){
-    var self = this;
-
-    if (self._isClosed) {
-        if (callback)
-            callback(new Error('Connection is closed.'));
-        return;
-    }
-
-    self._queue.push(callback);
-    self._socket.write(self._msg.getData());
-};
-
-Connection.prototype.connect = function (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');
-
-    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) {
-        this.clientKeys = srp.clientSeed();
-        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, Const.WIRE_CRYPT_DISABLE, 0, 0, 0]); // WireCrypt = Disabled
-    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
-        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;
-        }
-
-        self.accept = ret;
-        if (callback)
-            callback(undefined, ret);
-    }
-
-    this._queueEvent(cb);
-};
-
-Connection.prototype.attach = function (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);
-    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);
-    }
-
-    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);
-    }
-
-    // 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);
-};
-
-Connection.prototype.detach = function (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);
-    });
-};
-
-Connection.prototype.createDatabase = function (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);
-    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);
-    }
-
-    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;
-
-        setImmediate(function() {
-            if (self.db)
-                self.db.emit('attach', ret);
-        });
-
-        if (callback)
-            callback(err, ret);
-    }
-
-    cb.response = new Database(this);
-    this._queueEvent(cb);
-};
-
-Connection.prototype.dropDatabase = function (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);
-        });
-    });
-};
-
-Connection.prototype.throwClosed = function(callback) {
-    var err = new Error('Connection is closed.');
-    this.db.emit('error', err);
-    if (callback)
-        callback(err);
-    return this;
-};
-
-Connection.prototype.startTransaction = function(isolation, callback) {
-
-    if (typeof(isolation) === 'function') {
-        var tmp = isolation;
-        isolation = callback;
-        callback = tmp;
-    }
-
-    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.addBytes(isolation || Const.ISOLATION_REPEATABLE_READ);
-    msg.addInt(Const.op_transaction);
-    msg.addInt(this.dbhandle);
-    msg.addBlr(blr);
-    callback.response = new Transaction(this);
-
-    this.db.emit('transaction', isolation);
-    this._queueEvent(callback);
-};
-
-Connection.prototype.commit = function (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);
-};
-
-Connection.prototype.rollback = function (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);
-};
-
-Connection.prototype.commitRetaining = function (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);
-};
-
-Connection.prototype.rollbackRetaining = function (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);
-};
-
-Connection.prototype.allocateStatement = function (callback) {
-
-    if (this._isClosed)
-        return this.throwClosed(callback);
-
-    // for auto detach
-    this._pending.push('allocateStatement');
+                        // Erreur plugin not able to connect
+                        return cb(new Error("Unable to connect with plugin " + cnx.accept.pluginName));
+                    }
 
-    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);
-};
+                    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);
 
-Connection.prototype.dropStatement = function (statement, callback) {
+                        cnx.sendOpContAuth(
+                            cnx.accept.authData,
+                            Const.DEFAULT_ENCODING,
+                            pluginName
+                        );
 
-    if (this._isClosed)
-        return this.throwClosed(callback);
+                        return {error: new Error('login')};
+                    }
+                }
 
-    // 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);
-};
-
-Connection.prototype.closeStatement = function (statement, callback) {
+                return data.accept;
+            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;
+            default:
+                return cb(new Error('Unexpected:' + r));
+        }
+    } catch (err) {
+        if (err instanceof RangeError) {
+            return cb(err);
+        }
+        throw err;
+    }
+}
 
-    if (this._isClosed)
-        return this.throwClosed(callback);
+function parseOpResponse(data, response, cb) {
+    var handle = data.readInt();
 
-    // 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);
-};
-
-Connection.prototype.allocateAndPrepareStatement = function (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 (!response.handle) {
+        response.handle = handle;
+    }
 
-        if (callback)
-            callback(err, ret);
-    };
+    var oid = data.readQuad();
+    if (oid.low || oid.high) {
+        response.oid = oid;
+    }
 
-    // for auto detach
-    this._pending.push('allocateAndPrepareStatement');
+    var buf = data.readArray();
+    if (buf) {
+        response.buffer = buf;
+    }
 
-    var msg = this._msg;
-    var blr = this._blr;
+    var num, op, item = {};
+    while (true) {
+        op = data.readInt();
 
-    msg.pos = 0;
-    blr.pos = 0;
+        switch (op) {
+            case Const.isc_arg_end:
+                return cb ? cb(undefined, response) : response;
+            case Const.isc_arg_gds:
+                num = data.readInt();
+                if (!num) {
+                    break;
+                }
 
-    msg.addInt(Const.op_allocate_statement);
-    msg.addInt(this.dbhandle);
-    mainCallback.lazy_count = 1;
+                item = {gdscode: num};
 
-    blr.addBytes(Const.DESCRIBE);
-    if (plan)
-        blr.addByte(Const.isc_info_sql_get_plan);
+                if (response.status) {
+                    response.status.push(item);
+                } else {
+                    response.status = [item];
+                }
 
-    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;
+                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)];
+                }
 
-    mainCallback.response = new Statement(this);
-    this._queueEvent(mainCallback);
-};
+                break;
+            case Const.isc_arg_number:
+                num = data.readInt();
 
-Connection.prototype.prepare = function (transaction, query, plan, callback) {
-    var self = this;
+                if (item.params) {
+                    item.params.push(num);
+                } else {
+                    item.params = [num];
+                }
 
-    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;
-            }
+                if (item.gdscode === Const.isc_sqlerr) {
+                    response.sqlcode = num;
+                }
 
-            self.prepareStatement(transaction, statement, query, plan, callback);
-        });
+                break;
+            default:
+                if (cb) {
+                    cb(new Error('Unexpected: ' + op))
+                } else {
+                    throw new Error('Unexpected: ' + op);
+                }
+        }
     }
-};
+}
 
 function describe(buff, statement) {
     var br = new BlrReader(buff);
@@ -1149,52 +2034,6 @@ function describe(buff, statement) {
     }
 }
 
-Connection.prototype.prepareStatement = function (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);
-    });
-
-};
-
 function CalcBlr(blr, xsqlda) {
     blr.addBytes([Const.blr_version5, Const.blr_begin, Const.blr_message, 0]); // + message number
     blr.addWord(xsqlda.length * 2);
@@ -1209,280 +2048,6 @@ function CalcBlr(blr, xsqlda) {
     blr.addByte(Const.blr_eoc);
 }
 
-Connection.prototype.executeStatement = function(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);
-        var wait = params.length;
-
-        function done() {
-            wait--;
-            if (wait === 0)
-                callback(ret);
-        }
-
-        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);
-
-                if (Buffer.isBuffer(b)) {
-                    bufferReader(b, 1024, function(b, next) {
-                        self.batchSegments(blob, b, next);
-                    }, function() {
-                        ret[index] = new Xsql.SQLParamQuad(blob.oid);
-                        self.closeBlob(blob, callback);
-                    });
-                    return;
-                }
-
-                var isReading = false;
-                var isEnd = false;
-
-                value.on('data', function(chunk) {
-                    value.pause();
-                    isReading = true;
-                    bufferReader(chunk, 1024, function(b, next) {
-                        self.batchSegments(blob, b, next);
-                    }, function() {
-                        isReading = false;
-
-                        if (isEnd) {
-                            ret[index] = new Xsql.SQLParamQuad(blob.oid);
-                            self.closeBlob(blob, callback);
-                        } else
-                            value.resume();
-                    });
-                });
-
-                value.on('end', function() {
-                    isEnd = true;
-                    if (isReading)
-                        return;
-                    ret[index] = new Xsql.SQLParamQuad(blob.oid);
-                    self.closeBlob(blob, callback);
-                });
-            });
-        }
-
-        for (var i = 0, length = params.length; i < length; i++) {
-            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:
-                        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;
-                }
-                done();
-            } else {
-                switch (meta.type) {
-                    case Const.SQL_BLOB:
-                        putBlobData(i, value, done);
-                        break;
-
-                    case Const.SQL_TIMESTAMP:
-                    case Const.SQL_TYPE_DATE:
-                    case Const.SQL_TYPE_TIME:
-
-                        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));
-
-                        done();
-                        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;
-                        }
-                        done();
-                }
-            }
-        }
-    }
-
-    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);
-};
-
-Connection.prototype.sendExecute = function (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
-    }
-
-    callback.statement = statement;
-    this._queueEvent(callback);
-}
-
 function fetch_blob_async_transaction(statement, id, column, row) {
     const infoValue = { row, column, value: '' };
 
@@ -1639,228 +2204,55 @@ function fetch_blob_async(statement, id, name, row) {
     };
 }
 
-Connection.prototype.fetch = function(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);
-};
-
-Connection.prototype.fetchAll = function (statement, transaction, callback) {
-    const self = this, data = [];
-    const loop = (err, ret) => {
-        if (err) {
-            return callback(err);
-        } else 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;
-                }
-
-                const lastIndex = ret.data.length - 1;
-                for (let i = 0; i < ret.data.length; i++) {
-                    const pos = data.push(ret.data[i]);
-                    if (statement.custom && statement.custom.asStream && statement.custom.on) {
-                        statement.custom.on(ret.data[i], pos - 1);
-                    }
-                    if (i === lastIndex) {
-                        if (ret.fetched) {
-                            return callback(undefined, data);
-                        } else {
-                            self.fetch(statement, transaction, Const.DEFAULT_FETCHSIZE, loop);
-                        }
-                    }
-                }
-            }).catch(callback);
-        } else if (ret.fetched) {
-            callback(undefined, data);
-        } else {
-            self.fetch(statement, transaction, Const.DEFAULT_FETCHSIZE, loop);
-        }
+function doSynchronousLoop(data, processData, done) {
+    if (!data || !data.length) {
+        done();
+        return;
     }
 
-    this.fetch(statement, transaction, Const.DEFAULT_FETCHSIZE, loop);
-};
-
-
-Connection.prototype.openBlob = function(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);
-};
-
-Connection.prototype.closeBlob = function(blob, callback) {
-    var msg = this._msg;
-    msg.pos = 0;
-    msg.addInt(Const.op_close_blob);
-    msg.addInt(blob.handle);
-    this._queueEvent(callback);
-};
-
-Connection.prototype.getSegment = function(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);
-};
-
-Connection.prototype.createBlob2 = function (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);
-};
-
-Connection.prototype.batchSegments = function(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);
-};
-
-Connection.prototype.svcattach = function (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);
-    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);
-    }
+    const loop = (index) => {
+        processData(data[index], index, (err) => {
+            if (err) {
+                done(err);
+                return;
+            }
 
-    // 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);
-    }
+            const nextIndex = index + 1;
+            if (nextIndex < data.length) {
+                loop(nextIndex);
+            } else {
+                done();
+            }
+        });
+    };
 
-    this._queueEvent(cb);
+    loop(0);
 }
 
-Connection.prototype.svcstart = function (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);
-}
+function executeStreamRow(custom, row, index, output, next) {
+    let done = false;
+    const finish = (err) => {
+        if (done) {
+            return;
+        }
+        done = true;
+        next(err);
+    };
 
-Connection.prototype.svcquery = function (spbquery, resultbuffersize, timeout,callback) {
-    if (resultbuffersize > Const.MAX_BUFFER_SIZE) {
-        doError(new Error('Buffer is too big'), callback);
-        return;
+    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);
     }
-
-    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);
-}
-
-Connection.prototype.svcdetach = function (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);
-    });
 }
 
 function bufferReader(buffer, max, writer, cb, beg, end) {
@@ -1887,79 +2279,31 @@ function bufferReader(buffer, max, writer, cb, beg, end) {
     });
 }
 
-Connection.prototype.auxConnection = function (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);
-    function cb(err, ret) {
-
-        if (err) {
-            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)
-        }
-
-        callback(undefined, socket_info);
-    }
-    this._queueEvent(cb);
-}
-
-Connection.prototype.queEvents = function (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 = new Buffer(event, 'UTF8');
-        blr.addByte(event_buffer.length);
-        blr.addBytes(event_buffer);
-        blr.addInt32(events[event]);
+/**
+ * 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);
     }
-    msg.addBlr(blr);    // epb    
-    msg.addInt(0);    // ast
-    msg.addInt(0);   // args
-    msg.addInt(eventid);
-    this._queueEvent(callback);
-}
 
-Connection.prototype.closeEvents = function (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;
+    // 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);
         }
-
-        callback(err);
     }
 
-    this._queueEvent(cb);
+    // Plain string - encode as UTF-8
+    return Buffer.from(config, 'utf8');
 }
 
 module.exports = Connection;