archive-gh-me/node-postgres
1
0
Fork 0
mirror of https://github.com/brianc/node-postgres.git synced 2025-12-08 20:16:25 +00:00
Code Issues Projects Releases Wiki Activity

More linting

Browse Source
This commit is contained in:
Brian Carlson 2024-05-30 15:48:56 -05:00
parent 2840d4a26f
commit 8ac7bd099f
29 changed files with 1041 additions and 1641 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
packages/pg-native/bench/index.js
View File

@ -1,52 +1,52 @@
var pg = require("pg").native;
var Native = require("../");
var pg = require('pg').native
var Native = require('../')
var warmup = function (fn, cb) {
var count = 0;
var max = 10;
var count = 0
var max = 10
var run = function (err) {
if (err) return cb(err);
if (err) return cb(err)
if (max >= count++) {
return fn(run);
return fn(run)
}
cb();
};
run();
};
cb()
}
run()
}
var native = Native();
native.connectSync();
var native = Native()
native.connectSync()
var queryText = "SELECT generate_series(0, 1000)";
var client = new pg.Client();
var queryText = 'SELECT generate_series(0, 1000)'
var client = new pg.Client()
client.connect(function () {
var pure = function (cb) {
client.query(queryText, function (err) {
if (err) throw err;
cb(err);
});
};
if (err) throw err
cb(err)
})
}
var nativeQuery = function (cb) {
native.query(queryText, function (err) {
if (err) throw err;
cb(err);
});
};
if (err) throw err
cb(err)
})
}
var run = function () {
var start = Date.now();
var start = Date.now()
warmup(pure, function () {
console.log("pure done", Date.now() - start);
start = Date.now();
console.log('pure done', Date.now() - start)
start = Date.now()
warmup(nativeQuery, function () {
console.log("native done", Date.now() - start);
});
});
};
console.log('native done', Date.now() - start)
})
})
}
setInterval(function () {
run();
}, 500);
});
run()
}, 500)
})

60
packages/pg-native/bench/leaks.js
View File

@ -1,50 +1,50 @@
var Client = require("../");
var async = require("async");
var Client = require('../')
var async = require('async')
var loop = function () {
var client = new Client();
var client = new Client()
var connect = function (cb) {
client.connect(cb);
};
client.connect(cb)
}
var simpleQuery = function (cb) {
client.query("SELECT NOW()", cb);
};
client.query('SELECT NOW()', cb)
}
var paramsQuery = function (cb) {
client.query("SELECT $1::text as name", ["Brian"], cb);
};
client.query('SELECT $1::text as name', ['Brian'], cb)
}
var prepared = function (cb) {
client.prepare("test", "SELECT $1::text as name", 1, function (err) {
if (err) return cb(err);
client.execute("test", ["Brian"], cb);
});
};
client.prepare('test', 'SELECT $1::text as name', 1, function (err) {
if (err) return cb(err)
client.execute('test', ['Brian'], cb)
})
}
var sync = function (cb) {
client.querySync("SELECT NOW()");
client.querySync("SELECT $1::text as name", ["Brian"]);
client.prepareSync("boom", "SELECT $1::text as name", 1);
client.executeSync("boom", ["Brian"]);
setImmediate(cb);
};
client.querySync('SELECT NOW()')
client.querySync('SELECT $1::text as name', ['Brian'])
client.prepareSync('boom', 'SELECT $1::text as name', 1)
client.executeSync('boom', ['Brian'])
setImmediate(cb)
}
var end = function (cb) {
client.end(cb);
};
client.end(cb)
}
var ops = [connect, simpleQuery, paramsQuery, prepared, sync, end];
var ops = [connect, simpleQuery, paramsQuery, prepared, sync, end]
var start = Date.now();
var start = Date.now()
async.series(ops, function (err) {
if (err) throw err;
console.log(Date.now() - start);
setImmediate(loop);
});
};
if (err) throw err
console.log(Date.now() - start)
setImmediate(loop)
})
}
// on my machine this will consume memory up to about 50 megs of ram
// and then stabalize at that point
loop();
loop()

340
packages/pg-native/index.js
View File

