node-firebird 2.0.2 → 2.3.0

package/lib/wire/const.js

@@ -186,6 +186,14 @@ const protocol = {
 
     // Protocol 15 has support for conditional accept with early wire encryption.
     PROTOCOL_VERSION15  : (FB_PROTOCOL_FLAG | 15),
+
+    // Protocol 16 has support for statement timeouts, DECFLOAT data types,
+    // and extended metadata identifiers (up to 63 characters).
+    // Introduced in Firebird 4.0.
+    PROTOCOL_VERSION16  : (FB_PROTOCOL_FLAG | 16),
+
+    // Protocol 17 continues Firebird 4.0 enhancements.
+    PROTOCOL_VERSION17  : (FB_PROTOCOL_FLAG | 17),
 };
 
 // Protocols types (accept_type)
@@ -205,6 +213,8 @@ const SUPPORTED_PROTOCOL = [
     [protocol.PROTOCOL_VERSION13, connect.ARCHITECTURE_GENERIC, acceptType.ptype_lazy_send, acceptType.ptype_lazy_send, 4],
     [protocol.PROTOCOL_VERSION14, connect.ARCHITECTURE_GENERIC, acceptType.ptype_lazy_send, acceptType.ptype_lazy_send, 5],
     [protocol.PROTOCOL_VERSION15, connect.ARCHITECTURE_GENERIC, acceptType.ptype_lazy_send, acceptType.ptype_lazy_send, 6],
+    [protocol.PROTOCOL_VERSION16, connect.ARCHITECTURE_GENERIC, acceptType.ptype_lazy_send, acceptType.ptype_lazy_send, 7],
+    [protocol.PROTOCOL_VERSION17, connect.ARCHITECTURE_GENERIC, acceptType.ptype_lazy_send, acceptType.ptype_lazy_send, 8],
 ];
 
 const authPlugin = {
@@ -240,8 +250,18 @@ const sqlType = {
     SQL_TYPE_DATE : 570,
     SQL_INT64 : 580,
     SQL_INT128: 32752, // >= 4.0
+    SQL_TIMESTAMP_TZ : 32754, // >= 4.0 - timestamp with time zone
+    SQL_TIMESTAMP_TZ_EX : 32748, // >= 4.0 - extended timestamp with time zone
+    SQL_TIME_TZ : 32756, // >= 4.0 - time with time zone
+    SQL_TIME_TZ_EX : 32750, // >= 4.0 - extended time with time zone
+    SQL_DEC16 : 32760, // >= 4.0 - DECFLOAT(16) - 8 bytes, IEEE 754 Decimal64
+    SQL_DEC34 : 32762, // >= 4.0 - DECFLOAT(34) - 16 bytes, IEEE 754 Decimal128
     SQL_BOOLEAN : 32764, // >: 3.0
     SQL_NULL : 32766, // >= 2.5
+    SQL_TIMESTAMP_TZ_EX : 32748,
+    SQL_TIME_TZ_EX : 32750,
+    SQL_TIMESTAMP_TZ : 32754,
+    SQL_TIME_TZ : 32756,
 };
 
 const blobType = {
@@ -271,6 +291,10 @@ const blr = {
     blr_sql_time : 13,
     blr_int64 : 16,
     blr_int128 : 26, // >: 4.0
+    blr_dec64 : 24, // >= 4.0 - DECFLOAT(16), IEEE 754 Decimal64
+    blr_dec128 : 25, // >= 4.0 - DECFLOAT(34), IEEE 754 Decimal128
+    blr_timestamp_tz : 28, // >= 4.0 - timestamp with time zone
+    blr_time_tz : 29, // >= 4.0 - time with time zone
     blr_blob2 : 17, // >: 2.0
     blr_domain_name : 18, // >: 2.1
     blr_domain_name2 : 19, // >: 2.1
@@ -279,6 +303,11 @@ const blr = {
     blr_column_name2 : 22, // >: 2.5
     blr_bool : 23, // >: 3.0
 
+    blr_sql_time_tz : 28, // >: 4.0
+    blr_timestamp_tz : 29, // >: 4.0
+    blr_ex_time_tz : 30, // >: 4.0
+    blr_ex_timestamp_tz : 31, // >: 4.0
+
     blr_version4 : 4,
     blr_version5 : 5, // dialect 3
     blr_eoc : 76,

package/lib/wire/database.js

@@ -9,6 +9,35 @@ const FbEventManager = require('./fbEventManager');
  *
  *   Database
  *
+ * Driver events (emitted on the Database instance itself)
+ * --------------------------------------------------------
+ * These are synchronous notifications from the driver about connection-level
+ * operations. Subscribe with db.on(eventName, handler).
+ *
+ *   'attach'      – fired synchronously after the user callback returns,
+ *                   once the database is attached.
+ *   'detach'      – fired when the database connection is detached.
+ *   'reconnect'   – fired after the driver successfully reconnects a dropped socket.
+ *   'error'       – fired for connection-level errors (socket errors, closed
+ *                   connection attempts, etc.).
+ *   'transaction' – fired when a transaction is started (before server response),
+ *                   with the resolved transaction options object as the argument.
+ *   'commit'      – fired when a transaction commit is sent (before server response).
+ *   'rollback'    – fired when a transaction rollback is sent (before server response).
+ *   'query'       – fired with the SQL string when a statement is prepared.
+ *   'row'         – fired with each individual row as it is decoded.
+ *   'result'      – fired with the full rows array once all rows are fetched.
+ *
+ * Firebird database events (POST_EVENT)
+ * ----------------------------------------
+ * Real Firebird asynchronous notifications triggered by POST_EVENT inside
+ * PSQL triggers or stored procedures are handled through a separate channel:
+ *   1. Call db.attachEvent(callback) to obtain a FbEventManager instance.
+ *   2. Call evtmgr.registerEvent(names, callback) to subscribe to event names.
+ *   3. Listen for evtmgr.on('post_event', (name, count) => {}) to receive them.
+ *   4. Call evtmgr.unregisterEvent(names, callback) to cancel a subscription.
+ *   5. Call evtmgr.close(callback) when done to release the aux connection.
+ *
  ***************************************/
 
 function readblob(blob, callback) {
@@ -161,9 +190,9 @@ class Database extends Events.EventEmitter {
         return this;
     }
 
-    execute(query, params, callback, custom) {
+    execute(query, params, callback, options) {
         if (params instanceof Function) {
-            custom = callback;
+            options = callback;
             callback = params;
             params = undefined;
         }
@@ -191,15 +220,15 @@ class Database extends Events.EventEmitter {
                         callback(err, result, meta, isSelect);
                 });
 
-            }, custom);
+            }, options);
         });
 
         return self;
     }
 
