postgrejs 2.23.1 → 3.0.1

package/data-types/timestamp-type.js

@@ -1,4 +1,5 @@
 import { DataTypeOIDs } from '../constants.js';
+import { formatTimestamp } from '../util/format-datetime.js';
 import { parseDateTime } from '../util/parse-datetime.js';
 const timeShift = 946684800000;
 const timeMul = 4294967296;
@@ -6,25 +7,13 @@ export const TimestampType = {
     name: 'timestamp',
     oid: DataTypeOIDs.timestamp,
     jsType: 'Date',
-    parseBinary(v, options) {
-        const fetchAsString = options.fetchAsString &&
-            options.fetchAsString.includes(DataTypeOIDs.timestamp);
-        const hi = v.readInt32BE();
-        const lo = v.readUInt32BE(4);
-        if (lo === 0xffffffff && hi === 0x7fffffff)
-            return fetchAsString ? 'infinity' : Infinity;
-        if (lo === 0x00000000 && hi === -0x80000000)
-            return fetchAsString ? '-infinity' : -Infinity;
-        // Shift from 2000 to 1970
-        let d = new Date((lo + hi * timeMul) / 1000 + timeShift);
-        if (fetchAsString || !options.utcDates) {
-            d = new Date(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds());
-        }
-        return fetchAsString ? dateToTimestampString(d) : d;
+    fixedBinarySize: 8,
+    encodeText(v, options) {
+        return formatTimestamp(v, options);
     },
     encodeBinary(buf, v, options) {
         if (typeof v === 'string')
-            v = parseDateTime(v, true, false, options.utcDates);
+            v = parseDateTime(v, options.utcDates);
         if (v === Infinity) {
             buf.writeInt32BE(0x7fffffff); // hi
             buf.writeUInt32BE(0xffffffff); // lo
@@ -47,19 +36,37 @@ export const TimestampType = {
         buf.writeInt32BE(hi);
         buf.writeUInt32BE(lo);
     },
-    parseText(v, options) {
-        if (options.fetchAsString &&
-            options.fetchAsString.includes(DataTypeOIDs.timestamp))
+    decodeBinary(v, offset = 0, options) {
+        const fetchAsString = options.fetchAsString?.includes(DataTypeOIDs.timestamp);
+        const hi = v.readInt32BE(offset);
+        const lo = v.readUInt32BE(offset + 4);
+        if (lo === 0xffffffff && hi === 0x7fffffff)
+            return fetchAsString ? 'infinity' : Infinity;
+        if (lo === 0x00000000 && hi === -0x80000000)
+            return fetchAsString ? '-infinity' : -Infinity;
+        // Shift from 2000 to 1970
+        let d = new Date((lo + hi * timeMul) / 1000 + timeShift);
+        if (fetchAsString || !options.utcDates) {
+            d = new Date(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds());
+        }
+        return fetchAsString ? dateToTimestampString(d) : d;
+    },
+    decodeText(v, options) {
+        if (options.fetchAsString?.includes(DataTypeOIDs.timestamp))
             return v;
-        return parseDateTime(v, true, false, options.utcDates);
+        return parseDateTime(v, options.utcDates);
+    },
+    // See date-type.ts's decodeTextBuffer comment - same rationale.
+    decodeTextBuffer(buf, offset, len, options) {
+        return TimestampType.decodeText(buf.toString('latin1', offset, offset + len), options);
     },
     isType(v) {
+        // A midnight-exact Date is ambiguous between "date-only" and "a real
+        // timestamp that happens to fall on midnight" - default to timestamp,
+        // since a timestamp/timestamptz column represents midnight just fine,
+        // whereas a date column can never represent a non-midnight time.
         return (v instanceof Date &&
-            !(v.getFullYear() === 1970 && v.getMonth() === 0 && v.getDate() === 1) &&
-            !(v.getHours() === 0 &&
-                v.getMinutes() === 0 &&
-                v.getSeconds() === 0 &&
-                v.getMilliseconds() === 0));
+            !(v.getFullYear() === 1970 && v.getMonth() === 0 && v.getDate() === 1));
     },
 };
 function padZero(v) {

package/data-types/timestamptz-type.js

@@ -1,31 +1,20 @@
 import { DataTypeOIDs } from '../constants.js';
 import { SmartBuffer } from '../protocol/smart-buffer.js';
-import { parseDateTime } from '../util/parse-datetime.js';
+import { formatTimestamptz } from '../util/format-datetime.js';
+import { parseDateTimeTz } from '../util/parse-datetime.js';
 const timeShift = 946684800000;
 const timeMul = 4294967296;
 export const TimestamptzType = {
     name: 'timestamptz',
     oid: DataTypeOIDs.timestamptz,
     jsType: 'Date',
-    parseBinary(v, options) {
-        const fetchAsString = options.fetchAsString &&
-            options.fetchAsString.includes(DataTypeOIDs.timestamptz);
-        const hi = v.readInt32BE();
-        const lo = v.readUInt32BE(4);
-        if (lo === 0xffffffff && hi === 0x7fffffff)
-            return fetchAsString ? 'infinity' : Infinity;
-        if (lo === 0x00000000 && hi === -0x80000000)
-            return fetchAsString ? '-infinity' : -Infinity;
-        // Shift from 2000 to 1970
-        let d = new Date((lo + hi * timeMul) / 1000 + timeShift);
-        if (fetchAsString || !options.utcDates) {
-            d = new Date(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());
-        }
-        return fetchAsString ? dateToTimestamptzString(d) : d;
+    fixedBinarySize: 8,
+    encodeText(v) {
+        return formatTimestamptz(v);
     },
     encodeBinary(buf, v, options) {
         if (typeof v === 'string')
-            v = parseDateTime(v, true, true, options.utcDates);
+            v = parseDateTimeTz(v, options.utcDates);
         if (v === Infinity) {
             buf.writeInt32BE(0x7fffffff); // hi
             buf.writeUInt32BE(0xffffffff); // lo
@@ -45,20 +34,43 @@ export const TimestamptzType = {
         buf.writeInt32BE(hi);
         buf.writeUInt32BE(lo);
     },
-    parseText(v, options) {
-        const d = parseDateTime(v, true, true, options.utcDates);
-        if (options.fetchAsString &&
-            options.fetchAsString.includes(DataTypeOIDs.timestamptz)) {
+    decodeBinary(v, offset = 0, options) {
+        const fetchAsString = options.fetchAsString?.includes(DataTypeOIDs.timestamptz);
+        const hi = v.readInt32BE(offset);
+        const lo = v.readUInt32BE(offset + 4);
+        if (lo === 0xffffffff && hi === 0x7fffffff)
+            return fetchAsString ? 'infinity' : Infinity;
+        if (lo === 0x00000000 && hi === -0x80000000)
+            return fetchAsString ? '-infinity' : -Infinity;
+        // Shift from 2000 to 1970
+        let d = new Date((lo + hi * timeMul) / 1000 + timeShift);
+        if (fetchAsString || !options.utcDates) {
+            d = new Date(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());
+        }
+        return fetchAsString ? dateToTimestamptzString(d) : d;
+    },
+    decodeText(v, options) {
+        const d = parseDateTimeTz(v, options.utcDates);
+        if (options.fetchAsString?.includes(DataTypeOIDs.timestamptz)) {
             if (d instanceof Date)
                 return dateToTimestamptzString(d);
             if (d === Infinity)
                 return 'infinity';
             if (d === -Infinity)
                 return '-infinity';
+            // parseDateTimeTz() only ever returns a Date, Infinity or -Infinity,
+            // never anything else, so this is unreachable.
             return '';
         }
         return d;
     },
+    // See date-type.ts's decodeTextBuffer comment - same rationale. Note this
+    // type's decodeText always parses first and only branches on
+    // fetchAsString afterward (unlike date/time/timestamp, which early-return
+    // the raw string) - delegating by reference preserves that as-is.
+    decodeTextBuffer(buf, offset, len, options) {
+        return TimestamptzType.decodeText(buf.toString('latin1', offset, offset + len), options);
+    },
     isType(v) {
         return v instanceof Date;
     },

package/data-types/uuid-type.js

@@ -4,16 +4,9 @@ export const UuidType = {
     name: 'uuid',
     oid: DataTypeOIDs.uuid,
     jsType: 'String',
-    parseBinary(v) {
-        return (v.toString('hex', 0, 4) +
-            '-' +
-            v.toString('hex', 4, 6) +
-            '-' +
-            v.toString('hex', 6, 8) +
-            '-' +
-            v.toString('hex', 8, 10) +
-            '-' +
-            v.toString('hex', 10, 16));
+    fixedBinarySize: 16,
+    encodeText(v) {
+        return '' + v;
     },
     encodeBinary(buf, v) {
         if (!GUID_PATTERN.test(v))
@@ -21,9 +14,26 @@ export const UuidType = {
         const b = Buffer.from(v.replace(/-/g, ''), 'hex');
         buf.writeBuffer(b);
     },
-    parseText(v) {
+    decodeBinary(v, offset = 0) {
+        return (v.toString('hex', offset, offset + 4) +
+            '-' +
+            v.toString('hex', offset + 4, offset + 6) +
+            '-' +
+            v.toString('hex', offset + 6, offset + 8) +
+            '-' +
+            v.toString('hex', offset + 8, offset + 10) +
+            '-' +
+            v.toString('hex', offset + 10, offset + 16));
+    },
+    decodeText(v) {
         return v;
     },
+    // Canonical UUID text is fixed-format hex+dashes, pure ASCII - 'latin1'
+    // decodes identically to 'utf8' here but skips V8's multi-byte-sequence
+    // detection.
+    decodeTextBuffer(buf, offset, len) {
+        return buf.toString('latin1', offset, offset + len);
+    },
     isType(v) {
         return typeof v === 'string' && GUID_PATTERN.test(v);
     },

package/data-types/varchar-type.js

@@ -3,14 +3,26 @@ export const VarcharType = {
     name: 'varchar',
     oid: DataTypeOIDs.varchar,
     jsType: 'string',
-    parseBinary(v) {
-        return v.toString('utf8');
+    encodeText(v) {
+        return '' + v;
     },
     encodeBinary(buf, v) {
         buf.writeString('' + v, 'utf8');
     },
-    parseText(v) {
-        return '' + v;
+    decodeBinary(v, offset = 0) {
+        return v.toString('utf8', offset);
+    },
+    decodeText(v) {
+        // The wire decoder always hands this a string (see intl-connection.ts's
+        // DataRow handling) - no coercion needed.
+        return v;
+    },
+    // varchar can hold arbitrary Unicode text, so this must stay 'utf8' -
+    // same allocation as the default (v.toString('utf8')) path, this only
+    // skips the extra decodeText wrapper-closure call get-parsers.ts would
+    // otherwise add.
+    decodeTextBuffer(buf, offset, len) {
+        return buf.toString('utf8', offset, offset + len);
     },
     isType(v) {
         return typeof v === 'string';

package/index.d.ts

@@ -1,6 +1,9 @@
 export * from './connection/bind-param.js';
 export * from './connection/connection.js';
+export * from './connection/copy-stream.js';
 export * from './connection/cursor.js';
+export * from './connection/large-object.js';
+export * from './connection/logical-replication.js';
 export * from './connection/pool.js';
 export * from './connection/prepared-statement.js';
 export * from './constants.js';
@@ -19,7 +22,9 @@ export * from './protocol/database-error.js';
 export * from './protocol/smart-buffer.js';
 export * from './types.js';
 export * from './util/connection-config.js';
+export * from './util/escape-identifier.js';
 export * from './util/escape-literal.js';
 export * from './util/parse-datetime.js';
+export * from './util/sql-tag.js';
 export * from './util/stringify-arrayliteral.js';
 export * from './util/stringify-for-sql.js';

package/index.js

@@ -1,6 +1,9 @@
 export * from './connection/bind-param.js';
 export * from './connection/connection.js';
+export * from './connection/copy-stream.js';
 export * from './connection/cursor.js';
+export * from './connection/large-object.js';
+export * from './connection/logical-replication.js';
 export * from './connection/pool.js';
 export * from './connection/prepared-statement.js';
 export * from './constants.js';
@@ -19,7 +22,9 @@ export * from './protocol/database-error.js';
 export * from './protocol/smart-buffer.js';
 export * from './types.js';
 export * from './util/connection-config.js';
+export * from './util/escape-identifier.js';
 export * from './util/escape-literal.js';
 export * from './util/parse-datetime.js';
+export * from './util/sql-tag.js';
 export * from './util/stringify-arrayliteral.js';
 export * from './util/stringify-for-sql.js';

package/interfaces/data-type.d.ts

@@ -1,4 +1,4 @@
-import type { DecodeBinaryFunction, EncodeAsNullFunction, EncodeBinaryFunction, EncodeCalculateDimFunction, EncodeTextFunction, OID, ParseTextFunction } from '../types.js';
+import type { DecodeBinaryFunction, DecodeTextBufferFunction, DecodeTextFunction, EncodeAsNullFunction, EncodeBinaryFunction, EncodeCalculateDimFunction, EncodeTextFunction, OID } from '../types.js';
 export interface DataType {
     oid: OID;
     name: string;
@@ -7,8 +7,10 @@ export interface DataType {
     jsType: string;
     arraySeparator?: string;
     isType: (v: any) => boolean;
-    parseBinary: DecodeBinaryFunction;
-    parseText: ParseTextFunction;
+    decodeBinary: DecodeBinaryFunction;
+    decodeText: DecodeTextFunction;
+    decodeTextBuffer?: DecodeTextBufferFunction;
+    fixedBinarySize?: number;
     encodeAsNull?: EncodeAsNullFunction;
     encodeBinary?: EncodeBinaryFunction;
     encodeText?: EncodeTextFunction;

package/interfaces/database-connection-params.d.ts

@@ -9,6 +9,58 @@ export interface DatabaseConnectionParams {
     password?: string | (() => string | Promise<string>);
     database?: string;
     applicationName?: string;
+    /**
+     * Opens the connection in replication mode, which is what lets it run
+     * START_REPLICATION. Set by LogicalReplication; a connection in this mode
+     * cannot serve ordinary queries once streaming has begun.
+     */
+    replication?: 'database' | 'true';
+    /**
+     * Additional servers to try, in order, when the first one cannot be used.
+     *
+     * Also accepted as a comma-separated `host`, or in a connection string:
+     * `postgres://a:5432,b:5433/db`. Each entry falls back to the top-level
+     * `port` when it does not carry one of its own.
+     *
+     * Selection happens when a connection is opened, so a cluster that has
+     * failed over to another node is found on the next connect - a query
+     * already in flight when a server goes down still fails.
+     */
+    hosts?: {
+        host: string;
+        port?: number;
+    }[];
+    /**
+     * Which server in `hosts` is acceptable, mirroring libpq's option of the
+     * same name: `read-write`, `read-only`, `primary`, `standby` or
+     * `prefer-standby`. A server that does not match is dropped and the next
+     * one tried, which is how `read-write` finds the current primary.
+     */
+    targetSessionAttrs?: TargetSessionAttrs;
+    /**
+     * How TLS is started: `postgres` (the default) asks first with an
+     * SSLRequest and waits for the server's yes or no; `direct` begins the
+     * TLS handshake straight away, announcing the `postgresql` protocol over
+     * ALPN so the server can tell what it is talking to.
+     *
+     * Direct saves a round trip and leaves no plaintext preamble for a
+     * middlebox to read or strip, but it needs PostgreSQL 17 or later and
+     * `ssl` set - an older server just closes the connection.
+     */
+    sslNegotiation?: 'postgres' | 'direct';
+    /**
+     * Whether SCRAM authentication binds itself to the TLS channel, mirroring
+     * libpq's option of the same name: `prefer` (the default there and here)
+     * uses it when the server offers it, `require` refuses to connect
+     * otherwise, `disable` never asks for it.
+     *
+     * Binding mixes a hash of the server's certificate into the SCRAM proof,
+     * so an attacker who terminates TLS in the middle - necessarily with a
+     * different certificate - cannot relay the exchange. It is what protects
+     * the login when the certificate itself is not verified, which is the
+     * usual case with `sslmode=require` or a self-signed certificate.
+     */
+    channelBinding?: 'prefer' | 'require' | 'disable';
     requireSSL?: boolean;
     ssl?: TlsConnectionOptions;
     timezone?: string;
@@ -26,8 +78,22 @@ export interface DatabaseConnectionParams {
      * @default true
      */
     rollbackOnError?: boolean;
+    /**
+     * Whether a thrown error's stack trace points at the application code
+     * that called query()/execute() (etc.) across the `await`, instead of an
+     * internal async frame inside this library.
+     *
+     * Getting this right costs a real, measurable amount of CPU when many
+     * calls are in flight at once (e.g. a burst of pipelined queries on one
+     * connection) - set to `false` to skip it, which is also what makes an
+     * apples-to-apples benchmark against a client that does not offer this
+     * fair.
+     * @default true
+     */
+    asyncErrorHandling?: boolean;
     debugLogger?: DebugLogger;
 }
+export type TargetSessionAttrs = 'read-write' | 'read-only' | 'primary' | 'standby' | 'prefer-standby';
 export interface SocketOptions {
     keepAlive?: boolean;
 }
@@ -35,4 +101,33 @@ export interface ConnectionConfiguration extends DatabaseConnectionParams, Socke
     buffer?: SmartBufferConfig;
 }
 export interface PoolConfiguration extends ConnectionConfiguration, LPoolConfiguration {
+    /**
+     * How many of Pool.query()'s one-shot queries may share a single pooled
+     * connection at the same time (default 100).
+     *
+     * PostgreSQL correlates responses to requests by order, so several
+     * queries can be in flight on one connection at once, each with its own
+     * Sync and therefore its own error boundary. Dispatching that way means
+     * `max` stops being a ceiling on concurrent queries and becomes only a
+     * ceiling on connections - with the default pool of 10, a burst of 1000
+     * queries no longer has to run as 100 sequential rounds of 10.
+     *
+     * Set to 1 for the older behaviour, where Pool.query() holds a
+     * connection exclusively for the duration of each query. Connections
+     * handed out by acquire() are never shared, whatever this is set to, so
+     * transactions, cursors and prepared statements are unaffected.
+     */
+    pipelineMaxQueries?: number;
+    /**
+     * How many pooled connections the pipelined path may borrow at once
+     * (default: the pool's own `max`).
+     *
+     * The server runs one connection's statements serially, so a burst
+     * spread over ten connections finishes in a fraction of the time it
+     * takes on one. Borrowed connections are handed straight back the
+     * moment they go idle, so this is a ceiling on how wide a single burst
+     * may fan out, not a reservation - lower it to keep connections free
+     * for acquire() while a burst is running.
+     */
+    pipelineMaxConnections?: number;
 }

package/interfaces/query-options.d.ts

@@ -43,4 +43,21 @@ export interface QueryOptions extends DataMappingOptions {
      * @default true
      */
     rollbackOnError?: boolean;
+    /**
+     * Aborts the call when the signal fires: the running statement is
+     * cancelled on the server and the promise rejects with the signal's own
+     * reason, with the database error attached as `cause`.
+     *
+     * Cancelling is a request rather than a guarantee - it travels on its own
+     * connection and the statement may finish first - so the call settles when
+     * the server has actually finished with it, not the moment abort() is
+     * called. `AbortSignal.timeout(ms)` gives a per-call timeout.
+     */
+    signal?: AbortSignal;
+    /**
+     * Overrides the connection's own `asyncErrorHandling` for this call only -
+     * see `DatabaseConnectionParams.asyncErrorHandling`.
+     * @default the connection's own setting
+     */
+    asyncErrorHandling?: boolean;
 }

package/interfaces/script-execute-options.d.ts

@@ -23,4 +23,21 @@ export interface ScriptExecuteOptions extends DataMappingOptions {
      * @default true
      */
     rollbackOnError?: boolean;
+    /**
+     * Aborts the call when the signal fires: the running statement is
+     * cancelled on the server and the promise rejects with the signal's own
+     * reason, with the database error attached as `cause`.
+     *
+     * Cancelling is a request rather than a guarantee - it travels on its own
+     * connection and the statement may finish first - so the call settles when
+     * the server has actually finished with it, not the moment abort() is
+     * called. `AbortSignal.timeout(ms)` gives a per-call timeout.
+     */
+    signal?: AbortSignal;
+    /**
+     * Overrides the connection's own `asyncErrorHandling` for this call only -
+     * see `DatabaseConnectionParams.asyncErrorHandling`.
+     * @default the connection's own setting
+     */
+    asyncErrorHandling?: boolean;
 }

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "postgrejs",
   "description": "Professional PostgreSQL client NodeJS",
-  "version": "2.23.1",
+  "version": "3.0.1",
   "author": "Panates",
-  "license": "MIT",
+  "license": "BSD-3-Clause",
   "dependencies": {
     "@jsopen/objects": "^2.2.3",
     "doublylinked": "^2.5.6",
     "lightning-pool": "^4.12.0",
-    "postgres-bytea": "^3.0.0",
     "power-tasks": "^1.14.2",
     "putil-promisify": "^1.10.1",
     "putil-varhelpers": "^1.7.0",

package/protocol/backend.d.ts

@@ -1,7 +1,12 @@
 import { Protocol } from './protocol.js';
 declare type ParseCallback = (code: Protocol.BackendMessageCode, data?: any) => void;
 export declare class Backend {
-    private _buf?;
+    private readonly _headerBuf;
+    private _headerFilled;
+    private _code?;
+    private _len;
+    private _bodyBuf?;
+    private _bodyFilled;
     reset(): void;
     parse(data: Buffer, callback: ParseCallback): void;
 }

package/protocol/backend.js

@@ -23,35 +23,70 @@ const ErrorFieldTypes = {
     R: 'routine',
 };
 export class Backend {
-    _buf;
+    _headerBuf = Buffer.allocUnsafe(HEADER_LENGTH);
+    _headerFilled = 0;
+    _code;
+    _len = 0;
+    _bodyBuf;
+    _bodyFilled = 0;
     reset() {
-        this._buf = undefined;
+        this._headerFilled = 0;
+        this._code = undefined;
+        this._bodyBuf = undefined;
+        this._bodyFilled = 0;
     }
     parse(data, callback) {
-        if (this._buf) {
-            data = Buffer.concat([this._buf, data]);
-            this._buf = undefined;
-        }
-        const io = new BufferReader(data);
-        let offsetBookmark;
-        while (io.length - io.offset >= HEADER_LENGTH) {
-            offsetBookmark = io.offset;
-            const code = io.readUInt8();
-            const len = io.readUInt32BE();
-            // Check if frame data not received yet
-            if (io.length - io.offset < len - 4) {
-                io.offset = offsetBookmark;
-                this._buf = io.readBuffer();
-                return;
+        const dataLen = data.length;
+        let pos = 0;
+        while (pos < dataLen) {
+            if (this._headerFilled === 0 &&
+                !this._bodyBuf &&
+                dataLen - pos >= HEADER_LENGTH) {
+                const code = data.readUInt8(pos);
+                const len = data.readUInt32BE(pos + 1);
+                const bodyStart = pos + HEADER_LENGTH;
+                const bodyEnd = bodyStart + (len - 4);
+                if (bodyEnd <= dataLen) {
+                    const io = new BufferReader(data.subarray(bodyStart, bodyEnd));
+                    const parser = MessageParsers[code];
+                    const v = parser && parser(io, code, len);
+                    callback(code, v);
+                    pos = bodyEnd;
+                    continue;
+                }
+            }
+            if (!this._bodyBuf) {
+                const need = HEADER_LENGTH - this._headerFilled;
+                const take = Math.min(need, dataLen - pos);
+                data.copy(this._headerBuf, this._headerFilled, pos, pos + take);
+                this._headerFilled += take;
+                pos += take;
+                if (this._headerFilled < HEADER_LENGTH)
+                    return; // header not complete yet
+                this._code = this._headerBuf.readUInt8(0);
+                this._len = this._headerBuf.readUInt32BE(1);
+                this._bodyBuf = Buffer.allocUnsafe(this._len - 4);
+                this._bodyFilled = 0;
+            }
+            const need = this._bodyBuf.length - this._bodyFilled;
+            const take = Math.min(need, dataLen - pos);
+            if (take > 0) {
+                data.copy(this._bodyBuf, this._bodyFilled, pos, pos + take);
+                this._bodyFilled += take;
+                pos += take;
             }
-            const parser = MessageParsers[code];
-            const v = parser && parser(io, code, len);
-            callback(code, v);
-            // Set offset to next message
-            io.offset = offsetBookmark + len + 1;
+            if (this._bodyFilled < this._bodyBuf.length)
+                return; // body not complete yet
+            const io = new BufferReader(this._bodyBuf);
+            const parser = MessageParsers[this._code];
+            const v = parser && parser(io, this._code, this._len);
+            callback(this._code, v);
+            // Reset reassembly state for the next message.
+            this._headerFilled = 0;
+            this._code = undefined;
+            this._bodyBuf = undefined;
+            this._bodyFilled = 0;
         }
-        if (io.offset < io.length)
-            this._buf = io.readBuffer(io.length - io.offset);
     }
 }
 const MessageParsers = {
@@ -158,7 +193,9 @@ function parseCopyResponse(io) {
     };
     if (out.columnCount) {
         out.columnFormats = [];
-        for (let i = 0; i < out.columnCount; i++) {
+        const l = out.columnCount;
+        let i;
+        for (i = 0; i < l; i++) {
             out.columnFormats.push(io.readUInt16BE() === 0
                 ? Protocol.DataFormat.text
                 : Protocol.DataFormat.binary);
@@ -166,24 +203,10 @@ function parseCopyResponse(io) {
     }
     return out;
 }
-function parseDataRow(io) {
-    const out = {
-        columnCount: io.readUInt16BE(),
-    };
-    if (out.columnCount) {
-        out.columns = [];
-        for (let i = 0; i < out.columnCount; i++) {
-            // The length of the column value, in bytes (this count does not include itself).
-            // Can be zero. As a special case, -1 indicates a NULL column value.
-            // No value bytes follow in the NULL case.
-            const l = io.readInt32BE();
-            if (l < 0)
-                out.columns.push(null);
-            else
-                out.columns.push(io.readBuffer(l));
-        }
-    }
-    return out;
+function parseDataRow(io, code, len) {
+    const columnCount = io.readUInt16BE();
+    const data = io.readBuffer(len - 6);
+    return { columnCount, data };
 }
 function parseErrorResponse(io) {
     const out = {};
@@ -217,10 +240,12 @@ function parseNegotiateProtocolVersion(io) {
 }
 function parseParameterDescription(io) {
     const out = {
-        parameterCount: io.readUInt32BE(),
+        parameterCount: io.readUInt16BE(),
         parameterIds: [],
     };
-    for (let i = 0; i < out.parameterCount; i++) {
+    const l = out.parameterCount;
+    let i;
+    for (i = 0; i < l; i++) {
         out.parameterIds.push(io.readUInt32BE());
     }
     return out;

package/protocol/buffer-reader.d.ts

@@ -11,7 +11,5 @@ export declare class BufferReader {
     readCString(encoding?: BufferEncoding): string;
     readLString(len: number, encoding?: BufferEncoding): string | null;
     readBuffer(len?: number): Buffer;
-    moveBy(n: number): this;
-    moveTo(pos: number): this;
     private _checkReadable;
 }