@ -1,332 +1,332 @@
var Libpq = require("libpq");
var EventEmitter = require("events").EventEmitter;
var util = require("util");
var assert = require("assert");
var types = require("pg-types");
var buildResult = require("./lib/build-result");
var CopyStream = require("./lib/copy-stream");
var Libpq = require('libpq')
var EventEmitter = require('events').EventEmitter
var util = require('util')
var assert = require('assert')
var types = require('pg-types')
var buildResult = require('./lib/build-result')
var CopyStream = require('./lib/copy-stream')
var Client = (module.exports = function (config) {
if (!(this instanceof Client)) {
return new Client(config);
return new Client(config)
}
config = config || {};
config = config || {}
EventEmitter.call(this);
this.pq = new Libpq();
this._reading = false;
this._read = this._read.bind(this);
EventEmitter.call(this)
this.pq = new Libpq()
this._reading = false
this._read = this._read.bind(this)
// allow custom type converstion to be passed in
this._types = config.types || types;
this._types = config.types || types
// allow config to specify returning results
// as an array of values instead of a hash
this.arrayMode = config.arrayMode || false;
this._resultCount = 0;
this._rows = undefined;
this._results = undefined;
this.arrayMode = config.arrayMode || false
this._resultCount = 0
this._rows = undefined
this._results = undefined
// lazy start the reader if notifications are listened for
// this way if you only run sync queries you wont block
// the event loop artificially
this.on("newListener", (event) => {
if (event !== "notification") return;
this._startReading();
});
this.on('newListener', (event) => {
if (event !== 'notification') return
this._startReading()
})
this.on("result", this._onResult.bind(this));
this.on("readyForQuery", this._onReadyForQuery.bind(this));
});
this.on('result', this._onResult.bind(this))
this.on('readyForQuery', this._onReadyForQuery.bind(this))
})
util.inherits(Client, EventEmitter);
util.inherits(Client, EventEmitter)
Client.prototype.connect = function (params, cb) {
this.pq.connect(params, cb);
};
this.pq.connect(params, cb)
}
Client.prototype.connectSync = function (params) {
this.pq.connectSync(params);
};
this.pq.connectSync(params)
}
Client.prototype.query = function (text, values, cb) {
var queryFn;
var queryFn
if (typeof values === "function") {
cb = values;
if (typeof values === 'function') {
cb = values
}
if (Array.isArray(values) && values.length > 0) {
queryFn = function () {
return self.pq.sendQueryParams(text, values);
};
return self.pq.sendQueryParams(text, values)
}
} else {
queryFn = function () {
return self.pq.sendQuery(text);
};
return self.pq.sendQuery(text)
}
}
var self = this;
var self = this
self._dispatchQuery(self.pq, queryFn, function (err) {
if (err) return cb(err);
if (err) return cb(err)
self._awaitResult(cb);
});
};
self._awaitResult(cb)
})
}
Client.prototype.prepare = function (statementName, text, nParams, cb) {
var self = this;
var self = this
var fn = function () {
return self.pq.sendPrepare(statementName, text, nParams);
};
return self.pq.sendPrepare(statementName, text, nParams)
}
self._dispatchQuery(self.pq, fn, function (err) {
if (err) return cb(err);
self._awaitResult(cb);
});
};
if (err) return cb(err)
self._awaitResult(cb)
})
}
Client.prototype.execute = function (statementName, parameters, cb) {
var self = this;
var self = this
var fn = function () {
return self.pq.sendQueryPrepared(statementName, parameters);
};
return self.pq.sendQueryPrepared(statementName, parameters)
}
self._dispatchQuery(self.pq, fn, function (err, rows) {
if (err) return cb(err);
self._awaitResult(cb);
});
};
if (err) return cb(err)
self._awaitResult(cb)
})
}
Client.prototype.getCopyStream = function () {
this.pq.setNonBlocking(true);
this._stopReading();
return new CopyStream(this.pq);
};
this.pq.setNonBlocking(true)
this._stopReading()
return new CopyStream(this.pq)
}
// cancel a currently executing query
Client.prototype.cancel = function (cb) {
assert(cb, "Callback is required");
assert(cb, 'Callback is required')
// result is either true or a string containing an error
var result = this.pq.cancel();
var result = this.pq.cancel()
return setImmediate(function () {
cb(result === true ? undefined : new Error(result));
});
};
cb(result === true ? undefined : new Error(result))
})
}
Client.prototype.querySync = function (text, values) {
if (values) {
this.pq.execParams(text, values);
this.pq.execParams(text, values)
} else {
this.pq.exec(text);
this.pq.exec(text)
}
throwIfError(this.pq);
const result = buildResult(this.pq, this._types, this.arrayMode);
return result.rows;
};
throwIfError(this.pq)
const result = buildResult(this.pq, this._types, this.arrayMode)
return result.rows
}
Client.prototype.prepareSync = function (statementName, text, nParams) {
this.pq.prepare(statementName, text, nParams);
throwIfError(this.pq);
};
this.pq.prepare(statementName, text, nParams)
throwIfError(this.pq)
}
Client.prototype.executeSync = function (statementName, parameters) {
this.pq.execPrepared(statementName, parameters);
throwIfError(this.pq);
return buildResult(this.pq, this._types, this.arrayMode).rows;
};
this.pq.execPrepared(statementName, parameters)
throwIfError(this.pq)
return buildResult(this.pq, this._types, this.arrayMode).rows
}
Client.prototype.escapeLiteral = function (value) {
return this.pq.escapeLiteral(value);
};
return this.pq.escapeLiteral(value)
}
Client.prototype.escapeIdentifier = function (value) {
return this.pq.escapeIdentifier(value);
};
return this.pq.escapeIdentifier(value)
}
// export the version number so we can check it in node-postgres
module.exports.version = require("./package.json").version;
module.exports.version = require('./package.json').version
Client.prototype.end = function (cb) {
this._stopReading();
this.pq.finish();
if (cb) setImmediate(cb);
};
this._stopReading()
this.pq.finish()
if (cb) setImmediate(cb)
}
Client.prototype._readError = function (message) {
var err = new Error(message || this.pq.errorMessage());
this.emit("error", err);
};
var err = new Error(message || this.pq.errorMessage())
this.emit('error', err)
}
Client.prototype._stopReading = function () {
if (!this._reading) return;
this._reading = false;
this.pq.stopReader();
this.pq.removeListener("readable", this._read);
};
if (!this._reading) return
this._reading = false
this.pq.stopReader()
this.pq.removeListener('readable', this._read)
}
Client.prototype._consumeQueryResults = function (pq) {
return buildResult(pq, this._types, this.arrayMode);
};
return buildResult(pq, this._types, this.arrayMode)
}
Client.prototype._emitResult = function (pq) {
var status = pq.resultStatus();
var status = pq.resultStatus()
switch (status) {
case "PGRES_FATAL_ERROR":
this._queryError = new Error(this.pq.resultErrorMessage());
break;
case 'PGRES_FATAL_ERROR':
this._queryError = new Error(this.pq.resultErrorMessage())
break
case "PGRES_TUPLES_OK":
case "PGRES_COMMAND_OK":
case "PGRES_EMPTY_QUERY":
const result = this._consumeQueryResults(this.pq);
this.emit("result", result);
break;
case 'PGRES_TUPLES_OK':
case 'PGRES_COMMAND_OK':
case 'PGRES_EMPTY_QUERY':
const result = this._consumeQueryResults(this.pq)
this.emit('result', result)
break
case "PGRES_COPY_OUT":
case "PGRES_COPY_BOTH": {
break;
case 'PGRES_COPY_OUT':
case 'PGRES_COPY_BOTH': {
break
}
default:
this._readError("unrecognized command status: " + status);
break;
this._readError('unrecognized command status: ' + status)
break
}
return status;
};
return status
}
// called when libpq is readable
Client.prototype._read = function () {
var pq = this.pq;
var pq = this.pq
// read waiting data from the socket
// e.g. clear the pending 'select'
if (!pq.consumeInput()) {
// if consumeInput returns false
// than a read error has been encountered
return this._readError();
return this._readError()
}
// check if there is still outstanding data
// if so, wait for it all to come in
if (pq.isBusy()) {
return;
return
}
// load our result object
while (pq.getResult()) {
const resultStatus = this._emitResult(this.pq);
const resultStatus = this._emitResult(this.pq)
// if the command initiated copy mode we need to break out of the read loop
// so a substream can begin to read copy data
if (resultStatus === "PGRES_COPY_BOTH" || resultStatus === "PGRES_COPY_OUT") {
break;
if (resultStatus === 'PGRES_COPY_BOTH' || resultStatus === 'PGRES_COPY_OUT') {
break
}
// if reading multiple results, sometimes the following results might cause
// a blocking read. in this scenario yield back off the reader until libpq is readable
if (pq.isBusy()) {
return;
return
}
}
this.emit("readyForQuery");
this.emit('readyForQuery')
var notice = this.pq.notifies();
var notice = this.pq.notifies()
while (notice) {
this.emit("notification", notice);
notice = this.pq.notifies();
this.emit('notification', notice)
notice = this.pq.notifies()
}
};
}
// ensures the client is reading and
// everything is set up for async io
Client.prototype._startReading = function () {
if (this._reading) return;
this._reading = true;
this.pq.on("readable", this._read);
this.pq.startReader();
};
if (this._reading) return
this._reading = true
this.pq.on('readable', this._read)
this.pq.startReader()
}
var throwIfError = function (pq) {
var err = pq.resultErrorMessage() || pq.errorMessage();
var err = pq.resultErrorMessage() || pq.errorMessage()
if (err) {
throw new Error(err);
throw new Error(err)
}
};
}
Client.prototype._awaitResult = function (cb) {
this._queryCallback = cb;
return this._startReading();
};
this._queryCallback = cb
return this._startReading()
}
// wait for the writable socket to drain
Client.prototype._waitForDrain = function (pq, cb) {
var res = pq.flush();
var res = pq.flush()
// res of 0 is success
if (res === 0) return cb();
if (res === 0) return cb()
// res of -1 is failure
if (res === -1) return cb(pq.errorMessage());
if (res === -1) return cb(pq.errorMessage())
// otherwise outgoing message didn't flush to socket
// wait for it to flush and try again
var self = this;
var self = this
// you cannot read & write on a socket at the same time
return pq.writable(function () {
self._waitForDrain(pq, cb);
});
};
self._waitForDrain(pq, cb)
})
}
// send an async query to libpq and wait for it to
// finish writing query text to the socket
Client.prototype._dispatchQuery = function (pq, fn, cb) {
this._stopReading();
var success = pq.setNonBlocking(true);
if (!success) return cb(new Error("Unable to set non-blocking to true"));
var sent = fn();
if (!sent) return cb(new Error(pq.errorMessage() || "Something went wrong dispatching the query"));
this._waitForDrain(pq, cb);
};
this._stopReading()
var success = pq.setNonBlocking(true)
if (!success) return cb(new Error('Unable to set non-blocking to true'))
var sent = fn()
if (!sent) return cb(new Error(pq.errorMessage() || 'Something went wrong dispatching the query'))
this._waitForDrain(pq, cb)
}
Client.prototype._onResult = function (result) {
if (this._resultCount === 0) {
this._results = result;
this._rows = result.rows;
this._results = result
this._rows = result.rows
} else if (this._resultCount === 1) {
this._results = [this._results, result];
this._rows = [this._rows, result.rows];
this._results = [this._results, result]
this._rows = [this._rows, result.rows]
} else {
this._results.push(result);
this._rows.push(result.rows);
this._results.push(result)
this._rows.push(result.rows)
}
this._resultCount++;
};
this._resultCount++
}
Client.prototype._onReadyForQuery = function () {
// remove instance callback
const cb = this._queryCallback;
this._queryCallback = undefined;
const cb = this._queryCallback
this._queryCallback = undefined
// remove instance query error
const err = this._queryError;
this._queryError = undefined;
const err = this._queryError
this._queryError = undefined
// remove instance rows
const rows = this._rows;
this._rows = undefined;
const rows = this._rows
this._rows = undefined
// remove instance results
const results = this._results;
this._results = undefined;
const results = this._results
this._results = undefined
this._resultCount = 0;
this._resultCount = 0
if (cb) {
cb(err, rows || [], results);
cb(err, rows || [], results)
}
};
}