-    sequentially(query, params, on, callback, asArray) {
+    sequentially(query, params, on, callback, options = {}) {
         if (params instanceof Function) {
-            asArray = callback;
+            options = callback;
             callback = on;
             on = params;
             params = undefined;
@@ -210,7 +239,7 @@ class Database extends Events.EventEmitter {
         }
 
         if (callback instanceof Boolean) {
-            asArray = callback;
+            options = callback;
             callback = undefined;
         }
 
@@ -252,18 +281,37 @@ class Database extends Events.EventEmitter {
             });
         };
 
-        self.execute(query, params, callback, { asObject: !asArray, asStream: true, on: _on });
+        // back compatibility - options parameter is a boolean
+        if (typeof options === 'boolean') {
+            options = { asObject: !options, asStream: true, on: _on };
+        } else {
+            options = {
+                asObject: true,
+                asStream: true,
+                on: _on,
+                ...options,
+            };
+        }
+
+        self.execute(query, params, callback, options);
         return self;
     }
 
-    query(query, params, callback) {
+    query(query, params, callback, options = {}) {
         if (params instanceof Function) {
+            options = callback || {};
             callback = params;
             params = undefined;
         }
 
+        options = {
+            asObject: true,
+            asStream: callback === undefined || callback === null,
+            ...options
+        };
+
         var self = this;
-        self.execute(query, params, callback, { asObject: true, asStream: callback === undefined || callback === null });
+        self.execute(query, params, callback, options);
         return self;
     }
 
@@ -273,13 +321,23 @@ class Database extends Events.EventEmitter {
 
     attachEvent(callback) {
         var self = this;
+        if (process.env.FIREBIRD_DEBUG) {
+            console.log('[fb-debug] Database.attachEvent: calling auxConnection, eventid=%d queue=%d', self.eventid, self.connection._queue.length);
+        }
         this.connection.auxConnection(function (err, socket_info) {
 
             if (err) {
+                if (process.env.FIREBIRD_DEBUG) {
+                    console.log('[fb-debug] Database.attachEvent: auxConnection error:', err.message);
+                }
                 doError(err, callback);
                 return;
             }
 
+            if (process.env.FIREBIRD_DEBUG) {
+                console.log('[fb-debug] Database.attachEvent: auxConnection ok, connecting to aux port %s:%d', socket_info.host, socket_info.port);
+            }
+
             const host = (socket_info.host === '0.0.0.0' || socket_info.host === '::')
                 ? self.connection.options.host
                 : socket_info.host;
@@ -287,16 +345,27 @@ class Database extends Events.EventEmitter {
             const eventConnection = new EventConnection(
                 host, socket_info.port, function(err) {
                 if (err) {
+                    if (process.env.FIREBIRD_DEBUG) {
+                        console.log('[fb-debug] Database.attachEvent: EventConnection error:', err.message);
+                    }
                     doError(err, callback);
                     return;
                 }
 
+                if (process.env.FIREBIRD_DEBUG) {
+                    console.log('[fb-debug] Database.attachEvent: EventConnection connected, creating FbEventManager eventid=%d', self.eventid);
+                }
+
                 const evt = new FbEventManager(self, eventConnection, self.eventid++, function (err) {
                     if (err) {
                         doError(err, callback);
                         return;
                     }
 
+                    if (process.env.FIREBIRD_DEBUG) {
+                        console.log('[fb-debug] Database.attachEvent: FbEventManager ready, eventid=%d', evt.eventid);
+                    }
+
                     callback(err, evt);
                 });
             }, self);

package/lib/wire/eventConnection.js

@@ -87,10 +87,11 @@ class EventConnection {
                                 self.emgr.events[evt] = tmp_event[evt];
                             }
                             if (self.eventcallback)
-                                return self.eventcallback(null, { eventid: event_id, events: lst_event });
-
+                                self.eventcallback(null, { eventid: event_id, events: lst_event });
+                            break;
                         default:
-                            return cb(new Error('Unexpected:' + r));
+                            // Unknown opcode on the event connection – stop processing.
+                            return;
                     }
                 }
             } catch (err) {
@@ -98,6 +99,8 @@ class EventConnection {
                     xdr.buffer = xdr.buffer = xdr.buffer.slice(op_pos);
                     xdr.pos = 0;
                     self._xdr = xdr;
+                } else {
+                    throw err;
                 }
             }
         })

package/lib/wire/fbEventManager.js

@@ -1,3 +1,69 @@
+// FbEventManager – Firebird POST_EVENT subscription manager
+//
+// State machine overview
+// ──────────────────────
+//
+//  ┌──────────────────────────────────────────────────────────────────────┐
+//  │                      FbEventManager states                           │
+//  └──────────────────────────────────────────────────────────────────────┘
+//
+//   attachEvent()
+//       │
+//       ▼
+//   ┌─────────────────────────────────────────────────────────┐
+//   │ IDLE                                                    │
+//   │  _hasActiveSubscription = false                         │
+//   │  events = {}                                            │
+//   │  eventcallback = loop fn (set but subscription absent)  │
+//   └──────────────┬────────────────────────────┬────────────┘
+//                  │ registerEvent([...])        │ close()
+//                  ▼                             ▼
+//   ┌──────────────────────────┐    ┌───────────────────────┐
+//   │ SUBSCRIBING              │    │ CLOSING               │
+//   │  queEvents() sent        │    │  endAndWaitForClose()  │
+//   │  waiting for op_response │    │  sock.end() + wait     │
+//   └──────────┬───────────────┘    └───────────┬───────────┘
+//              │ op_response ok                  │ 'close' event
+//              ▼                                 ▼
+//   ┌──────────────────────────┐    ┌───────────────────────┐
+//   │ SUBSCRIBED               │    │ CLOSED / DONE         │
+//   │  _hasActiveSubscription  │    │  eventconnection gone  │
+//   │  = true                  │    └───────────────────────┘
+//   │  eventcallback active    │
+//   └───┬───────────┬──────────┘
+//       │           │
+//       │ op_event  │ unregisterEvent() (all removed) or close()
+//       │ received  │
+//       │           ▼
+//       │  ┌──────────────────────────────────────────────────┐
+//       │  │ CANCELLING                                       │
+//       │  │  closeEvents() sent (op_cancel_events)           │
+//       │  │  waiting for op_response                         │
+//       │  └──────────┬───────────────────────────────────────┘
+//       │             │ op_response ok
+//       │             ▼
+//       │  ┌──────────────────────────────────────────────────┐
+//       │  │ IDLE  (or CLOSING if called from close())        │
+//       │  └──────────────────────────────────────────────────┘
+//       │
+//       │ emit('post_event', name, count)
+//       └──────────────────────┐
+//                              ▼
+//                  loop() → SUBSCRIBING (re-subscribe)
+//
+// Wire-protocol messages on the MAIN connection
+// ──────────────────────────────────────────────
+//   Client → Server : op_connect_request   (attachEvent / auxConnection)
+//   Server → Client : op_response          (socket address of AUX port)
+//   Client → Server : op_que_events        (registerEvent / loop)
+//   Server → Client : op_response          (confirms event ID)
+//   Client → Server : op_cancel_events     (unregisterEvent / close)
+//   Server → Client : op_response
+//
+// Asynchronous notifications on the AUX (EventConnection) socket
+// ───────────────────────────────────────────────────────────────
+//   Server → Client : op_event  (fired by Firebird POST_EVENT trigger)
+
 const Events = require('events');
 const { doError } = require('../callback');
 
@@ -8,95 +74,172 @@ class FbEventManager extends Events.EventEmitter {
         this.eventconnection = eventconnection;
         this.events = {};
         this.eventid = eventid;
+        // True when an op_que_events subscription is currently active on the
+        // main connection (so close() and _changeEvent know whether to send
+        // op_cancel_events before tearing down or re-subscribing).
+        this._hasActiveSubscription = false;
         this._createEventLoop(callback);
     }
 
+    /**
+     * Returns a snapshot of the current state for debugging.
+     * Useful for tracing the state machine during development.
+     *
+     * Stable states: 'IDLE', 'SUBSCRIBED', 'CLOSED'.
+     * Transient states (SUBSCRIBING, CANCELLING, CLOSING) occur while waiting
+     * for op_response on the main connection or for the socket to close; they
+     * are not tracked with dedicated flags to keep the implementation simple,
+     * but they can be inferred: if the socket is open and _hasActiveSubscription
+     * disagrees with what the caller expects, a transitional operation is in
+     * progress.
+     *
+     * @returns {{
+     *   state: string,
+     *   hasActiveSubscription: boolean,
+     *   registeredEvents: Object,
+     *   eventId: number,
+     *   isEventConnectionOpen: boolean,
+     *   isDatabaseConnectionClosed: boolean
+     * }}
+     */
+    getState() {
+        const evtConnOpen = this.eventconnection
+            ? !this.eventconnection._isClosed
+            : false;
+        const dbConnClosed = this.db.connection
+            ? this.db.connection._isClosed
+            : true;
+
+        // Derive a human-readable stable-state label.
+        // Transitional states (SUBSCRIBING / CANCELLING / CLOSING) are not
+        // individually flagged; callers that need finer granularity can
+        // inspect hasActiveSubscription and isEventConnectionOpen together.
+        let state;
+        if (dbConnClosed || !evtConnOpen) {
+            state = 'CLOSED';
+        } else if (this._hasActiveSubscription) {
+            state = 'SUBSCRIBED';
+        } else {
+            state = 'IDLE';
+        }
+
+        return {
+            state,
+            hasActiveSubscription: this._hasActiveSubscription,
+            registeredEvents: Object.assign({}, this.events),
+            eventId: this.eventid,
+            isEventConnectionOpen: evtConnOpen,
+            isDatabaseConnectionClosed: dbConnClosed,
+        };
+    }
+
     _createEventLoop(callback) {
         var self = this;
         var cnx = this.db.connection;
         this.eventconnection.emgr = this;
-        console.log('[EventManager] Creating event loop, eventid:', this.eventid);
-        // create the loop
-        function loop(first) {
-            console.log('[EventManager] Calling queEvents, first:', first, 'events:', Object.keys(self.events));
-            cnx.queEvents(self.events, self.eventid, function (err, ret) {
-                console.log('[EventManager] queEvents callback, err:', err, 'ret:', ret, 'first:', first);
+
+        if (process.env.FIREBIRD_DEBUG) {
+            console.log('[fb-debug] FbEventManager._createEventLoop: eventid=%d', self.eventid);
+        }
+
+        // Re-subscribe after each op_event notification so that further
+        // trigger fires continue to be delivered.
+        function loop() {
+            // Guard: do not send queEvents if the subscription has been
+            // cancelled (e.g. via unregisterEvent removing all events) or if
+            // there are no registered events.  Without this check, a late
+            // op_event arriving on the event connection after closeEvents can
+            // trigger queEvents({}) which Firebird never acknowledges,
+            // permanently blocking the main connection queue.
+            if (!self._hasActiveSubscription || Object.keys(self.events).length === 0) {
+                return;
+            }
+            cnx.queEvents(self.events, self.eventid, function (err) {
                 if (err) {
-                    console.log('[EventManager] queEvents error:', err);
                     doError(err, callback);
                     return;
                 }
-                if (first) {
-                    console.log('[EventManager] First loop complete, calling callback');
-                    callback(null);
-                }
-            })
+                // subscription renewed, nothing else to do
+            });
         }
 
         this.eventconnection.eventcallback = function (err, ret) {
-            console.log('[EventManager] eventcallback invoked, err:', err, 'eventid match:', self.eventid === ret?.eventid);
             if (err || (self.eventid !== ret.eventid)) {
                 doError(err || new Error('Bad eventid'), callback);
                 return;
             }
 
             ret.events.forEach(function (event) {
-                self.emit('post_event', event.name, event.count)
-            })
+                self.emit('post_event', event.name, event.count);
+            });
 
-            loop(false);
-        }
+            loop();
+        };
 
