node-firebird 0.9.9 → 1.1.0

package/lib/index.js

@@ -11,7 +11,9 @@ var
 	BitSet = serialize.BitSet,
     messages = require('./messages.js'),
     crypt = require('./unix-crypt.js'),
-    path = require('path');
+    path = require('path'),
+	srp = require('./srp'),
+	BigInt = require('big-integer');
 
 if (typeof(setImmediate) === 'undefined') {
     global.setImmediate = function(cb) {
@@ -274,7 +276,9 @@ const
 	ptype_rpc = 2, 			 // Simple remote procedure call
     ptype_batch_send = 3,    // Batch sends, no asynchrony
 	ptype_out_of_band = 4,   // Batch sends w/ out of band notification
-	ptype_lazy_send = 5;     // Deferred packets delivery;
+	ptype_lazy_send = 5,     // Deferred packets delivery;
+	ptype_mask = 0xFF,       // Mask - up to 255 types of protocol
+	pflag_compress = 0x100;  // Turn on compression if possible
 
 const SUPPORTED_PROTOCOL = [
 	[PROTOCOL_VERSION10, ARCHITECTURE_GENERIC, ptype_rpc, ptype_batch_send, 1],
@@ -790,11 +794,25 @@ const
     DEFAULT_PAGE_SIZE = 4096,
     DEFAULT_SVC_NAME = 'service_mgr';
 
-const AUTH_PLUGIN_LEGACY = 'Legacy_Auth';
+const AUTH_PLUGIN_LEGACY = 'Legacy_Auth',
+ 	  AUTH_PLUGIN_SRP = 'Srp';
+	  // AUTH_PLUGIN_SRP256 = 'Srp256';
 
 const
-	AUTH_PLUGIN_LIST = [AUTH_PLUGIN_LEGACY],
-    LEGACY_AUTH_SALT = '9z';
+	// AUTH_PLUGIN_LIST = [AUTH_PLUGIN_SRP256, AUTH_PLUGIN_SRP, AUTH_PLUGIN_LEGACY],
+	AUTH_PLUGIN_LIST = [AUTH_PLUGIN_SRP, AUTH_PLUGIN_LEGACY],
+	// AUTH_PLUGIN_SRP_LIST = [AUTH_PLUGIN_SRP256, AUTH_PLUGIN_SRP],
+	AUTH_PLUGIN_SRP_LIST = [AUTH_PLUGIN_SRP],
+    LEGACY_AUTH_SALT = '9z',
+	WIRE_CRYPT_DISABLE = 0,
+	WIRE_CRYPT_ENABLE = 1;
+
+exports.AUTH_PLUGIN_LEGACY = AUTH_PLUGIN_LEGACY;
+exports.AUTH_PLUGIN_SRP = AUTH_PLUGIN_SRP;
+// exports.AUTH_PLUGIN_SRP256 = AUTH_PLUGIN_SRP256;
+
+exports.WIRE_CRYPT_DISABLE = WIRE_CRYPT_DISABLE;
+exports.WIRE_CRYPT_ENABLE = WIRE_CRYPT_ENABLE;
 
 exports.ISOLATION_READ_UNCOMMITTED = ISOLATION_READ_UNCOMMITTED;
 exports.ISOLATION_READ_COMMITED = ISOLATION_READ_COMMITED;
@@ -1284,7 +1302,9 @@ SQLParamBool.prototype.calcBlr = function(blr) {
  ***************************************/
 
 function isError(obj) {
-    return (obj instanceof Object && obj.status);
+    return Boolean(
+      obj != null && typeof obj === "object" && !Array.isArray(obj) && obj.status
+    );
 }
 
 function doCallback(obj, callback) {
@@ -2885,17 +2905,40 @@ Pool.prototype.check = function() {
     return self;
 };
 
-Pool.prototype.destroy = function() {
+Pool.prototype.destroy = function(callback) {
     var self = this;
+
+    var connectionCount = this.internaldb.length;
+
+    if (connectionCount === 0 && callback) {
+        callback();
+    }
+
+    function detachCallback(err) {
+        if (err) {
+            if (callback) {
+                callback(err);
+            }
+            return;
+        }
+
+        connectionCount--;
+        if (connectionCount === 0 && callback) {
+            callback();
+        }
+    }
+
     this.internaldb.forEach(function(db) {
-        if (db.connection._pooled === false)
+        if (db.connection._pooled === false) {
+            detachCallback();
             return;
+        }
         // check if the db is not free into the pool otherwise user should manual detach it
         var _db_in_pool = self.pooldb.indexOf(db);
         if (_db_in_pool !== -1) {
             self.pooldb.splice(_db_in_pool, 1);
             db.connection._pooled = false;
-            db.detach();
+            db.detach(detachCallback);
         }
     });
 };
@@ -2918,6 +2961,7 @@ var Connection = exports.Connection = function (host, port, callback, options, d
     this._detachAuto;
     this._socket = net.createConnection(port, host);
     this._pending = [];
+    this._isOpened = false;
     this._isClosed = false;
     this._isDetach = false;
     this._isUsed = false;
@@ -2925,6 +2969,8 @@ var Connection = exports.Connection = function (host, port, callback, options, d
     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');
@@ -2950,10 +2996,11 @@ exports.Connection.prototype._bind_events = function(host, port, callback) {
 
     self._socket.on('close', function() {
 
-        self._isClosed = true;
-
-        if (self._isDetach)
+        if (!self._isOpened || self._isDetach) {
             return;
+        }
+
+        self._isOpened = false;
 
         if (!self.db) {
             if (callback)
@@ -2961,10 +3008,9 @@ exports.Connection.prototype._bind_events = function(host, port, callback) {
             return;
         }
 
-        setImmediate(function() {
+       self._retry_connection_id = setTimeout(function() {
+            self._socket.removeAllListeners();
             self._socket = null;
-            self._msg = null;
-            self._blr = null;
 
             var ctx = new Connection(host, port, function(err) {
                 ctx.connect(self.options, function(err) {
@@ -2988,8 +3034,10 @@ exports.Connection.prototype._bind_events = function(host, port, callback) {
                     }, self.db);
                 });
 
+				Object.assign(self, ctx);
+
             }, self.options, self.db);
-        });
+        }, self._retry_connection_interval);
 
     });
 
@@ -3152,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;
 
@@ -3161,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) {
@@ -3197,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) {
@@ -3211,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);
@@ -3245,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:
@@ -3255,22 +3320,77 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                     protocolArchitecture: data.readInt(),
                     protocolMinimumType: data.readInt(),
                     pluginName: '',
-                    authData: ''
+                    authData: '',
+					sessionKey: ''
                 };
 
                 accept.protocolMinimumType = accept.protocolMinimumType & 0xFF;
+				//accept.compress = (accept.acceptType & pflag_compress) !== 0; // TODO Handle zlib compression
                 if (accept.protocolVersion < 0) {
                     accept.protocolVersion = (accept.protocolVersion & FB_PROTOCOL_MASK) | FB_PROTOCOL_FLAG;
                 }
 
                 if (r === op_cond_accept || r === op_accept_data) {
-                    var d = data.readString(DEFAULT_ENCODING);
+                    var d = new BlrReader(data.readArray());
                     accept.pluginName = data.readString(DEFAULT_ENCODING);
                     var is_authenticated = data.readInt();
                     var keys = data.readString(DEFAULT_ENCODING); // keys
 
                     if (is_authenticated === 0) {
-                        if (accept.pluginName === AUTH_PLUGIN_LEGACY) {
+                    	if (cnx.options.pluginName && cnx.options.pluginName !== accept.pluginName) {
+                    		doError(new Error('Server don\'t accept plugin : ' + cnx.options.pluginName + ', but support : ' + accept.pluginName), callback);
+						}
+
+                    	if (AUTH_PLUGIN_SRP_LIST.indexOf(accept.pluginName) !== -1) {
+							var crypto = {
+								Srp: 'sha1',
+								Srp256: 'sha256'
+							};
+							accept.srpAlgo = crypto[accept.pluginName];
+
+							// TODO : Fallback Srp256 to Srp ?
+							/*if (!d.buffer) {
+								cnx.sendOpContAuth(
+									cnx.clientKeys.public.toString(16),
+									DEFAULT_ENCODING,
+									accept.pluginName
+								);
+
+								return cb(new Error('login'));
+							}*/
+
+							// Check buffer contains salt
+							var saltLen = d.buffer.readUInt16LE(0);
+							if (saltLen > 32 * 2) {
+								console.log('salt to long'); // TODO : Throw error
+							}
+
+							// Check buffer contains key
+							var keyLen = d.buffer.readUInt16LE(saltLen + 2);
+							var keyStart = saltLen + 4;
+							if (d.buffer.length - keyStart !== keyLen) {
+								console.log('key error'); // TODO : Throw error
+							}
+
+							// Server keys
+							cnx.serverKeys = {
+								salt: d.buffer.slice(2, saltLen + 2).toString('utf8'),
+								public: BigInt(d.buffer.slice(keyStart, d.buffer.length).toString('utf8'), 16)
+							};
+
+							var proof = srp.clientProof(
+								cnx.options.user.toUpperCase(),
+								cnx.options.password,
+								cnx.serverKeys.salt,
+								cnx.clientKeys.public,
+								cnx.serverKeys.public,
+								cnx.clientKeys.private,
+								accept.srpAlgo
+							);
+
+							accept.authData = proof.authData.toString(16);
+							accept.sessionKey = proof.clientSessionKey;
+						} else if (accept.pluginName === AUTH_PLUGIN_LEGACY) {
                             accept.authData = crypt.crypt(cnx.options.password, LEGACY_AUTH_SALT).substring(2);
                         } else {
                             return cb(new Error('Unknow auth plugin : ' + accept.pluginName));
@@ -3280,7 +3400,35 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                         accept.sessionKey = '';
                     }
                 }
+
                 return cb(undefined, accept);
+			case op_cont_auth:
+				var d = new BlrReader(data.readArray());
+				var pluginName = data.readString(DEFAULT_ENCODING);
+				data.readString(DEFAULT_ENCODING); // plist
+				data.readString(DEFAULT_ENCODING); // pkey
+
+				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 === AUTH_PLUGIN_LEGACY) { // Fallback to LegacyAuth
+						cnx.accept.pluginName = pluginName;
+						cnx.accept.authData = crypt.crypt(cnx.options.password, LEGACY_AUTH_SALT).substring(2);
+
+						cnx.sendOpContAuth(
+							cnx.accept.authData,
+							DEFAULT_ENCODING,
+							pluginName
+						);
+
+						return {error: new Error('login')};
+					}
+				}
+
+				return data.accept;
             default:
                 return cb(new Error('Unexpected:' + r));
         }
@@ -3366,6 +3514,20 @@ function parseOpResponse(data, response, cb) {
     }
 }
 
+Connection.prototype.sendOpContAuth = function(authData, authDataEnc, pluginName) {
+	var msg = this._msg;
+	msg.pos = 0;
+
+	msg.addInt(op_cont_auth);
+	msg.addString(authData, authDataEnc);
+	msg.addString(pluginName, DEFAULT_ENCODING)
+	msg.addString(AUTH_PLUGIN_LIST.join(','), DEFAULT_ENCODING);
+	// msg.addInt(0); // p_list
+	msg.addInt(0); // keys
+
+	this._socket.write(msg.getData());
+}
+
 Connection.prototype._queueEvent = function(callback){
     var self = this;
 
@@ -3380,7 +3542,7 @@ Connection.prototype._queueEvent = function(callback){
 };
 
 Connection.prototype.connect = function (options, callback) {
-	var pluginName = AUTH_PLUGIN_LEGACY;
+	var pluginName = options.manager ? AUTH_PLUGIN_LEGACY : options.pluginName || AUTH_PLUGIN_LIST[0]; // TODO Srp for service
     var msg = this._msg;
     var blr = this._blr;
 
@@ -3393,13 +3555,19 @@ Connection.prototype.connect = function (options, callback) {
 	blr.addString(CNCT_plugin_name, pluginName, DEFAULT_ENCODING);
 	blr.addString(CNCT_plugin_list, AUTH_PLUGIN_LIST.join(','), DEFAULT_ENCODING);
 
-	if (pluginName === AUTH_PLUGIN_LEGACY) {
-		var specificData = crypt.crypt(options.password, LEGACY_AUTH_SALT).substring(2);
+	var specificData = '';
+	if (AUTH_PLUGIN_SRP_LIST.indexOf(pluginName) > -1) {
+		this.clientKeys = srp.clientSeed();
+		specificData = this.clientKeys.public.toString(16);
+		blr.addMultiblockPart(CNCT_specific_data, specificData, DEFAULT_ENCODING);
+	} else if (pluginName === AUTH_PLUGIN_LEGACY) {
+		specificData = crypt.crypt(options.password, LEGACY_AUTH_SALT).substring(2);
 		blr.addMultiblockPart(CNCT_specific_data, specificData, DEFAULT_ENCODING);
 	} else {
-		throw new Error('Invalide auth plugin');
+		doError(new Error('Invalide auth plugin \'' + pluginName + '\''), callback);
+		return;
 	}
-	blr.addBytes([CNCT_client_crypt, 4, 0, 0, 0, 0]); // WireCrypt = Disabled
+	blr.addBytes([CNCT_client_crypt, 4, WIRE_CRYPT_DISABLE, 0, 0, 0]); // WireCrypt = Disabled
 	blr.addString(CNCT_user, os.userInfo().username || 'Unknown', DEFAULT_ENCODING);
     blr.addString(CNCT_host, os.hostname(), DEFAULT_ENCODING);
     blr.addBytes([CNCT_user_verification, 0]);
@@ -3454,15 +3622,18 @@ 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 (this.accept.protocolVersion < PROTOCOL_VERSION13) {
-		if (this.accept.protocolVersion === PROTOCOL_VERSION10) {
-			blr.addString(isc_dpb_password, password, DEFAULT_ENCODING);
-		} else {
-			blr.addString(isc_dpb_password_enc, crypt.crypt(password, LEGACY_AUTH_SALT).substring(2), DEFAULT_ENCODING);
+	if (options.password && !this.accept.authData) {
+		if (this.accept.protocolVersion < PROTOCOL_VERSION13) {
+			if (this.accept.protocolVersion === PROTOCOL_VERSION10) {
+				blr.addString(isc_dpb_password, password, DEFAULT_ENCODING);
+			} else {
+				blr.addString(isc_dpb_password_enc, crypt.crypt(password, LEGACY_AUTH_SALT).substring(2), DEFAULT_ENCODING);
+			}
 		}
 	}
+
     if (role)
         blr.addString(isc_dpb_sql_role_name, role, DEFAULT_ENCODING);
 
@@ -3522,6 +3693,7 @@ Connection.prototype.detach = function (callback) {
     msg.addInt(0); // Database Object ID
 
     self._queueEvent(function(err, ret) {
+        clearTimeout(self._retry_connection_id);
         delete(self.dbhandle);
         if (callback)
             callback(err, ret);
@@ -4258,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 {
@@ -4322,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);
+        }
     };
 }
 
@@ -4359,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 {