66
packages/pg-native/lib/build-result.js
View File

@ -1,76 +1,76 @@
"use strict";
'use strict'
class Result {
constructor(types, arrayMode) {
this._types = types;
this._arrayMode = arrayMode;
this._types = types
this._arrayMode = arrayMode
this.command = undefined;
this.rowCount = undefined;
this.fields = [];
this.rows = [];
this.command = undefined
this.rowCount = undefined
this.fields = []
this.rows = []
}
consumeCommand(pq) {
this.command = pq.cmdStatus().split(" ")[0];
this.rowCount = parseInt(pq.cmdTuples(), 10);
this.command = pq.cmdStatus().split(' ')[0]
this.rowCount = parseInt(pq.cmdTuples(), 10)
}
consumeFields(pq) {
const nfields = pq.nfields();
const nfields = pq.nfields()
for (var x = 0; x < nfields; x++) {
this.fields.push({
name: pq.fname(x),
dataTypeID: pq.ftype(x),
});
})
}
}
consumeRows(pq) {
const tupleCount = pq.ntuples();
const tupleCount = pq.ntuples()
for (var i = 0; i < tupleCount; i++) {
const row = this._arrayMode ? this.consumeRowAsArray(pq, i) : this.consumeRowAsObject(pq, i);
this.rows.push(row);
const row = this._arrayMode ? this.consumeRowAsArray(pq, i) : this.consumeRowAsObject(pq, i)
this.rows.push(row)
}
}
consumeRowAsObject(pq, rowIndex) {
const row = {};
const row = {}
for (var j = 0; j < this.fields.length; j++) {
const value = this.readValue(pq, rowIndex, j);
row[this.fields[j].name] = value;
const value = this.readValue(pq, rowIndex, j)
row[this.fields[j].name] = value
}
return row;
return row
}
consumeRowAsArray(pq, rowIndex) {
const row = [];
const row = []
for (var j = 0; j < this.fields.length; j++) {
const value = this.readValue(pq, rowIndex, j);
row.push(value);
const value = this.readValue(pq, rowIndex, j)
row.push(value)
}
return row;
return row
}
readValue(pq, rowIndex, colIndex) {
var rawValue = pq.getvalue(rowIndex, colIndex);
if (rawValue === "") {
var rawValue = pq.getvalue(rowIndex, colIndex)
if (rawValue === '') {
if (pq.getisnull(rowIndex, colIndex)) {
return null;
return null
}
}
const dataTypeId = this.fields[colIndex].dataTypeID;
return this._types.getTypeParser(dataTypeId)(rawValue);
const dataTypeId = this.fields[colIndex].dataTypeID
return this._types.getTypeParser(dataTypeId)(rawValue)
}
}
function buildResult(pq, types, arrayMode) {
const result = new Result(types, arrayMode);
result.consumeCommand(pq);
result.consumeFields(pq);
result.consumeRows(pq);
const result = new Result(types, arrayMode)
result.consumeCommand(pq)
result.consumeFields(pq)
result.consumeRows(pq)
return result;
return result
}
module.exports = buildResult;
module.exports = buildResult

138
packages/pg-native/lib/copy-stream.js
View File

@ -1,42 +1,42 @@
var Duplex = require("stream").Duplex;
var Writable = require("stream").Writable;
var util = require("util");
var Duplex = require('stream').Duplex
var Writable = require('stream').Writable
var util = require('util')
var CopyStream = (module.exports = function (pq, options) {
Duplex.call(this, options);
this.pq = pq;
this._reading = false;
});
Duplex.call(this, options)
this.pq = pq
this._reading = false
})
util.inherits(CopyStream, Duplex);
util.inherits(CopyStream, Duplex)
// writer methods
CopyStream.prototype._write = function (chunk, encoding, cb) {
var result = this.pq.putCopyData(chunk);
var result = this.pq.putCopyData(chunk)
// sent successfully
if (result === 1) return cb();
if (result === 1) return cb()
// error
if (result === -1) return cb(new Error(this.pq.errorMessage()));
if (result === -1) return cb(new Error(this.pq.errorMessage()))
// command would block. wait for writable and call again.
var self = this;
var self = this
this.pq.writable(function () {
self._write(chunk, encoding, cb);
});
};
self._write(chunk, encoding, cb)
})
}
CopyStream.prototype.end = function () {
var args = Array.prototype.slice.call(arguments, 0);
var self = this;
var args = Array.prototype.slice.call(arguments, 0)
var self = this
var callback = args.pop();
var callback = args.pop()
if (args.length) {
this.write(args[0]);
this.write(args[0])
}
var result = this.pq.putCopyEnd();
var result = this.pq.putCopyEnd()
// sent successfully
if (result === 1) {
@ -44,19 +44,19 @@ CopyStream.prototype.end = function () {
// "parent" writable class so we can emit 'finish' and
// all that jazz
return consumeResults(this.pq, function (err, res) {
Writable.prototype.end.call(self);
Writable.prototype.end.call(self)
// handle possible passing of callback to end method
if (callback) {
callback(err);
callback(err)
}
});
})
}
// error
if (result === -1) {
var err = new Error(this.pq.errorMessage());
return this.emit("error", err);
var err = new Error(this.pq.errorMessage())
return this.emit('error', err)
}
// command would block. wait for writable and call end again
@ -64,92 +64,92 @@ CopyStream.prototype.end = function () {
// we already sent them to possible this.write the first time
// we called end
return this.pq.writable(function () {
return self.end.apply(self, callback);
});
};
return self.end.apply(self, callback)
})
}
// reader methods
CopyStream.prototype._consumeBuffer = function (cb) {
var result = this.pq.getCopyData(true);
var result = this.pq.getCopyData(true)
if (result instanceof Buffer) {
return setImmediate(function () {
cb(null, result);
});
cb(null, result)
})
}
if (result === -1) {
// end of stream
return cb(null, null);
return cb(null, null)
}
if (result === 0) {
var self = this;
this.pq.once("readable", function () {
self.pq.stopReader();
self.pq.consumeInput();
self._consumeBuffer(cb);
});
return this.pq.startReader();
var self = this
this.pq.once('readable', function () {
self.pq.stopReader()
self.pq.consumeInput()
self._consumeBuffer(cb)
})
return this.pq.startReader()
}
cb(new Error("Unrecognized read status: " + result));
};
cb(new Error('Unrecognized read status: ' + result))
}
CopyStream.prototype._read = function (size) {
if (this._reading) return;
this._reading = true;
if (this._reading) return
this._reading = true
// console.log('read begin');
var self = this;
var self = this
this._consumeBuffer(function (err, buffer) {
self._reading = false;
self._reading = false
if (err) {
return self.emit("error", err);
return self.emit('error', err)
}
if (buffer === false) {
// nothing to read for now, return
return;
return
}
self.push(buffer);
});
};
self.push(buffer)
})
}
var consumeResults = function (pq, cb) {
var cleanup = function () {
pq.removeListener("readable", onReadable);
pq.stopReader();
};
pq.removeListener('readable', onReadable)
pq.stopReader()
}
var readError = function (message) {
cleanup();
return cb(new Error(message || pq.errorMessage()));
};
cleanup()
return cb(new Error(message || pq.errorMessage()))
}
var onReadable = function () {
// read waiting data from the socket
// e.g. clear the pending 'select'
if (!pq.consumeInput()) {
return readError();
return readError()
}
// check if there is still outstanding data
// if so, wait for it all to come in
if (pq.isBusy()) {
return;
return
}
// load our result object
pq.getResult();
pq.getResult()
// "read until results return null"
// or in our case ensure we only have one result
if (pq.getResult() && pq.resultStatus() !== "PGRES_COPY_OUT") {
return readError("Only one result at a time is accepted");
if (pq.getResult() && pq.resultStatus() !== 'PGRES_COPY_OUT') {
return readError('Only one result at a time is accepted')
}
if (pq.resultStatus() === "PGRES_FATAL_ERROR") {
return readError();
if (pq.resultStatus() === 'PGRES_FATAL_ERROR') {
return readError()
}
cleanup();
return cb(null);
};
pq.on("readable", onReadable);
pq.startReader();
};
cleanup()
return cb(null)
}
pq.on('readable', onReadable)
pq.startReader()
}

