node-firebird 1.1.8 → 1.1.10

package/lib/wire/database.js

@@ -0,0 +1,198 @@
+const Events = require('events');
+const { doError } = require('../callback');
+const { escape } = require('../utils');
+const EventConnection = require('./eventConnection');
+const FbEventManager = require('./fbEventManager');
+
+/***************************************
+ *
+ *   Database
+ *
+ ***************************************/
+
+function Database(connection) {
+    this.connection = connection;
+    connection.db = this;
+    this.eventid = 1;
+}
+
+Database.prototype.__proto__ = Object.create(Events.EventEmitter.prototype, {
+    constructor: {
+        value: Database,
+        enumberable: false
+    }
+});
+
+Database.prototype.escape = function(value) {
+    return escape(value, this.connection.accept.protocolVersion);
+};
+
+Database.prototype.detach = function(callback, force) {
+
+    var self = this;
+
+    if (!force && self.connection._pending.length > 0) {
+        self.connection._detachAuto = true;
+        self.connection._detachCallback = callback;
+        return self;
+    }
+
+    if (self.connection._pooled === false) {
+        self.connection.detach(function (err, obj) {
+
+            self.connection.disconnect();
+            self.emit('detach', false);
+
+            if (callback)
+                callback(err, obj);
+
+        }, force);
+    } else {
+        self.emit('detach', false);
+        if (callback)
+            callback();
+    }
+
+    return self;
+};
+
+Database.prototype.transaction = function(options, callback) {
+    return this.startTransaction(options, callback);
+};
+
+Database.prototype.startTransaction = function(options, callback) {
+    this.connection.startTransaction(options, callback);
+    return this;
+};
+
+Database.prototype.newStatement = function (query, callback) {
+
+    this.startTransaction(function(err, transaction) {
+
+        if (err) {
+            callback(err);
+            return;
+        }
+
+        transaction.newStatement(query, function(err, statement) {
+
+            if (err) {
+                callback(err);
+                return;
+            }
+
+            transaction.commit(function(err) {
+                callback(err, statement);
+            });
+        });
+    });
+
+    return this;
+};
+
+Database.prototype.execute = function(query, params, callback, custom) {
+
+    if (params instanceof Function) {
+        custom = callback;
+        callback = params;
+        params = undefined;
+    }
+
+    var self = this;
+
+    self.connection.startTransaction(function(err, transaction) {
+
+        if (err) {
+            doError(err, callback);
+            return;
+        }
+
+        transaction.execute(query, params, function(err, result, meta, isSelect) {
+
+            if (err) {
+                transaction.rollback(function() {
+                    doError(err, callback);
+                });
+                return;
+            }
+
+            transaction.commit(function(err) {
+                if (callback)
+                    callback(err, result, meta, isSelect);
+            });
+
+        }, custom);
+    });
+
+    return self;
+};
+
+Database.prototype.sequentially = function(query, params, on, callback, asArray) {
+
+    if (params instanceof Function) {
+        asArray = callback;
+        callback = on;
+        on = params;
+        params = undefined;
+    }
+
+    if (on === undefined){
+        throw new Error('Expected "on" delegate.');
+    }
+
+    if (callback instanceof Boolean) {
+        asArray = callback;
+        callback = undefined;
+    }
+
+    var self = this;
+    self.execute(query, params, callback, { asObject: !asArray, asStream: true, on: on });
+    return self;
+};
+
+Database.prototype.query = function(query, params, callback) {
+
+    if (params instanceof Function) {
+        callback = params;
+        params = undefined;
+    }
+
+    var self = this;
+    self.execute(query, params, callback, { asObject: true, asStream: callback === undefined || callback === null });
+    return self;
+};
+
+Database.prototype.drop = function(callback) {
+    return this.connection.dropDatabase(callback);
+};
+
+Database.prototype.attachEvent = function (callback) {
+    var self = this;
+    this.connection.auxConnection(function (err, socket_info) {
+
+        if (err) {
+            doError(err, callback);
+            return;
+        }
+
+        const eventConnection = new EventConnection(self.connection.host, socket_info.port, function (err) {
+            if (err) {
+                doError(err, callback);
+                return;
+            }
+
+            const evt = new FbEventManager(self, eventConnection, self.eventid++, function (err) {
+                if (err) {
+                    doError(err, callback);
+                    return;
+                }
+
+                callback(err, evt);
+            });
+        }, self);
+    });
+
+    return this;
+}
+
+module.exports = Database;

