merge with upstream

Author: andythiv

.travis.yml

@@ -14,39 +14,27 @@ addons:
 
 matrix:
   include:
-    - node_js: "0.10"
-      addons:
-        postgresql: "9.1"
-    - node_js: "0.10"
-      addons:
-        postgresql: "9.2"
-    - node_js: "0.10"
-      addons:
-        postgresql: "9.3"
     - node_js: "0.10"
       addons:
         postgresql: "9.4"
     - node_js: "0.12"
       addons:
-        postgresql: "9.1"
-    - node_js: "0.12"
-      addons:
-        postgresql: "9.2"
-    - node_js: "0.12"
+        postgresql: "9.4"
+    - node_js: "4"
       addons:
-        postgresql: "9.3"
-    - node_js: "0.12"
+        postgresql: "9.4"
+    - node_js: "5"
       addons:
         postgresql: "9.4"
-    - node_js: "4.1"
+    - node_js: "6"
       addons:
         postgresql: "9.1"
-    - node_js: "4.1"
+    - node_js: "6"
       addons:
         postgresql: "9.2"
-    - node_js: "4.1"
+    - node_js: "6"
       addons:
         postgresql: "9.3"
-    - node_js: "4.1"
+    - node_js: "6"
       addons:
         postgresql: "9.4"

NEWS.md

@@ -4,6 +4,9 @@ For richer information consult the commit log on github with referenced pull req
 
 We do not include break-fix version release in this file.
 