10
packages/pg-native/package.json
View File

@ -29,21 +29,11 @@
"devDependencies": {
"async": "^0.9.0",
"concat-stream": "^1.4.6",
"eslint": "4.2.0",
"eslint-config-standard": "10.2.1",
"eslint-plugin-import": "2.7.0",
"eslint-plugin-node": "5.1.0",
"eslint-plugin-promise": "3.5.0",
"eslint-plugin-standard": "3.0.1",
"generic-pool": "^2.1.1",
"lodash": "^2.4.1",
"mocha": "3.4.2",
"node-gyp": ">=10.x",
"okay": "^0.3.0",
"pg": "*",
"semver": "^4.1.0"
},
"prettier": {
"printWidth": 200
}
}

44
packages/pg-native/test/array-mode.js
View File

@ -1,25 +1,25 @@
var Client = require("../");
var assert = require("assert");
var Client = require('../')
var assert = require('assert')
describe("client with arrayMode", function () {
it("returns result as array", function (done) {
var client = new Client({ arrayMode: true });
client.connectSync();
client.querySync("CREATE TEMP TABLE blah(name TEXT)");
client.querySync("INSERT INTO blah (name) VALUES ($1)", ["brian"]);
client.querySync("INSERT INTO blah (name) VALUES ($1)", ["aaron"]);
var rows = client.querySync("SELECT * FROM blah");
assert.equal(rows.length, 2);
var row = rows[0];
assert.equal(row.length, 1);
assert.equal(row[0], "brian");
assert.equal(rows[1][0], "aaron");
describe('client with arrayMode', function () {
it('returns result as array', function (done) {
var client = new Client({ arrayMode: true })
client.connectSync()
client.querySync('CREATE TEMP TABLE blah(name TEXT)')
client.querySync('INSERT INTO blah (name) VALUES ($1)', ['brian'])
client.querySync('INSERT INTO blah (name) VALUES ($1)', ['aaron'])
var rows = client.querySync('SELECT * FROM blah')
assert.equal(rows.length, 2)
var row = rows[0]
assert.equal(row.length, 1)
assert.equal(row[0], 'brian')
assert.equal(rows[1][0], 'aaron')
client.query("SELECT 'brian', null", function (err, res) {
assert.ifError(err);
assert.strictEqual(res[0][0], "brian");
assert.strictEqual(res[0][1], null);
client.end(done);
});
});
});
assert.ifError(err)
assert.strictEqual(res[0][0], 'brian')
assert.strictEqual(res[0][1], null)
client.end(done)
})
})
})

104
packages/pg-native/test/async-workflow.js
View File

@ -1,80 +1,80 @@
var Client = require("../");
var ok = require("okay");
var assert = require("assert");
var concat = require("concat-stream");
var Client = require('../')
var ok = require('okay')
var assert = require('assert')
var concat = require('concat-stream')
describe("async workflow", function () {
describe('async workflow', function () {
before(function (done) {
this.client = new Client();
this.client.connect(done);
});
this.client = new Client()
this.client.connect(done)
})
var echoParams = function (params, cb) {
this.client.query(
"SELECT $1::text as first, $2::text as second",
'SELECT $1::text as first, $2::text as second',
params,
ok(cb, function (rows) {
checkParams(params, rows);
cb(null, rows);
}),
);
};
checkParams(params, rows)
cb(null, rows)
})
)
}
var checkParams = function (params, rows) {
assert.equal(rows.length, 1);
assert.equal(rows[0].first, params[0]);
assert.equal(rows[0].second, params[1]);
};
assert.equal(rows.length, 1)
assert.equal(rows[0].first, params[0])
assert.equal(rows[0].second, params[1])
}
it("sends async query", function (done) {
var params = ["one", "two"];
echoParams.call(this, params, done);
});
it('sends async query', function (done) {
var params = ['one', 'two']
echoParams.call(this, params, done)
})
it("sends multiple async queries", function (done) {
var self = this;
var params = ["bang", "boom"];
it('sends multiple async queries', function (done) {
var self = this
var params = ['bang', 'boom']
echoParams.call(
this,
params,
ok(done, function (rows) {
echoParams.call(self, params, done);
}),
);
});
echoParams.call(self, params, done)
})
)
})
it("sends an async query, copies in, copies out, and sends another query", function (done) {
var self = this;
this.client.querySync("CREATE TEMP TABLE test(name text, age int)");
it('sends an async query, copies in, copies out, and sends another query', function (done) {
var self = this
this.client.querySync('CREATE TEMP TABLE test(name text, age int)')
this.client.query(
"INSERT INTO test(name, age) VALUES('brian', 32)",
ok(done, function () {
self.client.querySync("COPY test FROM stdin");
var input = self.client.getCopyStream();
input.write(Buffer.from("Aaron\t30\n", "utf8"));
self.client.querySync('COPY test FROM stdin')
var input = self.client.getCopyStream()
input.write(Buffer.from('Aaron\t30\n', 'utf8'))
input.end(function () {
self.client.query(
"SELECT COUNT(*) FROM test",
'SELECT COUNT(*) FROM test',
ok(done, function (rows) {
assert.equal(rows.length, 1);
assert.equal(rows.length, 1)
self.client.query(
"COPY test TO stdout",
'COPY test TO stdout',
ok(done, function () {
var output = self.client.getCopyStream();
var output = self.client.getCopyStream()
// pump the stream
output.read();
output.read()
output.pipe(
concat(function (res) {
done();
}),
);
}),
);
}),
);
});
}),
);
});
});
done()
})
)
})
)
})
)
})
})
)
})
})

52
packages/pg-native/test/cancel.js
View File

@ -1,32 +1,32 @@
var Client = require("../");
var assert = require("assert");
var Client = require('../')
var assert = require('assert')
describe("cancel query", function () {
it("works", function (done) {
var client = new Client();
client.connectSync();
client.query("SELECT pg_sleep(100);", function (err) {
assert(err instanceof Error);
client.end(done);
});
describe('cancel query', function () {
it('works', function (done) {
var client = new Client()
client.connectSync()
client.query('SELECT pg_sleep(100);', function (err) {
assert(err instanceof Error)
client.end(done)
})
client.cancel(function (err) {
assert.ifError(err);
});
});
assert.ifError(err)
})
})
it("does not raise error if no active query", function (done) {
var client = new Client();
client.connectSync();
it('does not raise error if no active query', function (done) {
var client = new Client()
client.connectSync()
client.cancel(function (err) {
assert.ifError(err);
done();
});
});
assert.ifError(err)
done()
})
})
it("raises error if client is not connected", function (done) {
it('raises error if client is not connected', function (done) {
new Client().cancel(function (err) {
assert(err, "should raise an error when not connected");
done();
});
});
});
assert(err, 'should raise an error when not connected')
done()
})
})
})

32
packages/pg-native/test/connection-errors.js
View File

@ -1,18 +1,18 @@
"use strict";
'use strict'
var Client = require("../");
var assert = require("assert");
var Client = require('../')
var assert = require('assert')
describe("connection errors", function () {
it("raise error events", function (done) {
var client = new Client();
client.connectSync();
client.query("SELECT pg_terminate_backend(pg_backend_pid())", assert.fail);
client.on("error", function (err) {
assert(err);
assert.strictEqual(client.pq.resultErrorFields().sqlState, "57P01");
client.end();
done();
});
});
});
describe('connection errors', function () {
it('raise error events', function (done) {
var client = new Client()
client.connectSync()
client.query('SELECT pg_terminate_backend(pg_backend_pid())', assert.fail)
client.on('error', function (err) {
assert(err)
assert.strictEqual(client.pq.resultErrorFields().sqlState, '57P01')
client.end()
done()
})
})
})

38
packages/pg-native/test/connection.js
View File

