node-firebird 1.0.0 → 1.1.0

package/README.md

@@ -68,6 +68,7 @@ options.role = null;            // default
 options.pageSize = 4096;        // default when creating database
 options.pageSize = 4096;        // default when creating database
 options.retryConnectionInterval = 1000; // reconnect interval in case of connection drop
+options.blobAsText = false; // set to true to get blob as text, only affects blob subtype 1
 ```
 
 ### Classic
@@ -223,6 +224,73 @@ Firebird.attach(options, function(err, db) {
 });
 ```
 
+### Reading Multiples Blobs (Asynchronous)
+```js
+Firebird.attach(options, (err, db) => {
+    if (err)
+        throw err;
+
+    db.transaction(Firebird.ISOLATION_READ_COMMITED, (err, transaction) => {
+        if (err) {
+            throw err;
+        }
+
+        transaction.query('SELECT FIRST 10 * FROM JOB', (err, result) => {
+            if (err) {
+                transaction.rollback();
+                return;
+            }
+
+            const arrBlob = [];
+            for (const item of result) {
+                const fields = Object.keys(item);
+                for (const key of fields) {
+                    if (typeof item[key] === 'function') {
+                        item[key] = new Promise((resolve, reject) => {
+                            // the same transaction is used (better performance)
+                            // this is optional
+                            item[key](transaction, (error, name, event, row) => {
+                                if (error) {
+                                    return reject(error);
+                                }
+
+                                // reading data
+                                let value = '';
+                                event.on('data', (chunk) => {
+                                    value += chunk.toString('binary');
+                                });
+                                event.on('end', () => {
+                                    resolve({ value, column: name, row });
+                                });
+                            });
+                        });
+                        arrBlob.push(item[key]);
+                    }
+                }
+            }
+
+            Promise.all(arrBlob).then((blobs) => {
+                for (const blob of blobs) {
+                    result[blob.row][blob.column] = blob.value;
+                }
+
+                transaction.commit((err) => {
+                    if (err) {
+                        transaction.rollback();
+                        return;
+                    }
+
+                    db.detach();
+                    console.log(result);
+                });
+            }).catch((err) => {
+                transaction.rollback();
+            });
+        });
+    });
+});
+```
+
 ### Streaming a big data
 
 ```js

package/lib/index.d.ts

@@ -51,6 +51,37 @@ declare module 'node-firebird' {
         rollbackRetaining(callback?: SimpleCallback): void;
     }
 
+    export type SupportedCharacterSet = |
+        'NONE' |
+        'CP943C' |
+        'DOS737' |
+        'DOS775' |
+        'DOS858' |
+        'DOS862' |
+        'DOS864' |
+        'DOS866' |
+        'DOS869' |
+        'GB18030' |
+        'GBK' |
+        'ISO8859_2' |
+        'ISO8859_3' |
+        'ISO8859_4' |
+        'ISO8859_5' |
+        'ISO8859_6' |
+        'ISO8859_7' |
+        'ISO8859_8' |
+        'ISO8859_9' |
+        'ISO8859_13' |
+        'KOI8R' |
+        'KOI8U' |
+        'TIS620' |
+        'UTF8' |
+        'WIN1255' |
+        'WIN1256' |
+        'WIN1257' |
+        'WIN1258' |
+        'WIN_1258';
+
     export interface Options {
         host?: string;
         port?: number;
@@ -61,6 +92,8 @@ declare module 'node-firebird' {
         role?: string;
         pageSize?: number;
         retryConnectionInterval?: number;
+        encoding?: SupportedCharacterSet;
+        blobAsText?: boolean; // only affects for blob subtype 1
     }
 
     export interface SvcMgrOptions extends Options {

package/lib/index.js

@@ -3200,6 +3200,8 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                     }
                 }
 
+                const arrBlob = [];
+
                 while (data.fcount && (data.fstatus !== 100)) {
                     var lowerV13 = statement.connection.accept.protocolVersion < PROTOCOL_VERSION13;
 
@@ -3209,10 +3211,16 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
 
                             try {
                                 _xdrpos = data.pos;
-                                let key = custom.asObject ? data.fcols[data.fcolumn] : data.fcolumn;
+                                const key = custom.asObject ? data.fcols[data.fcolumn] : data.fcolumn;
+                                const row = data.frows.length;
                                 let value = item.decode(data, lowerV13);
-                                if (item.type === SQL_BLOB) {
-                                    value = fetch_blob_async(statement, value, key);
+                                if (item.type === SQL_BLOB && value !== null) {
+                                    if (item.subType === isc_blob_text && cnx.options.blobAsText) {
+                                        value = fetch_blob_async_transaction(statement, value, key, row);
+                                        arrBlob.push(value);
+                                    } else {
+                                        value = fetch_blob_async(statement, value, key, row);
+                                    }
                                 }
                                 data.frow[key] = value;
                             } catch (e) {
@@ -3245,8 +3253,13 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                                 _xdrpos = data.pos;
                                 var key = custom.asObject ? data.fcols[data.fcolumn] : data.fcolumn;
                                 var value = item.decode(data, lowerV13);
-                                if (item.type === SQL_BLOB) {
-                                    value = fetch_blob_async(statement, value, key);
+                                if (item.type === SQL_BLOB && value !== null) {
+                                    if (item.subType === isc_blob_text && cnx.options.blobAsText) {
+                                        value = fetch_blob_async_transaction(statement, value, key, data);
+                                        arrBlob.push(value);
+                                    } else {
+                                        value = fetch_blob_async(statement, value, key);
+                                    }
                                 }
                                 data.frow[key] = value;
                             } catch (e) {
@@ -3259,6 +3272,9 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                     }
 
                     data.fcolumn = 0;
+                    // ToDo: emit "row" with blob subtype string decoded
+                    // use: data.frow['fieldBlob'](transaction?).then(({ value }) => console.log(value))
+                    // arg "transaction" is optional
                     statement.connection.db.emit('row', data.frow, statement.nbrowsfetched, custom.asObject);
                     data.frows.push(data.frow);
                     data.frow = custom.asObject ? {} : new Array(output.length);
@@ -3293,8 +3309,9 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                     statement.nbrowsfetched++;
                 }
 
-                statement.connection.db.emit('result', data.frows);
-                return cb(null, {data: data.frows, fetched: Boolean(!isOpFetch || data.fstatus === 100)});
+                // ToDo: emit "result" with blob subtype string decoded
+                statement.connection.db.emit('result', data.frows, arrBlob);
+                return cb(null, {data: data.frows, fetched: Boolean(!isOpFetch || data.fstatus === 100), arrBlob});
             case op_accept:
             case op_cond_accept:
             case op_accept_data:
@@ -3605,7 +3622,7 @@ Connection.prototype.attach = function (options, callback, db) {
     blr.pos = 0;
 
     blr.addByte(isc_dpb_version1);
-    blr.addString(isc_dpb_lc_ctype, 'UTF8', DEFAULT_ENCODING);
+    blr.addString(isc_dpb_lc_ctype, options.encoding || 'UTF8', DEFAULT_ENCODING);
     blr.addString(isc_dpb_user_name, user, DEFAULT_ENCODING);
 	if (options.password && !this.accept.authData) {
 		if (this.accept.protocolVersion < PROTOCOL_VERSION13) {
@@ -4413,63 +4430,129 @@ Connection.prototype.sendExecute = function (op, statement, transaction, callbac
 	this._queueEvent(callback);
 }
 
-function fetch_blob_async(statement, id, name) {
-
-    if (!id)
-        return null;
+function fetch_blob_async_transaction(statement, id, name, row) {
+    const infoValue = {
+        row,
+        column: name,
+        value: ''
+    };
 
-    return function(callback) {
-        // callback(err, buffer, name);
-        statement.connection.startTransaction(ISOLATION_READ_UNCOMMITTED, function(err, transaction) {
+    return (transactionArg) => {
+        const singleTransaction = transactionArg === undefined;
 
-            if (err) {
-                callback(err);
-                return;
-            }
+        let promiseTransaction;
+        if (singleTransaction) {
+            promiseTransaction = new Promise((resolve, reject) => {
+                statement.connection.startTransaction(ISOLATION_READ_UNCOMMITTED, (err, transaction) => {
+                    if (err) {
+                        return reject(err);
+                    }
+                    resolve(transaction);
+                });
+            });
+        } else {
+            promiseTransaction = Promise.resolve(transactionArg);
+        }
 
-            statement.connection._pending.push('openBlob');
-            statement.connection.openBlob(id, transaction, function(err, blob) {
+        return promiseTransaction.then((transaction) => {
+            return new Promise((resolve, reject) => {
+                statement.connection._pending.push('openBlob');
+                statement.connection.openBlob(id, transaction, (err, blob) => {
+    
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+    
+                    const read = () => {
+                        statement.connection.getSegment(blob, (err, ret) => {
+    
+                            if (err) {
+                                if (singleTransaction) {
+                                    transaction.rollback(() => reject(err));
+                                } else {
+                                    reject(err);
+                                }
+                                return;
+                            }
+    
+                            if (ret.buffer) {
+                                const blr = new BlrReader(ret.buffer);
+                                const data = blr.readSegment();
+                                infoValue.value += data.toString(DEFAULT_ENCODING);
+                            }
+    
+                            if (ret.handle !== 2) {
+                                read();
+                                return;
+                            }
+    
+                            statement.connection.closeBlob(blob);
+                            if (singleTransaction) {
+                                transaction.commit((err) => {
+                                    if (err) {
+                                        reject(err);
+                                    } else {
+                                        resolve(infoValue);
+                                    }
+                                });
+                            } else {
+                                resolve(infoValue);
+                            }
+                        });
+                    };
+    
+                    read();
+                });
+            });
+        });
+    };
+}
 
-                var e = new Events.EventEmitter();
+function fetch_blob_async(statement, id, name, row) {
+    const cbTransaction = (transaction, close, callback) => {
+        statement.connection._pending.push('openBlob');
+        statement.connection.openBlob(id, transaction, (err, blob) => {
+            let e = new Events.EventEmitter();
 
-                e.pipe = function(stream) {
-                    e.on('data', function(chunk) {
-                        stream.write(chunk);
-                    });
-                    e.on('end', function() {
-                        stream.end();
-                    });
-                };
+            e.pipe = (stream) => {
+                e.on('data', (chunk) => {
+                    stream.write(chunk);
+                });
+                e.on('end', () => {
+                    stream.end();
+                });
+            };
 
-                if (err) {
-                    callback(err, name, e);
-                    return;
-                }
+            if (err) {
+                return callback(err, name, e, row);
+            }
 
-                function read() {
-                    statement.connection.getSegment(blob, function(err, ret) {
+            const read = () => {
+                statement.connection.getSegment(blob, (err, ret) => {
 
-                        if (err) {
-                            transaction.rollback(function() {
-                                e.emit('error', err);
-                            });
-                            return;
-                        }
+                    if (err) {
+                        transaction.rollback(() => {
+                            e.emit('error', err);
+                        });
+                        return;
+                    }
 
-                        if (ret.buffer) {
-                            var blr = new BlrReader(ret.buffer);
-                            var data = blr.readSegment();
+                    if (ret.buffer) {
+                        const blr = new BlrReader(ret.buffer);
+                        const data = blr.readSegment();
 
-                            e.emit('data', data);
-                        }
+                        e.emit('data', data);
+                    }
 
-                        if (ret.handle !== 2) {
-                            read();
-                            return;
-                        }
+                    if (ret.handle !== 2) {
+                        read();
+                        return;
+                    }
 
-                        statement.connection.closeBlob(blob);
-                        transaction.commit(function(err) {
+                    statement.connection.closeBlob(blob);
+                    if (close) {
+                        transaction.commit((err) => {
                             if (err) {
                                 e.emit('error', err);
                             } else {
@@ -4477,15 +4560,33 @@ function fetch_blob_async(statement, id, name) {
                             }
                             e = null;
                         });
+                    } else {
+                        e.emit('end');
+                        e = null;
+                    }
+                });
+            };
 
-                    });
-                }
-
-                callback(err, name, e);
-                read();
+            callback(err, name, e, row);
+            read();
+        });
+    };
 
+    return (transaction, callback) => {
+        // callback(error, nameField, eventEmitter, row)
+        const singleTransaction = callback === undefined;
+        if (singleTransaction) {
+            callback = transaction;
+            statement.connection.startTransaction(ISOLATION_READ_UNCOMMITTED, (err, transaction) => {
+                if (err) {
+                    callback(err);
+                    return;
+                }
+                cbTransaction(transaction, singleTransaction, callback);
             });
-        });
+        } else {
+            cbTransaction(transaction, singleTransaction, callback);
+        }
     };
 }
 
@@ -4514,24 +4615,34 @@ Connection.prototype.fetch = function(statement, transaction, count, callback) {
 };
 
 Connection.prototype.fetchAll = function (statement, transaction, callback) {
-	var self = this, data = [];
-	var loop = function (err, ret) {
+	const self = this, data = [];
+	const loop = (err, ret) => {
 		if (err) {
 			return callback(err);
 		} else if (ret && ret.data && ret.data.length) {
-			for (var i = 0; i < ret.data.length; i++) {
-				var 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 === ret.data.length - 1) {
-					if (ret.fetched) {
-						return callback(undefined, data);
-					} else {
-						self.fetch(statement, transaction, DEFAULT_FETCHSIZE, loop);
-					}
-				}
-			}
+            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, DEFAULT_FETCHSIZE, loop);
+                        }
+                    }
+                }
+            }).catch(callback);
 		} else if (ret.fetched) {
 			callback(undefined, data);
 		} else {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-firebird",
-    "version": "1.0.0",
+    "version": "1.1.0",
     "description": "Pure JavaScript and Asynchronous Firebird client for Node.js.",
     "keywords": [
         "firebird",