-        loop(true);
+        // Resolve attachEvent on the next tick – no subscription is needed
+        // until the caller registers at least one event name via registerEvent().
+        // process.nextTick ensures the outer `const evt = new FbEventManager(...)`
+        // assignment in database.js completes before this callback fires.
+        process.nextTick(function() { callback(null); });
     }
 
     _changeEvent(callback) {
         var self = this;
 
-        console.log('[EventManager] _changeEvent called, eventid:', this.eventid, 'events:', Object.keys(self.events));
         // Temporarily suppress the event loop to prevent stale op_event
         // notifications from pushing spurious queEvents onto the main
-        // connection queue while closeEvents + queEvents are in flight
+        // connection queue while we're reconfiguring the subscription.
         var savedCallback = self.eventconnection.eventcallback;
         self.eventconnection.eventcallback = null;
-        console.log('[EventManager] Suppressed event callback, calling closeEvents');
 
-        self.db.connection.closeEvents(this.eventid, function (err) {
-            console.log('[EventManager] closeEvents callback, err:', err);
-            if (err) {
+        function subscribe() {
+            // If no events remain, mark subscription as inactive and return.
+            // Sending queEvents with an empty EPB after op_cancel_events does
+            // not receive op_response from some Firebird versions, which would
+            // permanently block the main connection queue.
+            if (Object.keys(self.events).length === 0) {
+                self._hasActiveSubscription = false;
                 self.eventconnection.eventcallback = savedCallback;
-                doError(err, callback);
+                callback(null);
                 return;
             }
-            
-            console.log('[EventManager] closeEvents success, calling queEvents');
+
             self.db.connection.queEvents(self.events, self.eventid, function (err, ret) {
-                console.log('[EventManager] queEvents callback in _changeEvent, err:', err, 'ret:', ret);
-                // Restore the event loop now that our queEvents is safely queued
                 self.eventconnection.eventcallback = savedCallback;
-                console.log('[EventManager] Restored event callback');
                 if (err) {
-                    console.log('[EventManager] queEvents error in _changeEvent:', err);
                     doError(err, callback);
                     return;
                 }
-                console.log('[EventManager] _changeEvent complete, calling final callback');
+                self._hasActiveSubscription = true;
                 callback(null, ret);
             });
-        })
+        }
+
+        if (self._hasActiveSubscription) {
+            // Cancel the current subscription before setting up a new one.
+            self.db.connection.closeEvents(this.eventid, function (err) {
+                if (err) {
+                    self.eventconnection.eventcallback = savedCallback;
+                    doError(err, callback);
+                    return;
+                }
+                self._hasActiveSubscription = false;
+                subscribe();
+            });
+        } else {
+            // No active subscription yet (first registerEvent call, or after
+            // all events were unregistered) – go straight to subscribing.
+            subscribe();
+        }
     }
 
     registerEvent(events, callback) {
         var self = this;
 
-        console.log('[EventManager] registerEvent called with events:', events);
-        console.log('[EventManager] Connection closed?', self.db.connection._isClosed, 'Event connection closed?', self.eventconnection._isClosed);
-        
         if (self.db.connection._isClosed || self.eventconnection._isClosed)
             return self.eventconnection.throwClosed(callback);
 
         events.forEach((event) => self.events[event] = self.events[event] || 0);
-        console.log('[EventManager] Events registered, current events:', Object.keys(self.events));
         self._changeEvent(callback);
     }
 
@@ -113,21 +256,71 @@ class FbEventManager extends Events.EventEmitter {
     close(callback) {
         var self = this;
 
+        if (process.env.FIREBIRD_DEBUG) {
+            console.log('[fb-debug] FbEventManager.close() called, _hasActiveSubscription=%s eventid=%d', self._hasActiveSubscription, self.eventid);
+        }
+
         // Prevent the event loop from re-queuing on stale op_event notifications
         // that may arrive between closeEvents and socket.end()
         self.eventconnection.eventcallback = null;
 
+        // Gracefully close the event socket using a FIN (end()) rather than a RST
+        // (destroy()), then wait for the 'close' event which confirms both sides have
+        // exchanged FINs.  This gives Firebird (all versions 3/4/5) time to fully
+        // process the previous event connection's teardown before the next
+        // op_connect_request or op_que_events arrives on the main connection.
+        // destroy() (RST) is faster but causes Firebird 3 to get confused on subsequent
+        // queEvents calls – the server internally fails on the RST error and does not
+        // clean up its event state in time for the next subscription request.
+        // A 200 ms safety timer fires as a fallback if Firebird never sends its FIN.
+        function endAndWaitForClose(cb) {
+            var sock = self.eventconnection && self.eventconnection._socket;
+            if (!sock || sock.destroyed) {
+                if (process.env.FIREBIRD_DEBUG) {
+                    console.log('[fb-debug] endAndWaitForClose: socket already destroyed, calling back immediately');
+                }
+                if (cb) cb();
+                return;
+            }
+            var fired = false;
+            var timer;
+            function done(source) {
+                if (!fired) {
+                    fired = true;
+                    clearTimeout(timer);
+                    if (process.env.FIREBIRD_DEBUG) {
+                        console.log('[fb-debug] endAndWaitForClose done() via %s, eventid=%d', source, self.eventid);
+                    }
+                    if (cb) cb();
+                }
+            }
+            sock.once('close', function() { done('close-event'); });
+            if (process.env.FIREBIRD_DEBUG) {
+                console.log('[fb-debug] endAndWaitForClose: calling sock.end(), eventid=%d sock.destroyed=%s', self.eventid, sock.destroyed);
+            }
+            sock.end();
+            // Safety fallback: if Firebird never sends its FIN (e.g. an error
+            // occurs on the server side), resolve after 200 ms so tests don't hang.
+            timer = setTimeout(function() { done('200ms-timer'); }, 200);
+        }
+
+        if (!self._hasActiveSubscription) {
+            // No active subscription (attachEvent without registerEvent, or
+            // all events were unregistered) – nothing to cancel.
+            endAndWaitForClose(callback);
+            return;
+        }
+
         self.db.connection.closeEvents(this.eventid, function (err) {
             if (err) {
                 doError(err, callback);
                 return;
             }
 
-            self.eventconnection._socket.end();
-            if (callback)
-                callback();
+            self._hasActiveSubscription = false;
+            endAndWaitForClose(callback);
         });
     }
 }
 
-module.exports = FbEventManager;
+module.exports = FbEventManager;

package/lib/wire/serialize.js

@@ -1,4 +1,5 @@
 var Long = require('long');
+const { encodeDecimal64, decodeDecimal64, encodeDecimal128, decodeDecimal128 } = require('../ieee754-decimal');
 
 function align(n) {
     return (n + 3) & ~3;
@@ -297,6 +298,26 @@ class XdrWriter {
         this.pos += 8;
     }
 
+    addDecFloat16(value) {
+        // DECFLOAT(16) - IEEE 754 Decimal64 - 8 bytes
+        // Full IEEE 754-2008 Decimal64 implementation
+        this.ensure(8);
+        
+        const encoded = encodeDecimal64(value);
+        encoded.copy(this.buffer, this.pos, 0, 8);
+        this.pos += 8;
+    }
+
+    addDecFloat34(value) {
+        // DECFLOAT(34) - IEEE 754 Decimal128 - 16 bytes
+        // Full IEEE 754-2008 Decimal128 implementation
+        this.ensure(16);
+        
+        const encoded = encodeDecimal128(value);
+        encoded.copy(this.buffer, this.pos, 0, 16);
+        this.pos += 16;
+    }
+
     addUInt(value) {
         this.ensure(4);
         this.buffer.writeUInt32BE(value, this.pos);
@@ -406,6 +427,24 @@ class XdrReader {
         return (BigInt(high) << BigInt(64)) + BigInt(low)
     }
 
+    readDecFloat16() {
+        // DECFLOAT(16) - IEEE 754 Decimal64 - 8 bytes
+        // Full IEEE 754-2008 Decimal64 implementation
+        const buf = this.buffer.slice(this.pos, this.pos + 8);
+        this.pos += 8;
+        
+        return decodeDecimal64(buf);
+    }
+
+    readDecFloat34() {
+        // DECFLOAT(34) - IEEE 754 Decimal128 - 16 bytes
+        // Full IEEE 754-2008 Decimal128 implementation
+        const buf = this.buffer.slice(this.pos, this.pos + 16);
+        this.pos += 16;
+        
+        return decodeDecimal128(buf);
+    }
+
     readShort() {
         var r = this.buffer.readInt16BE(this.pos);
         this.pos += 2;