@ -1,23 +1,23 @@
var Client = require("../");
var assert = require("assert");
var Client = require('../')
var assert = require('assert')
describe("connection error", function () {
it("doesnt segfault", function (done) {
var client = new Client();
client.connect("asldgsdgasgdasdg", function (err) {
assert(err);
describe('connection error', function () {
it('doesnt segfault', function (done) {
var client = new Client()
client.connect('asldgsdgasgdasdg', function (err) {
assert(err)
// calling error on a closed client was segfaulting
client.end();
done();
});
});
});
client.end()
done()
})
})
})
describe("reading while not connected", function () {
it("does not seg fault but does throw execption", function () {
var client = new Client();
describe('reading while not connected', function () {
it('does not seg fault but does throw execption', function () {
var client = new Client()
assert.throws(function () {
client.on("notification", function (msg) {});
});
});
});
client.on('notification', function (msg) {})
})
})
})

80
packages/pg-native/test/copy-from.js
View File

@ -1,47 +1,47 @@
var assert = require("assert");
var Client = require("../");
var assert = require('assert')
var Client = require('../')
describe("COPY FROM", function () {
describe('COPY FROM', function () {
before(function (done) {
this.client = Client();
this.client.connect(done);
});
this.client = Client()
this.client.connect(done)
})
after(function (done) {
this.client.end(done);
});
this.client.end(done)
})
it("works", function (done) {
var client = this.client;
this.client.querySync("CREATE TEMP TABLE blah(name text, age int)");
this.client.querySync("COPY blah FROM stdin");
var stream = this.client.getCopyStream();
stream.write(Buffer.from("Brian\t32\n", "utf8"));
stream.write(Buffer.from("Aaron\t30\n", "utf8"));
stream.write(Buffer.from("Shelley\t28\n", "utf8"));
stream.end();
it('works', function (done) {
var client = this.client
this.client.querySync('CREATE TEMP TABLE blah(name text, age int)')
this.client.querySync('COPY blah FROM stdin')
var stream = this.client.getCopyStream()
stream.write(Buffer.from('Brian\t32\n', 'utf8'))
stream.write(Buffer.from('Aaron\t30\n', 'utf8'))
stream.write(Buffer.from('Shelley\t28\n', 'utf8'))
stream.end()
stream.once("finish", function () {
var rows = client.querySync("SELECT COUNT(*) FROM blah");
assert.equal(rows.length, 1);
assert.equal(rows[0].count, 3);
done();
});
});
stream.once('finish', function () {
var rows = client.querySync('SELECT COUNT(*) FROM blah')
assert.equal(rows.length, 1)
assert.equal(rows[0].count, 3)
done()
})
})
it("works with a callback passed to end", function (done) {
var client = this.client;
this.client.querySync("CREATE TEMP TABLE boom(name text, age int)");
this.client.querySync("COPY boom FROM stdin");
var stream = this.client.getCopyStream();
stream.write(Buffer.from("Brian\t32\n", "utf8"));
stream.write(Buffer.from("Aaron\t30\n", "utf8"), function () {
stream.end(Buffer.from("Shelley\t28\n", "utf8"), function () {
var rows = client.querySync("SELECT COUNT(*) FROM boom");
assert.equal(rows.length, 1);
assert.equal(rows[0].count, 3);
done();
});
});
});
});
it('works with a callback passed to end', function (done) {
var client = this.client
this.client.querySync('CREATE TEMP TABLE boom(name text, age int)')
this.client.querySync('COPY boom FROM stdin')
var stream = this.client.getCopyStream()
stream.write(Buffer.from('Brian\t32\n', 'utf8'))
stream.write(Buffer.from('Aaron\t30\n', 'utf8'), function () {
stream.end(Buffer.from('Shelley\t28\n', 'utf8'), function () {
var rows = client.querySync('SELECT COUNT(*) FROM boom')
assert.equal(rows.length, 1)
assert.equal(rows[0].count, 3)
done()
})
})
})
})

52
packages/pg-native/test/copy-to.js
View File

@ -1,35 +1,35 @@
var assert = require("assert");
var Client = require("../");
var concat = require("concat-stream");
var _ = require("lodash");
var assert = require('assert')
var Client = require('../')
var concat = require('concat-stream')
var _ = require('lodash')
describe("COPY TO", function () {
describe('COPY TO', function () {
before(function (done) {
this.client = Client();
this.client.connect(done);
});
this.client = Client()
this.client.connect(done)
})
after(function (done) {
this.client.end(done);
});
this.client.end(done)
})
it("works - basic check", function (done) {
var limit = 1000;
var qText = "COPY (SELECT * FROM generate_series(0, " + (limit - 1) + ")) TO stdout";
var self = this;
it('works - basic check', function (done) {
var limit = 1000
var qText = 'COPY (SELECT * FROM generate_series(0, ' + (limit - 1) + ')) TO stdout'
var self = this
this.client.query(qText, function (err) {
if (err) return done(err);
var stream = self.client.getCopyStream();
if (err) return done(err)
var stream = self.client.getCopyStream()
// pump the stream for node v0.11.x
stream.read();
stream.read()
stream.pipe(
concat(function (buff) {
var res = buff.toString("utf8");
var expected = _.range(0, limit).join("\n") + "\n";
assert.equal(res, expected);
done();
}),
);
});
});
});
var res = buff.toString('utf8')
var expected = _.range(0, limit).join('\n') + '\n'
assert.equal(res, expected)
done()
})
)
})
})
})

36
packages/pg-native/test/custom-types.js
View File

@ -1,27 +1,27 @@
var Client = require("../");
var ok = require("okay");
var assert = require("assert");
var Client = require('../')
var ok = require('okay')
var assert = require('assert')
describe("Custom type parser", function () {
it("is used by client", function (done) {
describe('Custom type parser', function () {
it('is used by client', function (done) {
var client = new Client({
types: {
getTypeParser: function () {
return function () {
return "blah";
};
return 'blah'
}
},
},
});
client.connectSync();
var rows = client.querySync("SELECT NOW() AS when");
assert.equal(rows[0].when, "blah");
})
client.connectSync()
var rows = client.querySync('SELECT NOW() AS when')
assert.equal(rows[0].when, 'blah')
client.query(
"SELECT NOW() as when",
'SELECT NOW() as when',
ok(function (rows) {
assert.equal(rows[0].when, "blah");
client.end(done);
}),
);
});
});
assert.equal(rows[0].when, 'blah')
client.end(done)
})
)
})
})

50
packages/pg-native/test/domains.js
View File

@ -1,32 +1,32 @@
var Client = require("../");
var assert = require("assert");
var Client = require('../')
var assert = require('assert')
var checkDomain = function (domain, when) {
assert(process.domain, "Domain was lost after " + when);
assert.strictEqual(process.domain, domain, "Domain switched after " + when);
};
assert(process.domain, 'Domain was lost after ' + when)
assert.strictEqual(process.domain, domain, 'Domain switched after ' + when)
}
describe("domains", function (done) {
it("remains bound after a query", function (done) {
describe('domains', function (done) {
it('remains bound after a query', function (done) {
var domain = require('domain').create() // eslint-disable-line
domain.run(function () {
var client = new Client();
var client = new Client()
client.connect(function () {
checkDomain(domain, "connection");
client.query("SELECT NOW()", function () {
checkDomain(domain, "query");
client.prepare("testing", "SELECT NOW()", 0, function () {
checkDomain(domain, "prepare");
client.execute("testing", [], function () {
checkDomain(domain, "execute");
checkDomain(domain, 'connection')
client.query('SELECT NOW()', function () {
checkDomain(domain, 'query')
client.prepare('testing', 'SELECT NOW()', 0, function () {
checkDomain(domain, 'prepare')
client.execute('testing', [], function () {
checkDomain(domain, 'execute')
client.end(function () {
checkDomain(domain, "end");
done();
});
});
});
});
});
});
});
});
checkDomain(domain, 'end')
done()
})
})
})
})
})
})
})
})

30
packages/pg-native/test/empty-query.js
View File