+### v4.5.0
+- Add option to parse JS date objects in query parameters as [UTC](https://github.com/brianc/node-postgres/pull/943)
+
 ### v4.4.0
 - Warn to `stderr` if a named query exceeds 63 characters which is the max lenght supported by postgres.
 

README.md

@@ -24,15 +24,15 @@ var conString = "postgres://username:password@localhost/database";
 
 //this initializes a connection pool
 //it will keep idle connections open for a (configurable) 30 seconds
-//and set a limit of 20 (also configurable)
+//and set a limit of 10 (also configurable)
 pg.connect(conString, function(err, client, done) {
   if(err) {
     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();
-    
+
     if(err) {
       return console.error('error running query', err);
     }
@@ -124,32 +124,14 @@ Usually I'll pop the code into the repo as a test.  Hopefully the test fails.  T
 
 If you need help or run into _any_ issues getting node-postgres to work on your system please report a bug or contact me directly.  I am usually available via google-talk at my github account public email address.
 
-I usually tweet about any important status updates or changes to node-postgres on twitter.  
+I usually tweet about any important status updates or changes to node-postgres on twitter.
 Follow me [@briancarlson](https://twitter.com/briancarlson) to keep up to date.
 
 
 ## Extras
 
-node-postgres is by design pretty light on abstractions.  These are some handy modules we've been using over the years to complete the picture:
-
-- [brianc/node-pg-native](https://github.com/brianc/node-pg-native) - Simple interface abstraction on top of [libpq](https://github.com/brianc/node-libpq)
-- [brianc/node-pg-query-stream](https://github.com/brianc/node-pg-query-stream) - Query results from node-postgres as a readable (object) stream
-- [brianc/node-pg-cursor](https://github.com/brianc/node-pg-cursor) - Query cursor extension for node-postgres
-- [brianc/node-pg-copy-streams](https://github.com/brianc/node-pg-copy-streams) - COPY FROM / COPY TO for node-postgres. Stream from one database to another, and stuff.
-- [brianc/node-postgres-pure](https://github.com/brianc/node-postgres-pure) - node-postgres without any of the C/C++ stuff
-- [brianc/node-pg-types](https://github.com/brianc/node-pg-types) - Type parsing for node-postgres
-- [Suor/pg-bricks](https://github.com/Suor/pg-bricks) - A higher level wrapper around node-postgres to handle connection settings, sql generation, transactions and ease data access.
-- [grncdr/node-any-db](https://github.com/grncdr/node-any-db) - Thin and less-opinionated database abstraction layer for node.
-- [brianc/node-sql](https://github.com/brianc/node-sql) - SQL generation for node.js
-- [hiddentao/squel](https://hiddentao.github.io/squel/) - SQL query string builder for Javascript
-- [CSNW/sql-bricks](https://github.com/CSNW/sql-bricks) - Transparent, Schemaless SQL Generation
-- [datalanche/node-pg-format](https://github.com/datalanche/node-pg-format) - Safely and easily create dynamic SQL queries with this Node implementation of [PostgreSQL format()](http://www.postgresql.org/docs/9.3/static/functions-string.html#FUNCTIONS-STRING-FORMAT).
-- [iceddev/pg-transact](https://github.com/iceddev/pg-transact) - A nicer API on node-postgres transactions
-- [sehrope/node-pg-db](https://github.com/sehrope/node-pg-db) - Simpler interface, named parameter support, transaction management and event hooks.
-- [vitaly-t/pg-promise](https://github.com/vitaly-t/pg-promise) - Use node-postgres via [Promises/A+](https://promisesaplus.com/).
-- [pg-then](https://github.com/coderhaoxin/pg-then) A tiny wrapper of `pg` for promise api.
-- [acarl/pg-restify](https://github.com/acarl/pg-restify) - Creates a generic REST API for a postgres database using restify.
-- [XeCycle/pg-template-tag](https://github.com/XeCycle/pg-template-tag) - Write queries with ES6 tagged template literals, a "poor man's query builder".
+node-postgres is by design pretty light on abstractions.  These are some handy modules we've been using over the years to complete the picture.
+Entire list can be found on [wiki](https://github.com/brianc/node-postgres/wiki/Extras)
 
 ## License
 

lib/client.js

@@ -85,7 +85,7 @@ Client.prototype.connect = function(callback) {
   //password request handling
   con.on('authenticationMD5Password', checkPgPass(function(msg) {
     var inner = Client.md5(self.password + self.user);
-    var outer = Client.md5(inner + msg.salt.toString('binary'));
+    var outer = Client.md5(Buffer.concat([new Buffer(inner), msg.salt]));
     var md5password = "md5" + outer;
     con.password(md5password);
   }));

lib/connection.js

@@ -159,7 +159,7 @@ Connection.prototype.cancel = function(processID, secretKey) {
     .addInt16(5678)
     .addInt32(processID)
     .addInt32(secretKey)
-    .addCString('').flush();
+    .flush();
 
   var length = bodyBuffer.length + 4;
 
@@ -423,7 +423,7 @@ Connection.prototype.parseR = function(buffer, length) {
       return msg;
     }
   }
-  throw new Error("Unknown authenticatinOk message type" + util.inspect(msg));
+  throw new Error("Unknown authenticationOk message type" + util.inspect(msg));
 };
 
 Connection.prototype.parseS = function(buffer, length) {

lib/defaults.js

@@ -1,5 +1,5 @@
 var defaults = module.exports = {
-  // database host defaults to localhost
+  // database host. defaults to localhost
   host: 'localhost',
 
   //database user's name
@@ -30,7 +30,7 @@ var defaults = module.exports = {
   //from the pool and destroyed
   poolIdleTimeout: 30000,
 
-  //frequeny to check for idle clients within the client pool
+  //frequency to check for idle clients within the client pool
   reapIntervalMillis: 1000,
 
   //pool log function / boolean
@@ -40,8 +40,10 @@ var defaults = module.exports = {
 
   ssl: false,
 
-  application_name : undefined,
-  fallback_application_name: undefined
+  application_name: undefined,
+  fallback_application_name: undefined,
+
+  parseInputDatesAsUTC: false
 };
 
 //parse int8 so you can get your count values as actual numbers

lib/index.js

@@ -8,9 +8,9 @@ var Connection = require('./connection');
 var PG = function(clientConstructor) {
   EventEmitter.call(this);
   this.defaults = defaults;
-  this.Client = pool.Client = clientConstructor;
+  this.Client = clientConstructor;
   this.Query = this.Client.Query;
-  this.pools = pool;
+  this.pools = pool(clientConstructor);
   this.Connection = Connection;
   this.types = require('pg-types');
 };

lib/native/result.js

@@ -19,3 +19,10 @@ NativeResult.prototype.addCommandComplete = function(pq) {
     });
   }
 };
+
+NativeResult.prototype.addRow = function(row) {
+  // This is empty to ensure pg code doesn't break when switching to pg-native
+  // pg-native loads all rows into the final result object by default.
+  // This is because libpg loads all rows into memory before passing the result
+  // to pg-native.
+};

lib/pool.js

@@ -3,93 +3,96 @@ var EventEmitter = require('events').EventEmitter;
 var defaults = require('./defaults');
 var genericPool = require('generic-pool');
 
-var pools = {
-  //dictionary of all key:pool pairs
-  all: {},
-  //reference to the client constructor - can override in tests or for require('pg').native
-  Client: require('./client'),
-  getOrCreate: function(clientConfig) {
-    clientConfig = clientConfig || {};
-    var name = JSON.stringify(clientConfig);
-    var pool = pools.all[name];
-    if(pool) {
-      return pool;
-    }
-    pool = genericPool.Pool({
-      name: name,
-      max: clientConfig.poolSize || defaults.poolSize,
-      idleTimeoutMillis: clientConfig.poolIdleTimeout || defaults.poolIdleTimeout,
-      reapIntervalMillis: clientConfig.reapIntervalMillis || defaults.reapIntervalMillis,
-      log: clientConfig.poolLog || defaults.poolLog,
-      create: function(cb) {
-        var client = new pools.Client(clientConfig);
-        // Ignore errors on pooled clients until they are connected.
-        client.on('error', Function.prototype);
-        client.connect(function(err) {
-          if(err) return cb(err, null);
 
-          // Remove the noop error handler after a connection has been established.
-          client.removeListener('error', Function.prototype);
+module.exports = function(Client) {
+  var pools = {
+    Client: Client,
+    //dictionary of all key:pool pairs
+    all: {},
+    //reference to the client constructor - can override in tests or for require('pg').native
+    getOrCreate: function(clientConfig) {
+      clientConfig = clientConfig || {};
+      var name = JSON.stringify(clientConfig);
+      var pool = pools.all[name];
+      if(pool) {
+        return pool;
+      }
+      pool = genericPool.Pool({
+        name: name,
+        max: clientConfig.poolSize || defaults.poolSize,
+        idleTimeoutMillis: clientConfig.poolIdleTimeout || defaults.poolIdleTimeout,
+        reapIntervalMillis: clientConfig.reapIntervalMillis || defaults.reapIntervalMillis,
+        log: clientConfig.poolLog || defaults.poolLog,
+        create: function(cb) {
+          var client = new pools.Client(clientConfig);
+          // Ignore errors on pooled clients until they are connected.
+          client.on('error', Function.prototype);
+          client.connect(function(err) {
+            if(err) return cb(err, null);
 
-          //handle connected client background errors by emitting event
-          //via the pg object and then removing errored client from the pool
-          client.on('error', function(e) {
-            pool.emit('error', e, client);
+            // Remove the noop error handler after a connection has been established.
+            client.removeListener('error', Function.prototype);
 
-            // If the client is already being destroyed, the error
-            // occurred during stream ending. Do not attempt to destroy
-            // the client again.
-            if (!client._destroying) {
-              pool.destroy(client);
-            }
-          });
+            //handle connected client background errors by emitting event
+            //via the pg object and then removing errored client from the pool
+            client.on('error', function(e) {
+              pool.emit('error', e, client);
 
-          // Remove connection from pool on disconnect
-          client.on('end', function(e) {
-            // Do not enter infinite loop between pool.destroy
-            // and client 'end' event...
-            if ( ! client._destroying ) {
+              // If the client is already being destroyed, the error
+              // occurred during stream ending. Do not attempt to destroy
+              // the client again.
+              if (!client._destroying) {
+                pool.destroy(client);
+              }
+            });
+
+            // Remove connection from pool on disconnect
+            client.on('end', function(e) {
+              // Do not enter infinite loop between pool.destroy
+              // and client 'end' event...
+              if ( ! client._destroying ) {
+                pool.destroy(client);
+              }
+            });
+            client.poolCount = 0;
+            return cb(null, client);
+          });
+        },
+        destroy: function(client) {
+          client._destroying = true;
+          client.poolCount = undefined;
+          client.end();
+        }
+      });
+      pools.all[name] = pool;
+      //mixin EventEmitter to pool
+      EventEmitter.call(pool);
+      for(var key in EventEmitter.prototype) {
+        if(EventEmitter.prototype.hasOwnProperty(key)) {
+          pool[key] = EventEmitter.prototype[key];
+        }
+      }
+      //monkey-patch with connect method
+      pool.connect = function(cb) {
+        var domain = process.domain;
+        pool.acquire(function(err, client) {
+          if(domain) {
+            cb = domain.bind(cb);
+          }
+          if(err)  return cb(err, null, function() {/*NOOP*/});
+          client.poolCount++;
+          cb(null, client, function(err) {
+            if(err) {
               pool.destroy(client);
+            } else {
+              pool.release(client);
             }
           });
-          client.poolCount = 0;
-          return cb(null, client);
         });
-      },
-      destroy: function(client) {
-        client._destroying = true;
-        client.poolCount = undefined;
-        client.end();
-      }
-    });
-    pools.all[name] = pool;
-    //mixin EventEmitter to pool
-    EventEmitter.call(pool);
-    for(var key in EventEmitter.prototype) {
-      if(EventEmitter.prototype.hasOwnProperty(key)) {
-        pool[key] = EventEmitter.prototype[key];
-      }
+      };
+      return pool;
     }
-    //monkey-patch with connect method
-    pool.connect = function(cb) {
-      var domain = process.domain;
-      pool.acquire(function(err, client) {
-        if(domain) {
-          cb = domain.bind(cb);
-        }
-        if(err)  return cb(err, null, function() {/*NOOP*/});
-        client.poolCount++;
-        cb(null, client, function(err) {
-          if(err) {
-            pool.destroy(client);
-          } else {
-            pool.release(client);
-          }
-        });
-      });
-    };
-    return pool;
-  }
-};
+  };
 
-module.exports = pools;
+  return pools;
+};

lib/query.js

@@ -146,11 +146,8 @@ Query.prototype.prepare = function(connection) {
     }, true);
   }
 
-  //TODO is there some better way to prepare values for the database?
   if(self.values) {
-    for(var i = 0, len = self.values.length; i < len; i++) {
-      self.values[i] = utils.prepareValue(self.values[i]);
-    }
+    self.values = self.values.map(utils.prepareValue);
   }
 
   //http://developer.postgresql.org/pgdocs/postgres/protocol-flow.html#PROTOCOL-FLOW-EXT-QUERY