Pg: Adds a boolean value for PoolClient.release's support for truthy and error values (#41040)

* Formats code

* Adds boolean value for Pool.release's support for truthy and error values
This commit is contained in:
Daniel Durante
2020-01-02 19:43:53 -05:00
committed by Ryan Cavanaugh
parent c7ce2f4b92
commit fe47c041d5
2 changed files with 203 additions and 147 deletions

95
types/pg/index.d.ts vendored
View File

@@ -6,9 +6,9 @@
/// <reference types="node" />
import events = require("events");
import stream = require("stream");
import pgTypes = require("pg-types");
import events = require('events');
import stream = require('stream');
import pgTypes = require('pg-types');
import { ConnectionOptions } from "tls";
@@ -81,7 +81,7 @@ export interface QueryResultBase {
}
export interface QueryResultRow {
[column: string]: any;
[column: string]: any;
}
export interface QueryResult<R extends QueryResultRow = any> extends QueryResultBase {
@@ -112,7 +112,7 @@ export interface BindConfig {
portal?: string;
statement?: string;
binary?: string;
values?: Array<(Buffer | null | undefined | string)>;
values?: Array<Buffer | null | undefined | string>;
}
export interface ExecuteConfig {
@@ -167,16 +167,34 @@ export class Pool extends events.EventEmitter {
query<T extends Submittable>(queryStream: T): T;
// tslint:disable:no-unnecessary-generics
query<R extends any[] = any[], I extends any[] = any[]>(queryConfig: QueryArrayConfig<I>, values?: I): Promise<QueryArrayResult<R>>;
query<R extends QueryResultRow = any, I extends any[] = any[]>(queryConfig: QueryConfig<I>): Promise<QueryResult<R>>;
query<R extends QueryResultRow = any, I extends any[] = any[]>(queryTextOrConfig: string | QueryConfig<I>, values?: I): Promise<QueryResult<R>>;
query<R extends any[] = any[], I extends any[] = any[]>(queryConfig: QueryArrayConfig<I>, callback: (err: Error, result: QueryArrayResult<R>) => void): void;
query<R extends QueryResultRow = any, I extends any[] = any[]>(queryTextOrConfig: string | QueryConfig<I>, callback: (err: Error, result: QueryResult<R>) => void): void;
query<R extends QueryResultRow = any, I extends any[] = any[]>(queryText: string, values: I, callback: (err: Error, result: QueryResult<R>) => void): void;
query<R extends any[] = any[], I extends any[] = any[]>(
queryConfig: QueryArrayConfig<I>,
values?: I,
): Promise<QueryArrayResult<R>>;
query<R extends QueryResultRow = any, I extends any[] = any[]>(
queryConfig: QueryConfig<I>,
): Promise<QueryResult<R>>;
query<R extends QueryResultRow = any, I extends any[] = any[]>(
queryTextOrConfig: string | QueryConfig<I>,
values?: I,
): Promise<QueryResult<R>>;
query<R extends any[] = any[], I extends any[] = any[]>(
queryConfig: QueryArrayConfig<I>,
callback: (err: Error, result: QueryArrayResult<R>) => void,
): void;
query<R extends QueryResultRow = any, I extends any[] = any[]>(
queryTextOrConfig: string | QueryConfig<I>,
callback: (err: Error, result: QueryResult<R>) => void,
): void;
query<R extends QueryResultRow = any, I extends any[] = any[]>(
queryText: string,
values: I,
callback: (err: Error, result: QueryResult<R>) => void,
): void;
// tslint:enable:no-unnecessary-generics
on(event: "error", listener: (err: Error, client: PoolClient) => void): this;
on(event: "connect" | "acquire" | "remove", listener: (client: PoolClient) => void): this;
on(event: 'error', listener: (err: Error, client: PoolClient) => void): this;
on(event: 'connect' | 'acquire' | 'remove', listener: (client: PoolClient) => void): this;
}
export class ClientBase extends events.EventEmitter {
@@ -187,12 +205,30 @@ export class ClientBase extends events.EventEmitter {
query<T extends Submittable>(queryStream: T): T;
// tslint:disable:no-unnecessary-generics
query<R extends any[] = any[], I extends any[] = any[]>(queryConfig: QueryArrayConfig<I>, values?: I): Promise<QueryArrayResult<R>>;
query<R extends QueryResultRow = any, I extends any[] = any[]>(queryConfig: QueryConfig<I>): Promise<QueryResult<R>>;
query<R extends QueryResultRow = any, I extends any[] = any[]>(queryTextOrConfig: string | QueryConfig<I>, values?: I): Promise<QueryResult<R>>;
query<R extends any[] = any[], I extends any[] = any[]>(queryConfig: QueryArrayConfig<I>, callback: (err: Error, result: QueryArrayResult<R>) => void): void;
query<R extends QueryResultRow = any, I extends any[] = any[]>(queryTextOrConfig: string | QueryConfig<I>, callback: (err: Error, result: QueryResult<R>) => void): void;
query<R extends QueryResultRow = any, I extends any[] = any[]>(queryText: string, values: any[], callback: (err: Error, result: QueryResult<R>) => void): void;
query<R extends any[] = any[], I extends any[] = any[]>(
queryConfig: QueryArrayConfig<I>,
values?: I,
): Promise<QueryArrayResult<R>>;
query<R extends QueryResultRow = any, I extends any[] = any[]>(
queryConfig: QueryConfig<I>,
): Promise<QueryResult<R>>;
query<R extends QueryResultRow = any, I extends any[] = any[]>(
queryTextOrConfig: string | QueryConfig<I>,
values?: I,
): Promise<QueryResult<R>>;
query<R extends any[] = any[], I extends any[] = any[]>(
queryConfig: QueryArrayConfig<I>,
callback: (err: Error, result: QueryArrayResult<R>) => void,
): void;
query<R extends QueryResultRow = any, I extends any[] = any[]>(
queryTextOrConfig: string | QueryConfig<I>,
callback: (err: Error, result: QueryResult<R>) => void,
): void;
query<R extends QueryResultRow = any, I extends any[] = any[]>(
queryText: string,
values: any[],
callback: (err: Error, result: QueryResult<R>) => void,
): void;
// tslint:enable:no-unnecessary-generics
copyFrom(queryText: string): stream.Writable;
@@ -204,11 +240,11 @@ export class ClientBase extends events.EventEmitter {
escapeIdentifier(str: string): string;
escapeLiteral(str: string): string;
on(event: "drain", listener: () => void): this;
on(event: "error" | "notice", listener: (err: Error) => void): this;
on(event: "notification", listener: (message: Notification) => void): this;
on(event: 'drain', listener: () => void): this;
on(event: 'error' | 'notice', listener: (err: Error) => void): this;
on(event: 'notification', listener: (message: Notification) => void): this;
// tslint:disable-next-line unified-signatures
on(event: "end", listener: () => void): this;
on(event: 'end', listener: () => void): this;
}
export class Client extends ClientBase {
@@ -219,19 +255,20 @@ export class Client extends ClientBase {
}
export interface PoolClient extends ClientBase {
release(err?: Error): void;
release(err?: Error | boolean): void;
}
export class Query<R extends QueryResultRow = any, I extends any[] = any> extends events.EventEmitter implements Submittable {
export class Query<R extends QueryResultRow = any, I extends any[] = any> extends events.EventEmitter
implements Submittable {
constructor(queryTextOrConfig?: string | QueryConfig<I>, values?: I);
submit: (connection: Connection) => void;
on(event: "row", listener: (row: R, result?: ResultBuilder<R>) => void): this;
on(event: "error", listener: (err: Error) => void): this;
on(event: "end", listener: (result: ResultBuilder<R>) => void): this;
on(event: 'row', listener: (row: R, result?: ResultBuilder<R>) => void): this;
on(event: 'error', listener: (err: Error) => void): this;
on(event: 'end', listener: (result: ResultBuilder<R>) => void): this;
}
export class Events extends events.EventEmitter {
on(event: "error", listener: (err: Error, client: Client) => void): this;
on(event: 'error', listener: (err: Error, client: Client) => void): this;
}
export const types: typeof pgTypes;

View File

@@ -1,128 +1,135 @@
import { types, Client, QueryArrayConfig, Pool } from "pg";
import { types, Client, QueryArrayConfig, Pool } from 'pg';
// https://github.com/brianc/node-pg-types
// tslint:disable-next-line no-unnecessary-callback-wrapper
types.setTypeParser(20, val => Number(val));
const client = new Client({
host: 'my.database-server.com',
port: 5334,
user: 'database-user',
password: 'secretpassword!!',
keepAlive: true,
host: 'my.database-server.com',
port: 5334,
user: 'database-user',
password: 'secretpassword!!',
keepAlive: true,
});
client.connect(err => {
if (err) {
console.error("Could not connect to postgres", err);
console.error('Could not connect to postgres', err);
return;
}
client.query("SELECT NOW() AS 'theTime'", (err, result) => {
if (err) {
console.error("Error running query", err);
console.error('Error running query', err);
return;
}
console.log(result.rowCount);
console.log(result.rows[0]["theTime"]);
console.log(result.rows[0]['theTime']);
client.end();
return null;
});
return null;
});
client.on('end', () => console.log("Client was disconnected."));
client.on('end', () => console.log('Client was disconnected.'));
client.connect()
.then(() => console.log('connected'))
.catch(e => console.error('connection error', e.stack));
client
.connect()
.then(() => console.log('connected'))
.catch(e => console.error('connection error', e.stack));
client.query('SELECT NOW()', (err, res) => {
if (err) throw err;
console.log(res);
client.end();
if (err) throw err;
console.log(res);
client.end();
});
client.query('SELECT $1::text as name', ['brianc'], (err, res) => {
if (err) throw err;
console.log(res);
client.end();
if (err) throw err;
console.log(res);
client.end();
});
interface Person {
name: string;
name: string;
}
client.query<Person, [string]>('SELECT $1::text as name', ['brianc'], (err, res) => {
if (err) throw err;
console.log(res.rows[0].name);
client.end();
if (err) throw err;
console.log(res.rows[0].name);
client.end();
});
const query = {
name: 'get-name',
text: 'SELECT $1::text',
values: ['brianc']
name: 'get-name',
text: 'SELECT $1::text',
values: ['brianc'],
};
client.query(query, (err, res) => {
if (err) {
console.error(err.stack);
} else {
console.log(res.rows);
console.log(res.fields.map(f => f.name));
}
if (err) {
console.error(err.stack);
} else {
console.log(res.rows);
console.log(res.fields.map(f => f.name));
}
});
client.query(query)
.then(res => {
console.log(res.rows);
console.log(res.fields.map(f => f.name));
})
.catch(e => {
console.error(e.stack);
});
client.query(query, ['brianc'])
.then(res => {
console.log(res.rows);
console.log(res.fields.map(f => f.name));
})
.catch(e => {
console.error(e.stack);
});
client
.query(query)
.then(res => {
console.log(res.rows);
console.log(res.fields.map(f => f.name));
})
.catch(e => {
console.error(e.stack);
});
client
.query(query, ['brianc'])
.then(res => {
console.log(res.rows);
console.log(res.fields.map(f => f.name));
})
.catch(e => {
console.error(e.stack);
});
const queryArrMode: QueryArrayConfig = {
name: 'get-name-array',
text: 'SELECT $1::text',
values: ['brianc'],
rowMode: 'array'
name: 'get-name-array',
text: 'SELECT $1::text',
values: ['brianc'],
rowMode: 'array',
};
client.query(queryArrMode, (err, res) => {
if (err) {
console.error(err.stack);
} else {
console.log(res.rows);
console.log(res.fields.map(f => f.name));
}
if (err) {
console.error(err.stack);
} else {
console.log(res.rows);
console.log(res.fields.map(f => f.name));
}
});
client.query(queryArrMode)
.then(res => {
console.log(res.rows);
console.log(res.fields.map(f => f.name));
})
.catch(e => {
console.error(e.stack);
});
client.query({
text: 'select 1',
rowMode: 'array',
}).then(res => console.log(res.fields[0]));
client
.query(queryArrMode)
.then(res => {
console.log(res.rows);
console.log(res.fields.map(f => f.name));
})
.catch(e => {
console.error(e.stack);
});
client
.query({
text: 'select 1',
rowMode: 'array',
})
.then(res => console.log(res.fields[0]));
client.end((err) => {
console.log('client has disconnected');
if (err) {
console.log('error during disconnection', err.stack);
}
client.end(err => {
console.log('client has disconnected');
if (err) {
console.log('error during disconnection', err.stack);
}
});
client.end()
.then(() => console.log('client has disconnected'))
.catch(err => console.error('error during disconnection', err.stack));
client
.end()
.then(() => console.log('client has disconnected'))
.catch(err => console.error('error during disconnection', err.stack));
// pg.Pool
// https://node-postgres.com/api/pool
@@ -131,74 +138,86 @@ client.end()
const poolParameterlessCtor = new Pool();
const poolOne = new Pool({
connectionString: 'postgresql://dbuser:secretpassword@database.server.com:3211/mydb'
connectionString: 'postgresql://dbuser:secretpassword@database.server.com:3211/mydb',
});
const pool = new Pool({
host: 'localhost',
port: 5432,
user: 'database-user',
database: 'my_db',
max: 20,
idleTimeoutMillis: 30000,
connectionTimeoutMillis: 2000,
keepAlive: false,
log: (...args) => {
console.log.apply(console, args);
},
host: 'localhost',
port: 5432,
user: 'database-user',
database: 'my_db',
max: 20,
idleTimeoutMillis: 30000,
connectionTimeoutMillis: 2000,
keepAlive: false,
log: (...args) => {
console.log.apply(console, args);
},
});
console.log(pool.totalCount);
pool.connect((err, client, done) => {
if (err) {
console.error('error fetching client from pool', err);
return;
}
client.query('SELECT $1::int AS number', ['1'], (err, result) => {
done();
if (err) {
console.error('error running query', err);
return;
console.error('error fetching client from pool', err);
return;
}
console.log(result.rows[0].number);
});
client.query('SELECT $1::int AS number', ['1'], (err, result) => {
done();
if (err) {
console.error('error running query', err);
return;
}
console.log(result.rows[0].number);
});
});
pool.connect().then(client => {
client.query({ text: 'SELECT $1::int AS number', values: ['1'], rowMode: 'array' }).then(result => {
console.log(result.rowCount, result.rows[0][0], result.fields[0].name);
}).then(() => client.release(), e => client.release(e));
client
.query({ text: 'SELECT $1::int AS number', values: ['1'], rowMode: 'array' })
.then(result => {
console.log(result.rowCount, result.rows[0][0], result.fields[0].name);
})
.then(
() => client.release(),
e => client.release(e),
);
});
pool.on('error', (err, client) => {
console.error('idle client error', err.message, err.stack);
console.error('idle client error', err.message, err.stack);
});
(async () => {
const client = await pool.connect();
await client.query('SELECT 1');
client.release(true);
})();
pool.query('SELECT $1::text as name', ['brianc'], (err, result) => {
if (err) {
console.error('Error executing query', err.stack);
return;
}
console.log(result.rows[0].name);
if (err) {
console.error('Error executing query', err.stack);
return;
}
console.log(result.rows[0].name);
});
pool.query('SELECT $1::text as name', ['brianc'])
.then((res) => console.log(res.rows[0].name))
.catch(err => console.error('Error executing query', err.stack));
.then(res => console.log(res.rows[0].name))
.catch(err => console.error('Error executing query', err.stack));
pool.query({ text: 'SELECT $1::text as name' }, ['brianc'])
.then((res) => console.log(res.rows[0].name))
.catch(err => console.error('Error executing query', err.stack));
.then(res => console.log(res.rows[0].name))
.catch(err => console.error('Error executing query', err.stack));
pool.end(() => {
console.log('pool has ended');
console.log('pool has ended');
});
pool.end().then(() => console.log('pool has ended'));
(async () => {
const client = await pool.connect();
await client.query('SELECT NOW()');
client.release();
const client = await pool.connect();
await client.query('SELECT NOW()');
client.release();
})();
// client constructor tests