@ -1,16 +1,16 @@
var Client = require("../");
var assert = require("assert");
var Client = require('../')
var assert = require('assert')
describe("empty query", () => {
it("has field metadata in result", (done) => {
const client = new Client();
client.connectSync();
client.query("SELECT NOW() as now LIMIT 0", (err, rows, res) => {
assert(!err);
assert.equal(rows.length, 0);
assert(Array.isArray(res.fields));
assert.equal(res.fields.length, 1);
client.end(done);
});
});
});
describe('empty query', () => {
it('has field metadata in result', (done) => {
const client = new Client()
client.connectSync()
client.query('SELECT NOW() as now LIMIT 0', (err, rows, res) => {
assert(!err)
assert.equal(rows.length, 0)
assert(Array.isArray(res.fields))
assert.equal(res.fields.length, 1)
client.end(done)
})
})
})

38
packages/pg-native/test/huge-query.js
View File

@ -1,27 +1,27 @@
var Client = require("../");
var assert = require("assert");
var Client = require('../')
var assert = require('assert')
describe("huge async query", function () {
describe('huge async query', function () {
before(function (done) {
this.client = Client();
this.client.connect(done);
});
this.client = Client()
this.client.connect(done)
})
after(function (done) {
this.client.end(done);
});
this.client.end(done)
})
it("works", function (done) {
var params = [""];
var len = 100000;
it('works', function (done) {
var params = ['']
var len = 100000
for (var i = 0; i < len; i++) {
params[0] += "A";
params[0] += 'A'
}
var qText = "SELECT '" + params[0] + "'::text as my_text";
var qText = "SELECT '" + params[0] + "'::text as my_text"
this.client.query(qText, function (err, rows) {
if (err) return done(err);
assert.equal(rows[0].my_text.length, len);
done();
});
});
});
if (err) return done(err)
assert.equal(rows[0].my_text.length, len)
done()
})
})
})

58
packages/pg-native/test/index.js
View File

@ -1,36 +1,36 @@
var Client = require("../");
var assert = require("assert");
var Client = require('../')
var assert = require('assert')
describe("connection", function () {
it("works", function (done) {
Client().connect(done);
});
describe('connection', function () {
it('works', function (done) {
Client().connect(done)
})
it("connects with args", function (done) {
Client().connect("host=localhost", done);
});
it('connects with args', function (done) {
Client().connect('host=localhost', done)
})
it("errors out with bad connection args", function (done) {
Client().connect("host=asldkfjasdf", function (err) {
assert(err, "should raise an error for bad host");
done();
});
});
});
it('errors out with bad connection args', function (done) {
Client().connect('host=asldkfjasdf', function (err) {
assert(err, 'should raise an error for bad host')
done()
})
})
})
describe("connectSync", function () {
it("works without args", function () {
Client().connectSync();
});
describe('connectSync', function () {
it('works without args', function () {
Client().connectSync()
})
it("works with args", function () {
var args = "host=" + (process.env.PGHOST || "localhost");
Client().connectSync(args);
});
it('works with args', function () {
var args = 'host=' + (process.env.PGHOST || 'localhost')
Client().connectSync(args)
})
it("throws if bad host", function () {
it('throws if bad host', function () {
assert.throws(function () {
Client().connectSync("host=laksdjfdsf");
});
});
});
Client().connectSync('host=laksdjfdsf')
})
})
})

44
packages/pg-native/test/load.js
View File

@ -1,30 +1,30 @@
var Client = require("../");
var async = require("async");
var ok = require("okay");
var Client = require('../')
var async = require('async')
var ok = require('okay')
var execute = function (x, done) {
var client = new Client();
client.connectSync();
var client = new Client()
client.connectSync()
var query = function (n, cb) {
client.query("SELECT $1::int as num", [n], function (err) {
cb(err);
});
};
client.query('SELECT $1::int as num', [n], function (err) {
cb(err)
})
}
return async.timesSeries(
5,
query,
ok(done, function () {
client.end();
done();
}),
);
};
describe("Load tests", function () {
it("single client and many queries", function (done) {
async.times(1, execute, done);
});
client.end()
done()
})
)
}
describe('Load tests', function () {
it('single client and many queries', function (done) {
async.times(1, execute, done)
})
it("multiple client and many queries", function (done) {
async.times(20, execute, done);
});
});
it('multiple client and many queries', function (done) {
async.times(20, execute, done)
})
})

84
packages/pg-native/test/many-connections.js
View File

@ -1,57 +1,57 @@
var Client = require("../");
var async = require("async");
var ok = require("okay");
var bytes = require("crypto").pseudoRandomBytes;
var Client = require('../')
var async = require('async')
var ok = require('okay')
var bytes = require('crypto').pseudoRandomBytes
describe("many connections", function () {
describe("async", function () {
describe('many connections', function () {
describe('async', function () {
var test = function (count, times) {
it("connecting " + count + " clients " + times, function (done) {
this.timeout(200000);
it('connecting ' + count + ' clients ' + times, function (done) {
this.timeout(200000)
var connectClient = function (n, cb) {
var client = new Client();
var client = new Client()
client.connect(
ok(cb, function () {
bytes(
1000,
ok(cb, function (chunk) {
client.query(
"SELECT $1::text as txt",
[chunk.toString("base64")],
'SELECT $1::text as txt',
[chunk.toString('base64')],
ok(cb, function (rows) {
client.end(cb);
}),
);
}),
);
}),
);
};
client.end(cb)
})
)
})
)
})
)
}
var run = function (n, cb) {
async.times(count, connectClient, cb);
};
async.times(count, connectClient, cb)
}
async.timesSeries(times, run, done);
});
};
async.timesSeries(times, run, done)
})
}
test(1, 1);
test(1, 1);
test(1, 1);
test(5, 5);
test(5, 5);
test(5, 5);
test(5, 5);
test(10, 10);
test(10, 10);
test(10, 10);
test(20, 20);
test(20, 20);
test(20, 20);
test(30, 10);
test(30, 10);
test(30, 10);
});
});
test(1, 1)
test(1, 1)
test(1, 1)
test(5, 5)
test(5, 5)
test(5, 5)
test(5, 5)
test(10, 10)
test(10, 10)
test(10, 10)
test(20, 20)
test(20, 20)
test(20, 20)
test(30, 10)
test(30, 10)
test(30, 10)
})
})

38
packages/pg-native/test/many-errors.js
View File

@ -1,26 +1,26 @@
var Client = require("../");
var async = require("async");
var assert = require("assert");
var Client = require('../')
var async = require('async')
var assert = require('assert')
describe("many errors", function () {
it("functions properly without segfault", function (done) {
describe('many errors', function () {
it('functions properly without segfault', function (done) {
var throwError = function (n, cb) {
var client = new Client();
client.connectSync();
var client = new Client()
client.connectSync()
var doIt = function (n, cb) {
client.query("select asdfiasdf", function (err) {
assert(err, "bad query should emit an error");
cb(null);
});
};
client.query('select asdfiasdf', function (err) {
assert(err, 'bad query should emit an error')
cb(null)
})
}
async.timesSeries(10, doIt, function (err) {
if (err) return cb(err);
client.end(cb);
});
};
if (err) return cb(err)
client.end(cb)
})
}
async.times(10, throwError, done);
});
});
async.times(10, throwError, done)
})
})

64
packages/pg-native/test/multiple-queries.js
View File

