All major and minor releases are briefly explained below.
For richer information consult the commit log on github with referenced pull requests.
We do not include break-fix version release in this file.
- Add support for passing secureOptions SSL config.
- Upgrade pg-types to 2.0.
- Add support for configurable query timeout on a client level.
- Add support for "bring your own promise"
- Better error message when passing
null
orundefined
toclient.query
. - Better error handling on queued queries.
- Add support for Uint8Array values.
- Add support for statement timeout.
- Pinned pg-pool and pg-types to a tighter semver range. This is likely not a noticeable change for you unless you were specifically installing older versions of those libraries for some reason, but making it a minor bump here just in case it could cause any confusion.
- Drop support for node <
4.x
. - Remove
pg.connect
pg.end
andpg.cancel
singleton methods. Client#connect(callback)
now returnsundefined
. It used to return an event emitter.- Upgrade pg-pool to
2.x
. - Upgrade pg-native to
2.x
. - Standardize error message fields between JS and native driver. The only breaking changes were in the native driver as its field names were brought into alignment with the existing JS driver field names.
- Result from multi-statement text queries such as
SELECT 1; SELECT 2;
are now returned as an array of results instead of a single result with 1 array containing rows from both queries.
Please see here for a migration guide
- Overhauled documentation: https://node-postgres.com.
- Add
Client#connect() => Promise<void>
andClient#end() => Promise<void>
calls. Promises are now returned from all async methods on clients if and only if no callback was supplied to the method. - Add
connectionTimeoutMillis
to pg-pool.
- Add support for parsing
replicationStart
messages.
- Add optional callback parameter to the pure JavaScript
client.end
method. The native client already supported this.
- Remove
pg.pools
. There is still a reference kept to the pools created & tracked bypg.connect
but it has been renamed, is considered private, and should not be used. Accessing this API directly was uncommon and was supposed to be private but was incorrectly documented on the wiki. Therefore, it is a breaking change of an (unintentionally) public interface to remove it by renaming it & making it private. Eventuallypg.connect
itself will be deprecated in favor of instantiating pools directly vianew pg.Pool()
so this property should become completely moot at some point. In the mean time...check out the new features...
- Replace internal pooling code with pg-pool. This is the first step in eventually deprecating and removing the singleton
pg.connect
. The pg-pool constructor is exported from node-postgres atrequire('pg').Pool
. It provides a backwards compatible interface withpg.connect
as well as a promise based interface & additional niceties.
You can now create an instance of a pool and don't have to rely on the pg
singleton for anything:
var pg = require('pg')
var pool = new pg.Pool()
// your friendly neighborhood pool interface, without the singleton
pool.connect(function(err, client, done) {
// ...
})
Promise support & other goodness lives now in pg-pool.
Please read the readme at pg-pool for the full api.
- Included support for tcp keep alive. Enable it as follows:
var client = new Client({ keepAlive: true });
This should help with backends incorrectly considering idle clients to be dead and prematurely disconnecting them.
- Make the query object returned from
client.query
implement the promise interface. This is the first step towards promisifying more of the node-postgres api.
Example:
var client = new Client();
client.connect();
client.query("SELECT $1::text as name", ["brianc"]).then(function(res) {
console.log("hello from", res.rows[0]);
client.end();
});
require('pg').native
now returns null if the native bindings cannot be found; previously, this threw an exception.
- better error message when passing
undefined
as a query parameter - support for
defaults.connectionString
- support for
returnToHead
being passed to generic pool
- Add option to parse JS date objects in query parameters as UTC
- Warn to
stderr
if a named query exceeds 63 characters which is the max length supported by postgres.
- Unpin
pg-types
semver. Allow it to float against[email protected]
.
- Support for additional error fields in postgres >= 9.3 if available.
- Allow type parser overrides on a per-client basis
- Make native bindings an optional install with
npm install pg-native
- No longer surround query result callback with
try/catch
block. - Remove built in COPY IN / COPY OUT support - better implementations provided by pg-copy-streams and pg-native
- Include support for (parsing JSONB)[brianc/node-pg-types#13] (supported in postgres 9.4)
- Include support for parsing boolean arrays
- Include port as connection parameter to unix sockets
- Better support for odd date parsing
- Add support for parsing date arrays
- Expose array parsers on pg.types
- Allow pool to be configured
- Add count of the number of times a client has been checked out from the pool
- Emit
end
frompg
object when a pool is drained
After some discussion it was decided node-postgres was non-compliant in how it was handling DATE results. They were being converted to UTC, but the PostgreSQL documentation specifies they should be returned in the client timezone. This is a breaking change, and if you use the date
type you might want to examine your code and make sure nothing is impacted.
[email protected] included changes to not convert large integers into their JavaScript number representation because of possibility for numeric precision loss. The same types in arrays were not taken into account. This fix applies the same type of type-coercion rules to arrays of those types, so there will be no more possible numeric loss on an array of very large int8s for example. This is a breaking change because now a return type from a query of int8[]
will contain string representations
of the integers. Use your favorite JavaScript bignum module to represent them without precision loss, or punch over the type converter to return the old style arrays again.
Single date
parameters were properly sent to the PostgreSQL server properly in local time, but an input array of dates was being changed into utc dates. This is a violation of what PostgreSQL expects. Small breaking change, but none-the-less something you should check out if you are inserting an array of dates.
This is a small change to bring the semantics of query more in line with other EventEmitters. The tests all passed after this change, but I suppose it could still be a breaking change in certain use cases. If you are doing clever things with the end
and error
events of a query object you might want to check to make sure its still behaving normally, though it is most likely not an issue.
The long & short of it is now any object you supply in the list of query values will be inspected for a .toPostgres
method. If the method is present it will be called and its result used as the raw text value sent to PostgreSQL for that value. This allows the same type of custom type coercion on query parameters as was previously afforded to query result values.
If domains are active node-postgres will honor them and do everything it can to ensure all callbacks are properly fired in the active domain. If you have tried to use domains with node-postgres (or many other modules which pool long lived event emitters) you may have run into an issue where the active domain changes before and after a callback. This has been a longstanding footgun within node-postgres and I am happy to get it fixed.
Avoids a scenario where your pool could fill up with disconnected & unusable clients.
To provide better documentation and a clearer explanation of how to override the query result parsing system we broke the type converters into their own module. There is still work around removing the 'global-ness' of the type converters so each query or connection can return types differently, but this is a good first step and allow a lot more obvious way to return int8 results as JavaScript numbers, for example
- Add support for application_name
- Add support for the password file
- Add better support for unix domain socket connections
- Add support for parsing JSON[] and UUID[] result types
- Use single row mode in native bindings when available [@rpedela]
- reduces memory consumption when handling row values in 'row' event
- Automatically bind buffer type parameters as binary [@eugeneware]
- Respect PGSSLMODE environment variable
- Ability to opt-in to int8 parsing via
pg.defaults.parseInt8 = true
- Use eval in the result set parser to increase performance
- Remove built-in support for binary Int64 parsing. Due to the low usage & required compiled dependency this will be pushed into a 3rd party add-on
- Add support for SSL connections in JavaScript driver
- this means you can connect to heroku postgres from your local machine without the native bindings!
- Add field metadata to result object
- Add ability for rows to be returned as arrays instead of objects
- Properly handle various PostgreSQL to JavaScript type conversions to avoid data loss:
PostgreSQL | [email protected] JavaScript | [email protected] JavaScript
--------------------------------|----------------
float4 | number (float) | string
float8 | number (float) | string
int8 | string | number (int)
numeric | string | number (float)
decimal | string | number (float)
For more information see brianc#353 If you are unhappy with these changes you can always override the built in type parsing fairly easily.
- Make client_encoding configurable and optional
- return field metadata on result object: access via result.fields[i].name/dataTypeID
- built in support for
JSON
data type for PostgreSQL Server @ v9.2.0 or greater
- remove deprecated functionality
- Callback function passed to
pg.connect
now requires 3 arguments - Client#pauseDrain() / Client#resumeDrain removed
- numeric, decimal, and float data types no longer parsed into float before being returned. Will be returned from query results as
String
- Callback function passed to
- client now emits
end
when disconnected from back-end server - if client is disconnected in the middle of a query, query receives an error
- add deprecation warnings in prep for v1.0
- fix read/write failures in native module under node v0.9.x