node-firebird 1.1.8 → 1.1.10

package/lib/wire/socket.js

@@ -0,0 +1,100 @@
+const net = require("net");
+const zlib = require("zlib");
+
+/**
+ * Socket proxy.
+ */
+class Socket {
+    constructor(port, host) {
+        this._socket = net.createConnection(port, host);
+        this._socket.setNoDelay(true);
+        this.compressor = null;
+        this.compressorBuffer = [];
+        this.decompressor = null;
+        this.decompressorBuffer = [];
+        this.buffer = null;
+
+        return new Proxy(this._socket, this);
+    }
+
+    /**
+     * Decompress data when receive it if compression is enabled.
+     * Override on data event.
+     */
+    on(event, cb) {
+        if (event === 'data') {
+            const mainCb = cb;
+            cb = (data) => {
+                if (this.compress) {
+                    this.decompressor.write(data, () => {
+                        mainCb(Buffer.concat(this.decompressorBuffer));
+                        this.decompressorBuffer = []; // Reset buffer
+                    });
+                } else {
+                    mainCb(data);
+                }
+            };
+        }
+
+        this._socket.on(event, cb);
+    }
+
+    /**
+     * Compress data before sending to socket if compression is enabled.
+     */
+    write(data, defer = false) {
+        if (defer) {
+            this.buffer = Buffer.from(data);
+            return;
+        }
+
+        if (!defer && this.buffer) {
+            data = Buffer.concat([this.buffer, data]);
+            this.buffer = null;
+        }
+
+        if (this.compress) {
+            this.compressor.write(data, () => {
+                this._socket.write(Buffer.concat(this.compressorBuffer));
+                this.compressorBuffer = []; // Reset buffer
+            });
+        } else {
+            this._socket.write(data);
+        }
+    }
+
+    /**
+     * Enable compression/decompression on the fly.
+     */
+    enableCompression() {
+        this.compress = true;
+
+        // Create decompressor instance
+        this.decompressor = zlib.createInflate();
+        this.decompressor.on('data', (inflate) => {
+            this.decompressorBuffer.push(inflate);
+        });
+
+        // Create compressor instance
+        this.compressor = zlib.createDeflate({
+            flush: zlib.constants.Z_FULL_FLUSH,
+            finishFlush: zlib.constants.Z_SYNC_FLUSH
+        });
+        this.compressor.on('data', (deflate) => {
+            this.compressorBuffer.push(deflate);
+        });
+    }
+
+    /**
+     * Proxy trap.
+     */
+    get(target, field) {
+        if (field in this) {
+            return this[field].bind(this);
+        }
+
+        return target[field];
+    }
+}
+
+module.exports = Socket;

package/lib/wire/statement.js

@@ -0,0 +1,47 @@
+/***************************************
+ *
+ *   Statement
+ *
+ ***************************************/
+
+function Statement(connection) {
+    this.connection = connection;
+}
+
+Statement.prototype.close = function(callback) {
+    this.connection.closeStatement(this, callback);
+};
+
+Statement.prototype.drop = function(callback) {
+    this.connection.dropStatement(this, callback);
+};
+
+Statement.prototype.release = function(callback) {
+    var cache_query = this.connection.getCachedQuery(this.query);
+    if (cache_query)
+        this.connection.closeStatement(this, callback);
+    else
+        this.connection.dropStatement(this, callback);
+};
+
+Statement.prototype.execute = function(transaction, params, callback, custom) {
+
+    if (params instanceof Function) {
+        custom = callback;
+        callback = params;
+        params = undefined;
+    }
+
+    this.custom = custom;
+    this.connection.executeStatement(transaction, this, params, callback, custom);
+};
+
+Statement.prototype.fetch = function(transaction, count, callback) {
+    this.connection.fetch(this, transaction, count, callback);
+};
+
+Statement.prototype.fetchAll = function(transaction, callback) {
+    this.connection.fetchAll(this, transaction, callback);
+};
+
+module.exports = Statement;

package/lib/wire/transaction.js

@@ -0,0 +1,160 @@
+const {doCallback, doError} = require('../callback');
+const Const = require('./const');
+
+/***************************************
+ *
+ *   Transaction
+ *
+ ***************************************/
+
+function Transaction(connection) {
+    this.connection = connection;
+    this.db = connection.db;
+}
+
+Transaction.prototype.newStatement = function(query, callback) {
+    var cnx = this.connection;
+    var self = this;
+    var query_cache = cnx.getCachedQuery(query);
+
+    if (query_cache) {
+        callback(null, query_cache);
+    } else {
+        cnx.prepare(self, query, false, callback);
+    }
+};
+
+Transaction.prototype.execute = function(query, params, callback, custom) {
+
+    if (params instanceof Function) {
+        custom = callback;
+        callback = params;
+        params = undefined;
+    }
+
+    var self = this;
+    this.newStatement(query, function(err, statement) {
+
+        if (err) {
+            doError(err, callback);
+            return;
+        }
+
+        function dropError(err) {
+            statement.release();
+            doCallback(err, callback);
+        }
+
+        statement.execute(self, params, function(err, ret) {
+            if (err) {
+                dropError(err);
+                return;
+            }
+
+            switch (statement.type) {
+                case Const.isc_info_sql_stmt_select:
+                    statement.fetchAll(self, function(err, r) {
+                        if (err) {
+                            dropError(err);
+                            return;
+                        }
+
+                        statement.release();
+
+                        if (callback)
+                            callback(undefined, r, statement.output, true);
+
+                    });
+
+                    break;
+
+                case Const.isc_info_sql_stmt_exec_procedure:
+                    if (ret && ret.data && ret.data.length > 0) {
+                        statement.release();
+
+                        if (callback)
+                            callback(undefined, ret.data[0], statement.output, true);
+
+                        break;
+                    } else if (statement.output.length) {
+                        statement.fetch(self, 1, function(err, ret) {
+                            if (err) {
+                                dropError(err);
+                                return;
+                            }
+
+                            statement.release();
+
+                            if (callback)
+                                callback(undefined, ret.data[0], statement.output, false);
+                        });
+
+                        break;
+                    }
+
+                // Fall through is normal
+                default:
+                    statement.release();
+                    if (callback)
+                        callback()
+                    break;
+            }
+
+        }, custom);
+    });
+};
+
+Transaction.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;
+};
+
+Transaction.prototype.query = function(query, params, callback) {
+
+    if (params instanceof Function) {
+        callback = params;
+        params = undefined;
+    }
+
+    if (callback === undefined)
+        callback = noop;
+
+    this.execute(query, params, callback, { asObject: true, asStream: callback === undefined || callback === null });
+
+};
+
+Transaction.prototype.commit = function(callback) {
+    this.connection.commit(this, callback);
+};
+
+Transaction.prototype.rollback = function(callback) {
+    this.connection.rollback(this, callback);
+};
+
+Transaction.prototype.commitRetaining = function(callback) {
+    this.connection.commitRetaining(this, callback);
+};
+
+Transaction.prototype.rollbackRetaining = function(callback) {
+    this.connection.rollbackRetaining(this, callback);
+};
+
+module.exports = Transaction;