package/lib/wire/eventConnection.js

@@ -0,0 +1,113 @@
+const net = require('net');
+const { XdrReader } = require('./serialize');
+const DEFAULT_ENCODING = 'utf8';
+const Const = require('./const');
+
+var EventConnection = function (host, port, callback, db) {
+    var self = this;
+    this.db = db;
+    this.emgr = null;
+    this._isClosed = false;
+    this._isOpened = false;
+    this._socket = net.createConnection(port, host);
+    this._bind_events(host, port, callback);
+    this.error;
+    this.eventcallback;
+};
+
+EventConnection.prototype._bind_events = function (host, port, callback) {
+    var self = this;
+
+    self._socket.on('close', function () {
+
+        self._isClosed = true;
+    })
+
+    self._socket.on('error', function (e) {
+
+        self.error = e;
+    })
+
+    self._socket.on('connect', function () {
+        self._isClosed = false;
+        self._isOpened = true;
+        if (callback)
+            callback();
+    });
+
+    self._socket.on('data', function (data) {
+        var xdr, buf;
+
+        if (!self._xdr) {
+            xdr = new XdrReader(data);
+        } else {
+            xdr = self._xdr;
+            delete (self._xdr);
+            buf = Buffer.from(data.length + xdr.buffer.length);
+            xdr.buffer.copy(buf);
+            data.copy(buf, xdr.buffer.length);
+            xdr.buffer = buf;
+        }
+
+        try {
+            var item, op;
+            var op_pos = xdr.pos;
+            var tmp_event;
+            while (xdr.pos < xdr.buffer.length) {
+                do {
+                    var r = xdr.readInt();
+                } while (r === Const.op_dummy);
+
+                switch (r) {
+                    case Const.op_event:
+                        xdr.readInt(); // db handle
+                        var buf = xdr.readArray();
+                        // first byte is always set to 1
+                        tmp_event = {};
+                        var lst_event = [];
+                        var eventname = '';
+                        var eventcount = 0;
+                        var pos = 1;
+                        while (pos < buf.length) {
+                            var len = buf.readInt8(pos++);
+                            eventname = buf.toString(DEFAULT_ENCODING, pos, pos + len);
+                            var prevcount = self.emgr.events[eventname] || 0;
+                            pos += len;
+                            eventcount = buf.readInt32LE(pos);
+                            tmp_event[eventname] = eventcount;
+                            pos += 4;
+                            if (prevcount !== eventcount)
+                                lst_event.push({ name: eventname, count: eventcount });
+                        }
+                        xdr.readInt64(); // ignore AST INFO
+                        var event_id = xdr.readInt();
+                        // set the new count in global event hash
+                        for (var evt in tmp_event) {
+                            self.emgr.events[evt] = tmp_event[evt];
+                        }
+                        if (self.eventcallback)
+                            return self.eventcallback(null, { eventid: event_id, events: lst_event });
+
+                    default:
+                        return cb(new Error('Unexpected:' + r));
+                }
+            }
+        } catch (err) {
+            if (err instanceof RangeError) { // incomplete packet case
+                xdr.buffer = xdr.buffer = xdr.buffer.slice(op_pos);
+                xdr.pos = 0;
+                self._xdr = xdr;
+            }
+        }
+    })
+}
+
+EventConnection.prototype.throwClosed = function (callback) {
+    var err = new Error('Event Connection is closed.');
+    this.db.emit('error', err);
+    if (callback)
+        callback(err);
+    return this;
+};
+
+module.exports = EventConnection;

package/lib/wire/fbEventManager.js

