README.md

@@ -83,8 +83,8 @@ pool.connect(function(err, client, done) {
     return console.error('error fetching client from pool', err);
   }
   client.query('SELECT $1::int AS number', ['1'], function(err, result) {
-    //call `done()` to release the client back to the pool
-    done();
+    //call `done(err)` to release the client back to the pool (or destroy it if there is an error)
+    done(err);
 
     if(err) {
       return console.error('error running query', err);

lib/connection.js

@@ -13,6 +13,21 @@ var util = require('util');
 var Writer = require('buffer-writer');
 var Reader = require('packet-reader');
 
+var indexOf =
+  'indexOf' in Buffer.prototype ?
+    function indexOf(buffer, value, start) {
+      return buffer.indexOf(value, start);
+    } :
+    function indexOf(buffer, value, start) {
+      for (var i = start, len = buffer.length; i < len; i++) {
+        if (buffer[i] === value) {
+          return i;
+        }
+      }
+
+      return -1;
+    };
+
 var TEXT_MODE = 0;
 var BINARY_MODE = 1;
 var Connection = function(config) {
@@ -647,8 +662,9 @@ Connection.prototype.readBytes = function(buffer, length) {
 
 Connection.prototype.parseCString = function(buffer) {
   var start = this.offset;
-  while(buffer[this.offset++] !== 0) { }
-  return buffer.toString(this.encoding, start, this.offset - 1);
+  var end = indexOf(buffer, 0, start);
+  this.offset = end + 1;
+  return buffer.toString(this.encoding, start, end);
 };
 //end parsing methods
 module.exports = Connection;

lib/defaults.js

@@ -62,7 +62,13 @@ var defaults = module.exports = {
   parseInputDatesAsUTC: false
 };
 
+var pgTypes = require('pg-types');
+// save default parsers
+var parseBigInteger = pgTypes.getTypeParser(20, 'text');
+var parseBigIntegerArray = pgTypes.getTypeParser(1016, 'text');
+
 //parse int8 so you can get your count values as actual numbers
 module.exports.__defineSetter__("parseInt8", function(val) {
-  require('pg-types').setTypeParser(20, 'text', val ? parseInt : function(val) { return val; });
+  pgTypes.setTypeParser(20, 'text', val ? pgTypes.getTypeParser(23, 'text') : parseBigInteger);
+  pgTypes.setTypeParser(1016, 'text', val ? pgTypes.getTypeParser(1007, 'text') : parseBigIntegerArray);
 });

lib/query.js

@@ -80,7 +80,19 @@ Query.prototype.handleRowDescription = function(msg) {
 };
 
 Query.prototype.handleDataRow = function(msg) {
-  var row = this._result.parseRow(msg.fields);
+  var row;
+
+  if (this._canceledDueToError) {
+    return;
+  }
+
+  try {
+    row = this._result.parseRow(msg.fields);
+  } catch (err) {
+    this._canceledDueToError = err;
+    return;
+  }
+
   this.emit('row', row, this._result);
   if (this._accumulateRows) {
     this._result.addRow(row);

package.json

@@ -1,6 +1,6 @@
 {
   "name": "pg",
-  "version": "6.1.2",
+  "version": "6.1.3",
   "description": "PostgreSQL client - pure javascript & libpq with the same API",
   "keywords": [
     "postgres",

test/integration/client/parse-int-8-tests.js

@@ -6,11 +6,18 @@ test('ability to turn on and off parser', function() {
   pg.connect(helper.config, assert.success(function(client, done) {
     pg.defaults.parseInt8 = true;
     client.query('CREATE TEMP TABLE asdf(id SERIAL PRIMARY KEY)');
-    client.query('SELECT COUNT(*) as "count" FROM asdf', assert.success(function(res) {
+    client.query('SELECT COUNT(*) as "count", \'{1,2,3}\'::bigint[] as array FROM asdf', assert.success(function(res) {
+      assert.strictEqual(0, res.rows[0].count);
+      assert.strictEqual(1, res.rows[0].array[0]);
+      assert.strictEqual(2, res.rows[0].array[1]);
+      assert.strictEqual(3, res.rows[0].array[2]);
       pg.defaults.parseInt8 = false;
-      client.query('SELECT COUNT(*) as "count" FROM asdf', assert.success(function(res) {
+      client.query('SELECT COUNT(*) as "count", \'{1,2,3}\'::bigint[] as array FROM asdf', assert.success(function(res) {
         done();
-        assert.strictEqual("0", res.rows[0].count);
+        assert.strictEqual('0', res.rows[0].count);
+        assert.strictEqual('1', res.rows[0].array[0]);
+        assert.strictEqual('2', res.rows[0].array[1]);
+        assert.strictEqual('3', res.rows[0].array[2]);
         pg.end();
       }));
     }));

test/unit/client/throw-in-type-parser-tests.js

@@ -0,0 +1,112 @@
+var helper = require(__dirname + "/test-helper");
+var types = require('pg-types')
+
+test('handles throws in type parsers', function() {
+  var typeParserError = new Error('TEST: Throw in type parsers');
+
+  types.setTypeParser('special oid that will throw', function () {
+    throw typeParserError;
+  });
+
+  test('emits error', function() {
+    var handled;
+    var client = helper.client();
+    var con = client.connection;
+    var query = client.query('whatever');
+
+    handled = con.emit('readyForQuery');
+    assert.ok(handled, "should have handled ready for query");
+
+    con.emit('rowDescription',{
+      fields: [{
+        name: 'boom',
+        dataTypeID: 'special oid that will throw'
+      }]
+    });
+    assert.ok(handled, "should have handled row description");
+
+    assert.emits(query, 'error', function(err) {
+      assert.equal(err, typeParserError);
+    });
+
+    handled = con.emit('dataRow', { fields: ["hi"] });
+    assert.ok(handled, "should have handled first data row message");
+
+    handled = con.emit('commandComplete', { text: 'INSERT 31 1' });
+    assert.ok(handled, "should have handled command complete");
+
+    handled = con.emit('readyForQuery');
+    assert.ok(handled, "should have handled ready for query");
+  });
+
+  test('calls callback with error', function() {
+    var handled;
+
+    var callbackCalled = 0;
+
+    var client = helper.client();
+    var con = client.connection;
+    var query = client.query('whatever', assert.calls(function (err) {
+      callbackCalled += 1;
+
+      assert.equal(callbackCalled, 1);
+      assert.equal(err, typeParserError);
+    }));
+
+    handled = con.emit('readyForQuery');
+    assert.ok(handled, "should have handled ready for query");
+
+    handled = con.emit('rowDescription',{
+      fields: [{
+        name: 'boom',
+        dataTypeID: 'special oid that will throw'
+      }]
+    });
+    assert.ok(handled, "should have handled row description");
+
+    handled = con.emit('dataRow', { fields: ["hi"] });
+    assert.ok(handled, "should have handled first data row message");
+
+    handled = con.emit('dataRow', { fields: ["hi"] });
+    assert.ok(handled, "should have handled second data row message");
+
+    con.emit('commandComplete', { text: 'INSERT 31 1' });
+    assert.ok(handled, "should have handled command complete");
+
+    handled = con.emit('readyForQuery');
+    assert.ok(handled, "should have handled ready for query");
+  });
+
+  test('rejects promise with error', function() {
+    var handled;
+    var client = helper.client();
+    var con = client.connection;
+    var query = client.query('whatever');
+    var queryPromise = query.promise();
+
+    handled = con.emit('readyForQuery');
+    assert.ok(handled, "should have handled ready for query");
+
+    handled = con.emit('rowDescription',{
+      fields: [{
+        name: 'boom',
+        dataTypeID: 'special oid that will throw'
+      }]
+    });
+    assert.ok(handled, "should have handled row description");
+
+    handled = con.emit('dataRow', { fields: ["hi"] });
+    assert.ok(handled, "should have handled first data row message");
+
+    handled = con.emit('commandComplete', { text: 'INSERT 31 1' });
+    assert.ok(handled, "should have handled command complete");
+
+    handled = con.emit('readyForQuery');
+    assert.ok(handled, "should have handled ready for query");
+
+    queryPromise.catch(assert.calls(function (err) {
+      assert.equal(err, typeParserError);
+    }));
+  });
+
+});