@ -1,41 +1,41 @@
var Client = require("../");
var assert = require("assert");
var Client = require('../')
var assert = require('assert')
describe("multiple commands in a single query", function () {
describe('multiple commands in a single query', function () {
before(function (done) {
this.client = new Client();
this.client.connect(done);
});
this.client = new Client()
this.client.connect(done)
})
after(function (done) {
this.client.end(done);
});
this.client.end(done)
})
it("all execute to completion", function (done) {
it('all execute to completion', function (done) {
this.client.query("SELECT '10'::int as num; SELECT 'brian'::text as name", function (err, rows) {
assert.ifError(err);
assert.equal(rows.length, 2, "should return two sets rows");
assert.equal(rows[0][0].num, "10");
assert.equal(rows[1][0].name, "brian");
done();
});
});
assert.ifError(err)
assert.equal(rows.length, 2, 'should return two sets rows')
assert.equal(rows[0][0].num, '10')
assert.equal(rows[1][0].name, 'brian')
done()
})
})
it("inserts and reads at once", function (done) {
var txt = "CREATE TEMP TABLE boom(age int);";
txt += "INSERT INTO boom(age) VALUES(10);";
txt += "SELECT * FROM boom;";
it('inserts and reads at once', function (done) {
var txt = 'CREATE TEMP TABLE boom(age int);'
txt += 'INSERT INTO boom(age) VALUES(10);'
txt += 'SELECT * FROM boom;'
this.client.query(txt, function (err, rows, results) {
assert.ifError(err);
assert.equal(rows.length, 3);
assert.equal(rows[0].length, 0);
assert.equal(rows[1].length, 0);
assert.equal(rows[2][0].age, 10);
assert.ifError(err)
assert.equal(rows.length, 3)
assert.equal(rows[0].length, 0)
assert.equal(rows[1].length, 0)
assert.equal(rows[2][0].age, 10)
assert.equal(results[0].command, "CREATE");
assert.equal(results[1].command, "INSERT");
assert.equal(results[2].command, "SELECT");
done();
});
});
});
assert.equal(results[0].command, 'CREATE')
assert.equal(results[1].command, 'INSERT')
assert.equal(results[2].command, 'SELECT')
done()
})
})
})

38
packages/pg-native/test/multiple-statement-results.js
View File