@@ -0,0 +1,98 @@
+const Events = require('events');
+const { doError } = require('../callback');
+
+
+function FbEventManager(db, eventconnection, eventid, callback) {
+    this.db = db;
+    this.eventconnection = eventconnection;
+    this.events = {};
+    this.eventid = eventid;
+    this._createEventLoop(callback);
+}
+
+FbEventManager.prototype.__proto__ = Object.create(Events.EventEmitter.prototype, {
+    constructor: {
+        value: FbEventManager,
+        enumberable: false
+    }
+});
+
+FbEventManager.prototype._createEventLoop = function (callback) {
+    var self = this;
+    var cnx = this.db.connection;
+    this.eventconnection.emgr = this;
+    // create the loop
+    function loop(first) {
+        cnx.queEvents(self.events, self.eventid, function (err, ret) {
+            if (err) {
+                doError(err, callback);
+                return;
+            }
+            if (first)
+                callback();
+        })
+    }
+
+    this.eventconnection.eventcallback = function (err, ret) {
+        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)
+        })
+
+        loop(false);
+    }
+
+    loop(true);
+}
+
+FbEventManager.prototype._changeEvent = function (callback) {
+    var self = this;
+
+    self.db.connection.closeEvents(this.eventid, function (err) {
+        if (err) {
+            doError(err, callback);
+            return;
+        }
+        
+        self.db.connection.queEvents(self.events, self.eventid, callback);
+    })
+}
+
+FbEventManager.prototype.registerEvent = function (events, callback) {
+    var self = this;
+
+    if (self.db.connection._isClosed || self.eventconnection._isClosed)
+        return self.eventconnection.throwClosed(callback);
+
+    events.forEach((event) => self.events[event] = self.events[event] || 0);
+    self._changeEvent(callback);
+}
+
+FbEventManager.prototype.unregisterEvent = function (events, callback) {
+    var self = this;
+
+    if (self.db.connection._isClosed || self.eventconnection._isClosed)
+        return self.eventconnection.throwClosed(callback);
+
+    events.forEach(function (event) { delete self.events[event] });
+    self._changeEvent(callback);
+}
+
+FbEventManager.prototype.close = function (callback) {
+    var self = this;
+
+    self.db.connection.closeEvents(this.eventid, function (err) {
+        if (err) {
+            doError(err, callback);
+            return;
+        }
+
+        self.eventconnection._socket.end();
+    });
+}
+
+module.exports = FbEventManager;

package/lib/{serialize.js → wire/serialize.js}

@@ -1,4 +1,3 @@
-
 var Long = require('long');
 
 function align(n) {
@@ -103,7 +102,7 @@ BlrWriter.prototype.addString = function (c, s, encoding) {
 };
 
 BlrWriter.prototype.addBuffer = function (b) {
-    this.addSmall(b.length);
+    this.addWord(b.length);
     this.ensure(b.length);
     b.copy(this.buffer, this.pos);
     this.pos += b.length;
@@ -269,6 +268,20 @@ XdrWriter.prototype.addInt64 = function (value) {
     this.pos += 4;
 };
 
+XdrWriter.prototype.addInt128 = function (value) {
+    this.ensure(16);
+
+    const bigValue = BigInt(value);
+
+    const high = bigValue >> BigInt(64);
+    const low = bigValue & BigInt("0xFFFFFFFFFFFFFFFF");
+
+    this.buffer.writeBigUInt64BE(high, this.pos);
+    this.pos += 8;
+    this.buffer.writeBigUInt64BE(low, this.pos);
+    this.pos += 8;
+};
+
 XdrWriter.prototype.addUInt = function (value) {
     this.ensure(4);
     this.buffer.writeUInt32BE(value, this.pos);
@@ -366,6 +379,16 @@ XdrReader.prototype.readInt64 = function () {
     return new Long(low, high).toNumber();
 };
 
+XdrReader.prototype.readInt128 = function () {
+    var high = this.buffer.readBigUInt64BE(this.pos)
+    this.pos += 8
+
+    var low = this.buffer.readBigUInt64BE(this.pos)
+    this.pos += 8
+
+    return (BigInt(high) << BigInt(64)) + BigInt(low)
+};
+
 XdrReader.prototype.readShort = function () {
     var r = this.buffer.readInt16BE(this.pos);
     this.pos += 2;