@ -1,28 +1,28 @@
var Client = require("../");
var assert = require("assert");
var Client = require('../')
var assert = require('assert')
describe("multiple statements", () => {
describe('multiple statements', () => {
before(() => {
this.client = new Client();
this.client.connectSync();
});
this.client = new Client()
this.client.connectSync()
})
after(() => this.client.end());
after(() => this.client.end())
it("works with multiple queries", (done) => {
it('works with multiple queries', (done) => {
const text = `
SELECT generate_series(1, 2) as foo;
SELECT generate_series(10, 11) as bar;
SELECT generate_series(20, 22) as baz;
`;
`
this.client.query(text, (err, results) => {
if (err) return done(err);
assert(Array.isArray(results));
assert.equal(results.length, 3);
assert(Array.isArray(results[0]));
assert(Array.isArray(results[1]));
assert(Array.isArray(results[2]));
done();
});
});
});
if (err) return done(err)
assert(Array.isArray(results))
assert.equal(results.length, 3)
assert(Array.isArray(results[0]))
assert(Array.isArray(results[1]))
assert(Array.isArray(results[2]))
done()
})
})
})

90
packages/pg-native/test/notify.js
View File

@ -1,64 +1,64 @@
var Client = require("../");
var ok = require("okay");
var Client = require('../')
var ok = require('okay')
var notify = function (channel, payload) {
var client = new Client();
client.connectSync();
client.querySync("NOTIFY " + channel + ", '" + payload + "'");
client.end();
};
var client = new Client()
client.connectSync()
client.querySync('NOTIFY ' + channel + ", '" + payload + "'")
client.end()
}
describe("simple LISTEN/NOTIFY", function () {
describe('simple LISTEN/NOTIFY', function () {
before(function (done) {
var client = (this.client = new Client());
client.connect(done);
});
var client = (this.client = new Client())
client.connect(done)
})
it("works", function (done) {
var client = this.client;
client.querySync("LISTEN boom");
client.on("notification", function (msg) {
done();
});
notify("boom", "sup");
});
it('works', function (done) {
var client = this.client
client.querySync('LISTEN boom')
client.on('notification', function (msg) {
done()
})
notify('boom', 'sup')
})
after(function (done) {
this.client.end(done);
});
});
this.client.end(done)
})
})
if (!process.env.TRAVIS_CI) {
describe("async LISTEN/NOTIFY", function () {
describe('async LISTEN/NOTIFY', function () {
before(function (done) {
var client = (this.client = new Client());
client.connect(done);
});
var client = (this.client = new Client())
client.connect(done)
})
it("works", function (done) {
var client = this.client;
var count = 0;
it('works', function (done) {
var client = this.client
var count = 0
var check = function () {
count++;
if (count >= 2) return done();
};
client.on("notification", check);
count++
if (count >= 2) return done()
}
client.on('notification', check)
client.query(
"LISTEN test",
'LISTEN test',
ok(done, function () {
notify("test", "bot");
notify('test', 'bot')
client.query(
"SELECT pg_sleep(.05)",
'SELECT pg_sleep(.05)',
ok(done, function () {
notify("test", "bot");
}),
);
}),
);
});
notify('test', 'bot')
})
)
})
)
})
after(function (done) {
this.client.end(done);
});
});
this.client.end(done)
})
})
}

72
packages/pg-native/test/prepare.js
View File

@ -1,64 +1,64 @@
var Client = require("../");
var ok = require("okay");
var async = require("async");
var Client = require('../')
var ok = require('okay')
var async = require('async')
describe("async prepare", function () {
describe('async prepare', function () {
var run = function (n, cb) {
var client = new Client();
client.connectSync();
var client = new Client()
client.connectSync()
var exec = function (x, done) {
client.prepare("get_now" + x, "SELECT NOW()", 0, done);
};
client.prepare('get_now' + x, 'SELECT NOW()', 0, done)
}
async.timesSeries(
10,
exec,
ok(cb, function () {
client.end(cb);
}),
);
};
client.end(cb)
})
)
}
var t = function (n) {
it("works for " + n + " clients", function (done) {
it('works for ' + n + ' clients', function (done) {
async.times(n, run, function (err) {
done(err);
});
});
};
done(err)
})
})
}
for (var i = 0; i < 10; i++) {
t(i);
t(i)
}
});
})
describe("async execute", function () {
describe('async execute', function () {
var run = function (n, cb) {
var client = new Client();
client.connectSync();
client.prepareSync("get_now", "SELECT NOW()", 0);
var client = new Client()
client.connectSync()
client.prepareSync('get_now', 'SELECT NOW()', 0)
var exec = function (x, cb) {
client.execute("get_now", [], cb);
};
client.execute('get_now', [], cb)
}
async.timesSeries(
10,
exec,
ok(cb, function () {
client.end(cb);
}),
);
};
client.end(cb)
})
)
}
var t = function (n) {
it("works for " + n + " clients", function (done) {
it('works for ' + n + ' clients', function (done) {
async.times(n, run, function (err) {
done(err);
});
});
};
done(err)
})
})
}
for (var i = 0; i < 10; i++) {
t(i);
t(i)
}
});
})

178
packages/pg-native/test/query-async.js
View File

@ -1,115 +1,115 @@
var Client = require("../");
var assert = require("assert");
var async = require("async");
var ok = require("okay");
var Client = require('../')
var assert = require('assert')
var async = require('async')
var ok = require('okay')
describe("async query", function () {
describe('async query', function () {
before(function (done) {
this.client = Client();
this.client.connect(done);
});
this.client = Client()
this.client.connect(done)
})
after(function (done) {
this.client.end(done);
});
this.client.end(done)
})
it("can execute many prepared statements on a client", function (done) {
it('can execute many prepared statements on a client', function (done) {
async.timesSeries(
20,
(i, cb) => {
this.client.query("SELECT $1::text as name", ["brianc"], cb);
this.client.query('SELECT $1::text as name', ['brianc'], cb)
},
done,
);
});
done
)
})
it("simple query works", function (done) {
it('simple query works', function (done) {
var runQuery = function (n, done) {
this.client.query("SELECT NOW() AS the_time", function (err, rows) {
if (err) return done(err);
assert.equal(rows[0].the_time.getFullYear(), new Date().getFullYear());
return done();
});
}.bind(this);
async.timesSeries(3, runQuery, done);
});
this.client.query('SELECT NOW() AS the_time', function (err, rows) {
if (err) return done(err)
assert.equal(rows[0].the_time.getFullYear(), new Date().getFullYear())
return done()
})
}.bind(this)
async.timesSeries(3, runQuery, done)
})
it("parameters work", function (done) {
it('parameters work', function (done) {
var runQuery = function (n, done) {
this.client.query("SELECT $1::text AS name", ["Brian"], done);
}.bind(this);
async.timesSeries(3, runQuery, done);
});
this.client.query('SELECT $1::text AS name', ['Brian'], done)
}.bind(this)
async.timesSeries(3, runQuery, done)
})
it("prepared, named statements work", function (done) {
var client = this.client;
client.prepare("test", "SELECT $1::text as name", 1, function (err) {
if (err) return done(err);
it('prepared, named statements work', function (done) {
var client = this.client
client.prepare('test', 'SELECT $1::text as name', 1, function (err) {
if (err) return done(err)
client.execute(
"test",
["Brian"],
'test',
['Brian'],
ok(done, function (rows) {
assert.equal(rows.length, 1);
assert.equal(rows[0].name, "Brian");
assert.equal(rows.length, 1)
assert.equal(rows[0].name, 'Brian')
client.execute(
"test",
["Aaron"],
'test',
['Aaron'],
ok(done, function (rows) {
assert.equal(rows.length, 1);
assert.equal(rows[0].name, "Aaron");
done();
}),
);
}),
);
});
});
assert.equal(rows.length, 1)
assert.equal(rows[0].name, 'Aaron')
done()
})
)
})
)
})
})
it("returns error if prepare fails", function (done) {
this.client.prepare("test", "SELECT AWWW YEAH", 0, function (err) {
assert(err, "Should have returned an error");
done();
});
});
it('returns error if prepare fails', function (done) {
this.client.prepare('test', 'SELECT AWWW YEAH', 0, function (err) {
assert(err, 'Should have returned an error')
done()
})
})
it("returns an error if execute fails", function (done) {
this.client.execute("test", [], function (err) {
assert(err, "Should have returned an error");
done();
});
});
it('returns an error if execute fails', function (done) {
this.client.execute('test', [], function (err) {
assert(err, 'Should have returned an error')
done()
})
})
it("returns an error if there was a query error", function (done) {
it('returns an error if there was a query error', function (done) {
var runErrorQuery = function (n, done) {
this.client.query("SELECT ALKJSFDSLFKJ", function (err) {
assert(err instanceof Error, "Should return an error instance");
done();
});
}.bind(this);
async.timesSeries(3, runErrorQuery, done);
});
this.client.query('SELECT ALKJSFDSLFKJ', function (err) {
assert(err instanceof Error, 'Should return an error instance')
done()
})
}.bind(this)
async.timesSeries(3, runErrorQuery, done)
})
it("is still usable after an error", function (done) {
it('is still usable after an error', function (done) {
const runErrorQuery = (_, cb) => {
this.client.query("SELECT LKJSDJFLSDKFJ", (err) => {
assert(err instanceof Error, "Should return an error instance");
cb(null, err);
});
};
this.client.query('SELECT LKJSDJFLSDKFJ', (err) => {
assert(err instanceof Error, 'Should return an error instance')
cb(null, err)
})
}
async.timesSeries(3, runErrorQuery, (err, res) => {
assert(!err);
assert.equal(res.length, 3);
this.client.query("SELECT NOW()", done);
});
});
assert(!err)
assert.equal(res.length, 3)
this.client.query('SELECT NOW()', done)
})
})
it("supports empty query", function (done) {
this.client.query("", function (err, rows) {
assert.ifError(err);
assert(Array.isArray(rows));
console.log("rows", rows);
assert(rows.length === 0);
done();
});
});
});
it('supports empty query', function (done) {
this.client.query('', function (err, rows) {
assert.ifError(err)
assert(Array.isArray(rows))
console.log('rows', rows)
assert(rows.length === 0)
done()
})
})
})

118
packages/pg-native/test/query-sync.js
View File

@ -1,83 +1,83 @@
var Client = require("../");
var assert = require("assert");
var Client = require('../')
var assert = require('assert')
describe("query sync", function (done) {
describe('query sync', function (done) {
before(function () {
this.client = Client();
this.client.connectSync();
});
this.client = Client()
this.client.connectSync()
})
after(function (done) {
this.client.end(done);
});
this.client.end(done)
})
it("simple query works", function () {
var rows = this.client.querySync("SELECT NOW() AS the_time");
assert.equal(rows.length, 1);
assert.equal(rows[0].the_time.getFullYear(), new Date().getFullYear());
});
it('simple query works', function () {
var rows = this.client.querySync('SELECT NOW() AS the_time')
assert.equal(rows.length, 1)
assert.equal(rows[0].the_time.getFullYear(), new Date().getFullYear())
})
it("parameterized query works", function () {
var rows = this.client.querySync("SELECT $1::text AS name", ["Brian"]);
assert.equal(rows.length, 1);
assert.equal(rows[0].name, "Brian");
});
it('parameterized query works', function () {
var rows = this.client.querySync('SELECT $1::text AS name', ['Brian'])
assert.equal(rows.length, 1)
assert.equal(rows[0].name, 'Brian')
})
it("throws when second argument is not an array", function () {
it('throws when second argument is not an array', function () {
assert.throws(() => {
this.client.querySync("SELECT $1::text AS name", "Brian");
});
this.client.querySync('SELECT $1::text AS name', 'Brian')
})
assert.throws(() => {
this.client.prepareSync("test-failure", "SELECT $1::text as name", 1);
this.client.prepareSync('test-failure', 'SELECT $1::text as name', 1)
this.client.executeSync("test-failure", "Brian");
});
});
this.client.executeSync('test-failure', 'Brian')
})
})
it("prepared statement works", function () {
this.client.prepareSync("test", "SELECT $1::text as name", 1);
it('prepared statement works', function () {
this.client.prepareSync('test', 'SELECT $1::text as name', 1)
var rows = this.client.executeSync("test", ["Brian"]);
assert.equal(rows.length, 1);
assert.equal(rows[0].name, "Brian");
var rows = this.client.executeSync('test', ['Brian'])
assert.equal(rows.length, 1)
assert.equal(rows[0].name, 'Brian')
var rows2 = this.client.executeSync("test", ["Aaron"]);
assert.equal(rows2.length, 1);
assert.equal(rows2[0].name, "Aaron");
});
var rows2 = this.client.executeSync('test', ['Aaron'])
assert.equal(rows2.length, 1)
assert.equal(rows2[0].name, 'Aaron')
})
it("prepare throws exception on error", function () {
it('prepare throws exception on error', function () {
assert.throws(
function () {
this.client.prepareSync("blah", "I LIKE TO PARTY!!!", 0);
}.bind(this),
);
});
this.client.prepareSync('blah', 'I LIKE TO PARTY!!!', 0)
}.bind(this)
)
})
it("throws exception on executing improperly", function () {
it('throws exception on executing improperly', function () {
assert.throws(function () {
// wrong number of parameters
this.client.executeSync("test", []);
});
});
this.client.executeSync('test', [])
})
})
it("throws exception on error", function () {
it('throws exception on error', function () {
assert.throws(
function () {
this.client.querySync("SELECT ASLKJASLKJF");
}.bind(this),
);
});
this.client.querySync('SELECT ASLKJASLKJF')
}.bind(this)
)
})
it("is still usable after an error", function () {
var rows = this.client.querySync("SELECT NOW()");
assert(rows, "should have returned rows");
assert.equal(rows.length, 1);
});
it('is still usable after an error', function () {
var rows = this.client.querySync('SELECT NOW()')
assert(rows, 'should have returned rows')
assert.equal(rows.length, 1)
})
it("supports empty query", function () {
var rows = this.client.querySync("");
assert(rows, "should return rows");
assert.equal(rows.length, 0, "should return no rows");
});
});
it('supports empty query', function () {
var rows = this.client.querySync('')
assert(rows, 'should return rows')
assert.equal(rows.length, 0, 'should return no rows')
})
})

20
packages/pg-native/test/version.js
View File

@ -1,11 +1,11 @@
var Client = require("../");
var assert = require("assert");
var semver = require("semver");
var Client = require('../')
var assert = require('assert')
var semver = require('semver')
describe("version", function () {
it("is exported", function () {
assert(Client.version);
assert.equal(require("../package.json").version, Client.version);
assert(semver.gt(Client.version, "1.4.0"));
});
});
describe('version', function () {
it('is exported', function () {
assert(Client.version)
assert.equal(require('../package.json').version, Client.version)
assert(semver.gt(Client.version, '1.4.0'))
})
})

644
yarn.lock
View File

File diff suppressed because it is too large Load Diff