postgrejs 3.1.3 → 3.4.0

package/connection/prepared-statement.d.ts

@@ -1,3 +1,4 @@
+import type { BatchResult } from '../interfaces/batch-result.js';
 import type { QueryOptions } from '../interfaces/query-options.js';
 import type { QueryResult } from '../interfaces/query-result.js';
 import type { StatementPrepareOptions } from '../interfaces/statement-prepare-options.js';
@@ -20,7 +21,69 @@ export declare class PreparedStatement extends SafeEventEmitter implements Async
     get sql(): string;
     get paramTypes(): Maybe<Maybe<OID>[]>;
     execute(options?: QueryOptions): Promise<QueryResult>;
+    /**
+     * Runs this statement once per parameter set, sending every Bind/Execute
+     * before waiting for any of them and closing the lot with a single Sync.
+     *
+     * ```ts
+     * const st = await connection.prepare('update users set name = $1 where id = $2');
+     * const batch = await st.executeBatch([
+     *   ['John', 1],
+     *   ['Jane', 2],
+     *   ['Bob', 3],
+     * ]);
+     * batch.results.map(r => r.rowsAffected); // [1, 1, 0]
+     * batch.totalRowsAffected;                // 2
+     * ```
+     *
+     * Three things follow from the single Sync, and they are the reasons to
+     * reach for this over a loop or a Promise.all() of execute() calls:
+     *
+     * - **Speed.** Per-set Sync makes the server close an implicit
+     *   transaction and answer ReadyForQuery every time. Collapsing that to
+     *   one turned 1000 updates from 194ms (pipelined execute() calls) into
+     *   21ms locally, with socket reads dropping from 972 to 3.
+     * - **One transaction.** Unless an explicit transaction is already open,
+     *   the whole batch commits or rolls back together. This differs from N
+     *   separate execute() calls, where each commits on its own.
+     * - **A failing set stops the rest.** PostgreSQL discards everything
+     *   between an error and the Sync, so sets after a rejected one never
+     *   run. The error carries `failedIndex` (which set was rejected) and
+     *   `batchResults` (the ones that had completed) so the caller can see
+     *   how far it got.
+     *
+     * Every set runs the same statement, so results map to sets by position.
+     * Sets that return rows get them decoded into `rows` exactly as
+     * `execute()` would, `rowDecoder` included; `fetchCount` does not apply,
+     * since a portal suspended mid-batch would break that mapping - each set
+     * runs to completion and buffers its rows.
+     *
+     * For a bulk INSERT specifically, `connection.copyFrom()` is faster
+     * still, and a single `UPDATE ... FROM (VALUES ...)` beats this for bulk
+     * updates of one shape - at the cost of PostgreSQL's 65535-parameter
+     * ceiling. This is the general answer when neither fits.
+     *
+     * @param paramSets One array of bind parameters per execution.
+     * @param options Applied to every set - the same options `execute()`
+     *   takes, minus `fetchCount` and `cursor`, which a batch cannot honour.
+     */
+    executeBatch(paramSets: any[][], options?: QueryOptions): Promise<BatchResult>;
+    protected _executeBatchWithTransaction(paramSets: any[][], options: QueryOptions): Promise<BatchResult>;
     protected _executeWithTransaction(options?: QueryOptions): Promise<QueryResult>;
+    /**
+     * Runs `fn` inside whatever transaction handling the connection's config
+     * and `options` call for: an implicit BEGIN when autoCommit is off, a
+     * SAVEPOINT to roll back to when one is already open, a COMMIT when the
+     * call is the one turning autoCommit back on.
+     *
+     * Generic over `fn` rather than calling _execute() directly so that
+     * executeBatch() gets the same handling for the batch as a whole. Per
+     * set would be wrong twice over: the savepoints alone would add two
+     * statements per set, and the batch already shares one transaction by
+     * virtue of its single Sync, so a per-set savepoint could not roll one
+     * set back independently anyway.
+     */
+    protected _withTransaction<T>(options: QueryOptions | undefined, fn: (inlineSavepoint?: string) => Promise<T>, canInlineSavepoint?: boolean): Promise<T>;
     close(): Promise<void>;
     /**
      * Asks the server to cancel whatever this statement's connection is
@@ -28,7 +91,7 @@ export declare class PreparedStatement extends SafeEventEmitter implements Async
      * option, which reports the abort to the caller that asked for it.
      */
     cancel(): Promise<void>;
-    protected _execute(options?: QueryOptions): Promise<QueryResult>;
+    protected _execute(options?: QueryOptions, savepoint?: string): Promise<QueryResult>;
     /**
      * Called by Cursor.close() instead of separately awaiting
      * Portal.close() then this.close(). Returns false (no wire action taken,

package/connection/prepared-statement.js

@@ -4,6 +4,7 @@ import { Protocol } from '../protocol/protocol.js';
 import { SafeEventEmitter } from '../safe-event-emitter.js';
 import { withAbortSignal } from '../util/abort-signal.js';
 import { getParsers } from '../util/get-parsers.js';
+import { resolveRowType } from '../util/row-decoder.js';
 import { wrapRowDescription } from '../util/wrap-row-description.js';
 import { Cursor } from './cursor.js';
 import { getIntlConnection } from './intl-connection.js';
@@ -54,7 +55,89 @@ export class PreparedStatement extends SafeEventEmitter {
             return withAbortSignal(options.signal, () => intlCon.cancel(), () => this._executeWithTransaction(options));
         return this._executeWithTransaction(options);
     }
+    /**
+     * Runs this statement once per parameter set, sending every Bind/Execute
+     * before waiting for any of them and closing the lot with a single Sync.
+     *
+     * ```ts
+     * const st = await connection.prepare('update users set name = $1 where id = $2');
+     * const batch = await st.executeBatch([
+     *   ['John', 1],
+     *   ['Jane', 2],
+     *   ['Bob', 3],
+     * ]);
+     * batch.results.map(r => r.rowsAffected); // [1, 1, 0]
+     * batch.totalRowsAffected;                // 2
+     * ```
+     *
+     * Three things follow from the single Sync, and they are the reasons to
+     * reach for this over a loop or a Promise.all() of execute() calls:
+     *
+     * - **Speed.** Per-set Sync makes the server close an implicit
+     *   transaction and answer ReadyForQuery every time. Collapsing that to
+     *   one turned 1000 updates from 194ms (pipelined execute() calls) into
+     *   21ms locally, with socket reads dropping from 972 to 3.
+     * - **One transaction.** Unless an explicit transaction is already open,
+     *   the whole batch commits or rolls back together. This differs from N
+     *   separate execute() calls, where each commits on its own.
+     * - **A failing set stops the rest.** PostgreSQL discards everything
+     *   between an error and the Sync, so sets after a rejected one never
+     *   run. The error carries `failedIndex` (which set was rejected) and
+     *   `batchResults` (the ones that had completed) so the caller can see
+     *   how far it got.
+     *
+     * Every set runs the same statement, so results map to sets by position.
+     * Sets that return rows get them decoded into `rows` exactly as
+     * `execute()` would, `rowDecoder` included; `fetchCount` does not apply,
+     * since a portal suspended mid-batch would break that mapping - each set
+     * runs to completion and buffers its rows.
+     *
+     * For a bulk INSERT specifically, `connection.copyFrom()` is faster
+     * still, and a single `UPDATE ... FROM (VALUES ...)` beats this for bulk
+     * updates of one shape - at the cost of PostgreSQL's 65535-parameter
+     * ceiling. This is the general answer when neither fits.
+     *
+     * @param paramSets One array of bind parameters per execution.
+     * @param options Applied to every set - the same options `execute()`
+     *   takes, minus `fetchCount` and `cursor`, which a batch cannot honour.
+     */
+    async executeBatch(paramSets, options = {}) {
+        if (!Array.isArray(paramSets))
+            throw new TypeError('executeBatch() requires an array of parameter sets');
+        if (options.cursor)
+            throw new Error('executeBatch() cannot return a cursor - a batch runs every set to ' +
+                'completion under one Sync, so there is no portal left to fetch from');
+        const intlCon = getIntlConnection(this.connection);
+        if (!paramSets.length)
+            return { results: [], totalRowsAffected: 0 };
+        if (options.signal)
+            return withAbortSignal(options.signal, () => intlCon.cancel(), () => this._executeBatchWithTransaction(paramSets, options));
+        return this._executeBatchWithTransaction(paramSets, options);
+    }
+    _executeBatchWithTransaction(paramSets, options) {
+        const intlCon = getIntlConnection(this.connection);
+        return this._withTransaction(options, () => intlCon.executeBatchReused(this.name, this._fields, this.paramTypes, paramSets, options));
+    }
     async _executeWithTransaction(options = {}) {
+        // The Bind+Execute+Sync path can carry the rollbackOnError savepoint
+        // in its own round trip; the cursor path cannot, because the portal it
+        // opens outlives this call and the savepoint has to outlive it too.
+        return this._withTransaction(options, savepoint => this._execute(options, savepoint), !(options.cursor && this._fields));
+    }
+    /**
+     * Runs `fn` inside whatever transaction handling the connection's config
+     * and `options` call for: an implicit BEGIN when autoCommit is off, a
+     * SAVEPOINT to roll back to when one is already open, a COMMIT when the
+     * call is the one turning autoCommit back on.
+     *
+     * Generic over `fn` rather than calling _execute() directly so that
+     * executeBatch() gets the same handling for the batch as a whole. Per
+     * set would be wrong twice over: the savepoints alone would add two
+     * statements per set, and the batch already shares one transaction by
+     * virtue of its single Sync, so a per-set savepoint could not roll one
+     * set back independently anyway.
+     */
+    async _withTransaction(options = {}, fn, canInlineSavepoint = false) {
         const intlCon = getIntlConnection(this.connection);
         const transactionCommand = this.sql.match(/^(\bBEGIN\b|\bCOMMIT\b|\bSTART\b|\bROLLBACK|SAVEPOINT|RELEASE\b)/i);
         let beginFirst = false;
@@ -76,13 +159,21 @@ export class PreparedStatement extends SafeEventEmitter {
         const rollbackOnError = !transactionCommand &&
             intlCon.inTransaction &&
             (options?.rollbackOnError ?? intlCon.config.rollbackOnError ?? true);
-        if (rollbackOnError && intlCon.inTransaction)
+        // When `fn` can put the savepoint on the wire itself, SAVEPOINT and
+        // RELEASE ride along inside its single Sync instead of costing a round
+        // trip each - measured at 51us for the pair that way against 511us as
+        // two separate round trips. The error path is unchanged either way:
+        // PostgreSQL discards everything between a failed statement and the
+        // Sync, so an inlined RELEASE never runs, and ROLLBACK TO goes out on
+        // its own below exactly as before.
+        const inlineSavepoint = canInlineSavepoint && rollbackOnError && intlCon.inTransaction;
+        if (rollbackOnError && intlCon.inTransaction && !inlineSavepoint)
             await intlCon.execute('SAVEPOINT ' + this._onErrorSavePoint);
         try {
-            const result = await this._execute(options);
+            const result = await fn(inlineSavepoint ? this._onErrorSavePoint : undefined);
             if (commitLast)
                 await intlCon.execute('COMMIT');
-            else if (rollbackOnError && intlCon.inTransaction) {
+            else if (rollbackOnError && intlCon.inTransaction && !inlineSavepoint) {
                 await intlCon.execute('RELEASE ' + this._onErrorSavePoint + ';');
             }
             return result;
@@ -111,7 +202,7 @@ export class PreparedStatement extends SafeEventEmitter {
     async cancel() {
         return getIntlConnection(this.connection).cancel();
     }
-    async _execute(options = {}) {
+    async _execute(options = {}, savepoint) {
         const intlCon = getIntlConnection(this.connection);
         if (options.cursor && this._fields) {
             intlCon.ref();
@@ -124,7 +215,7 @@ export class PreparedStatement extends SafeEventEmitter {
                 const result = {
                     command: undefined,
                     fields: resultFields,
-                    rowType: options.objectRows ? 'object' : 'array',
+                    rowType: resolveRowType(options),
                     cursor: new Cursor(this, portal, resultFields, parsers, options),
                 };
                 this._refCount++;
@@ -141,7 +232,7 @@ export class PreparedStatement extends SafeEventEmitter {
         // unnamed portal, reusing the RowDescription prepare() already fetched
         // instead of re-Describing (and re-Close-ing) a fresh named portal on
         // every call.
-        return intlCon.executeReused(this.name, this._fields, this.paramTypes, options.params, options);
+        return intlCon.executeReused(this.name, this._fields, this.paramTypes, options.params, options, savepoint);
     }
     /**
      * Called by Cursor.close() instead of separately awaiting

package/data-types/bool-type.js

@@ -3,7 +3,6 @@ export const BoolType = {
     name: 'bool',
     oid: DataTypeOIDs.bool,
     jsType: 'boolean',
-    fixedBinarySize: 1,
     // 't'/'f', the form decodeText above reads and the server itself
     // emits - encodeText and decodeText are a public pair and have to stay
     // each other's inverse.

package/data-types/box-type.js

@@ -7,7 +7,6 @@ export const BoxType = {
     oid: DataTypeOIDs.box,
     jsType: 'object',
     arraySeparator: ';',
-    fixedBinarySize: 32,
     encodeText(v) {
         return `(${v.x1},${v.y1}),(${v.x2},${v.y2})`;
     },

package/data-types/bytea-type.js

@@ -9,10 +9,12 @@ export const ByteaType = {
         return '\\x' + v.toString('hex');
     },
     encodeBinary(buf, v) {
-        buf.writeBuffer(v);
+        buf.writeBytes(v);
     },
-    decodeBinary(v, offset = 0) {
-        return offset ? v.subarray(offset) : v;
+    decodeBinary(v, offset = 0, len) {
+        // A view, not a copy - the value handed back is the caller's own
+        // window onto the wire bytes, which is what bytea has always returned.
+        return v.subarray(offset, offset + len);
     },
     decodeText: parseBytea,
     decodeTextBuffer: parseByteaBuffer,

package/data-types/char-type.js

@@ -9,8 +9,8 @@ export const CharType = {
     encodeBinary(buf, v) {
         buf.writeString((v ? '' + v : ' ')[0], 'utf8');
     },
-    decodeBinary(v, offset = 0) {
-        return v.toString('utf8', offset);
+    decodeBinary(v, offset = 0, len) {
+        return v.toString('utf8', offset, offset + len);
     },
     decodeText(v) {
         return v;

package/data-types/circle-type.js

@@ -7,7 +7,6 @@ export const CircleType = {
     name: 'circle',
     oid: DataTypeOIDs.circle,
     jsType: 'object',
-    fixedBinarySize: 24,
     encodeText(v) {
         return `<(${v.x},${v.y}),${v.r}>`;
     },

package/data-types/date-type.js

@@ -6,7 +6,6 @@ export const DateType = {
     name: 'date',
     oid: DataTypeOIDs.date,
     jsType: 'Date',
-    fixedBinarySize: 4,
     encodeText(v, options) {
         return formatDate(v, options);
     },
@@ -30,7 +29,7 @@ export const DateType = {
         const t = Math.trunc(n + Number.EPSILON);
         buf.writeInt32BE(t);
     },
-    decodeBinary(v, offset = 0, options) {
+    decodeBinary(v, offset = 0, _len, options) {
         const fetchAsString = options.fetchAsString?.includes(DataTypeOIDs.date);
         const t = v.readInt32BE(offset);
         if (t === 0x7fffffff)

package/data-types/float4-type.js

@@ -1,22 +1,21 @@
 import { DataTypeOIDs } from '../constants.js';
+import { assertCoercedNumber } from '../util/assert-integer.js';
+import { fastParseFloatBuffer } from '../util/fast-parsefloat.js';
 export const Float4Type = {
     name: 'float4',
     oid: DataTypeOIDs.float4,
     jsType: 'number',
-    fixedBinarySize: 4,
     encodeText(v) {
         return '' + v;
     },
     encodeBinary(buf, v) {
-        buf.writeFloatBE(typeof v === 'number' ? v : parseFloat(v));
+        buf.writeFloatBE(typeof v === 'number' ? v : assertCoercedNumber(parseFloat(v), 'float4'));
     },
     decodeBinary(v, offset = 0) {
         return v.readFloatBE(offset);
     },
     decodeText: parseFloat,
-    decodeTextBuffer(buf, offset, len) {
-        return parseFloat(buf.toString('latin1', offset, offset + len));
-    },
+    decodeTextBuffer: fastParseFloatBuffer,
     isType(v) {
         return typeof v === 'number';
     },

package/data-types/float8-type.js

@@ -1,24 +1,22 @@
 import { DataTypeOIDs } from '../constants.js';
+import { assertCoercedNumber } from '../util/assert-integer.js';
+import { fastParseFloatBuffer } from '../util/fast-parsefloat.js';
 export const Float8Type = {
     name: 'float8',
     oid: DataTypeOIDs.float8,
     jsType: 'number',
-    fixedBinarySize: 8,
     // Infinity/NaN stringify to the words PostgreSQL itself uses.
     encodeText(v) {
         return '' + v;
     },
     encodeBinary(buf, v) {
-        buf.writeDoubleBE(typeof v === 'number' ? v : parseFloat(v));
+        buf.writeDoubleBE(typeof v === 'number' ? v : assertCoercedNumber(parseFloat(v), 'float8'));
     },
     decodeBinary(v, offset = 0) {
         return v.readDoubleBE(offset);
     },
     decodeText: parseFloat,
-    // See float4-type.ts's decodeTextBuffer comment - same rationale.
-    decodeTextBuffer(buf, offset, len) {
-        return parseFloat(buf.toString('latin1', offset, offset + len));
-    },
+    decodeTextBuffer: fastParseFloatBuffer,
     isType(v) {
         return typeof v === 'number';
     },

package/data-types/int2-type.js

@@ -1,15 +1,15 @@
 import { DataTypeOIDs } from '../constants.js';
+import { assertInteger } from '../util/assert-integer.js';
 import { fastParseInt, fastParseIntBuffer } from '../util/fast-parseint.js';
 export const Int2Type = {
     name: 'int2',
     oid: DataTypeOIDs.int2,
     jsType: 'number',
-    fixedBinarySize: 2,
     encodeText(v) {
         return '' + v;
     },
     encodeBinary(buf, v) {
-        buf.writeInt16BE(fastParseInt(v));
+        buf.writeInt16BE(assertInteger(fastParseInt(v), 'int2'));
     },
     decodeBinary(v, offset = 0) {
         return v.readInt16BE(offset);

package/data-types/int2-vector-type.js

@@ -15,8 +15,9 @@ export const Int2VectorType = {
     encodeCalculateDim(v) {
         return [v.length];
     },
-    decodeBinary(v) {
-        return decodeBinaryArray(v, 0, b => b.readInt16BE()) || undefined;
+    decodeBinary(v, offset = 0) {
+        return (decodeBinaryArray(v, offset, (b, off) => b.readInt16BE(off)) ||
+            undefined);
     },
     decodeText(str) {
         return str.split(' ').map(fastParseInt);

package/data-types/int4-type.js

@@ -1,15 +1,15 @@
 import { DataTypeOIDs } from '../constants.js';
+import { assertInteger } from '../util/assert-integer.js';
 import { fastParseInt, fastParseIntBuffer } from '../util/fast-parseint.js';
 export const Int4Type = {
     name: 'int4',
     oid: DataTypeOIDs.int4,
     jsType: 'number',
-    fixedBinarySize: 4,
     encodeText(v) {
         return '' + v;
     },
     encodeBinary(buf, v) {
-        buf.writeInt32BE(fastParseInt(v));
+        buf.writeInt32BE(assertInteger(fastParseInt(v), 'int4'));
     },
     decodeBinary(v, offset = 0) {
         return v.readInt32BE(offset);

package/data-types/int8-type.js

@@ -1,4 +1,5 @@
 import { DataTypeOIDs } from '../constants.js';
+import { assertBigIntSource } from '../util/assert-integer.js';
 import { readBigInt64BE } from '../util/bigint-methods.js';
 import { fastParseIntBuffer } from '../util/fast-parseint.js';
 const maxSafeInteger = BigInt(Number.MAX_SAFE_INTEGER);
@@ -6,12 +7,11 @@ export const Int8Type = {
     name: 'int8',
     oid: DataTypeOIDs.int8,
     jsType: 'BigInt',
-    fixedBinarySize: 8,
     encodeText(v) {
         return '' + v;
     },
     encodeBinary(buf, v) {
-        buf.writeBigInt64BE(v);
+        buf.writeBigInt64BE(assertBigIntSource(v, 'int8'));
     },
     decodeBinary(buf, offset = 0) {
         const v = typeof buf.readBigInt64BE === 'function'

package/data-types/json-type.js

@@ -3,8 +3,8 @@ export const JsonType = {
     name: 'json',
     oid: DataTypeOIDs.json,
     jsType: 'string',
-    decodeBinary(v, offset = 0, options) {
-        const content = v.toString('utf8', offset);
+    decodeBinary(v, offset = 0, len, options) {
+        const content = v.toString('utf8', offset, offset + len);
         const fetchAsString = options.fetchAsString?.includes(DataTypeOIDs.json);
         if (fetchAsString)
             return content;

package/data-types/jsonb-type.js

@@ -1,5 +1,4 @@
 import { DataTypeOIDs } from '../constants.js';
-import { BufferReader } from '../protocol/buffer-reader.js';
 export const JsonbType = {
     name: 'jsonb',
     oid: DataTypeOIDs.jsonb,
@@ -15,12 +14,14 @@ export const JsonbType = {
         buf.writeUInt8(1);
         buf.writeString(JsonbType.encodeText(v, {}), 'utf8');
     },
-    decodeBinary(v, offset = 0, options) {
-        const buf = new BufferReader(offset ? v.subarray(offset) : v);
-        if (buf.readUInt8() !== 1)
+    decodeBinary(v, offset = 0, len, options) {
+        // jsonb's binary form is a one-byte version followed by the JSON text,
+        // which carries no terminator of its own - so its end is whatever
+        // `len` says, not the end of the buffer it happens to sit in.
+        if (v[offset] !== 1)
             throw new Error('Unexpected Jsonb version value in header');
+        const content = v.toString('utf8', offset + 1, offset + len);
         const fetchAsString = options.fetchAsString?.includes(DataTypeOIDs.jsonb);
-        const content = buf.readLString(buf.length - buf.offset);
         if (fetchAsString)
             return content;
         return content ? JSON.parse(content) : undefined;

package/data-types/lseg-type.js

@@ -7,7 +7,6 @@ export const LsegType = {
     name: 'lseg',
     oid: DataTypeOIDs.lseg,
     jsType: 'object',
-    fixedBinarySize: 32,
     encodeText(v) {
         return `[(${v.x1},${v.y1}),(${v.x2},${v.y2})]`;
     },

package/data-types/numeric-type.js

@@ -1,4 +1,6 @@
 import { DataTypeOIDs } from '../constants.js';
+import { assertCoercedNumber } from '../util/assert-integer.js';
+import { fastParseFloatBuffer } from '../util/fast-parsefloat.js';
 const NUMERIC_NEG = 0x4000;
 const NUMERIC_NAN = 0xc000;
 const NUMERIC_PINF = 0xd000;
@@ -36,6 +38,12 @@ export const NumericType = {
             return writeHeader(0, 0, NUMERIC_PINF, 0);
         if (str === '-Infinity')
             return writeHeader(0, 0, NUMERIC_NINF, 0);
+        // Anything with no numeric reading at all - `{}` stringifies to
+        // "[object Object]", `true` to "true" - would otherwise be walked
+        // digit by digit below and stored as 0.
+        // Number('') is 0, not NaN, so an empty string - what `[]` and `null`
+        // stringify to - would slip past the NaN check below.
+        assertCoercedNumber(str.length ? Number(str) : NaN, 'numeric');
         // Exponent form has no place in the wire format; go through Number to
         // get it back into plain notation. toFixed() cannot do this itself -
         // per spec it falls back to exponential notation once the magnitude
@@ -109,10 +117,7 @@ export const NumericType = {
         return '' + n;
     },
     decodeText: parseFloat,
-    // See float4-type.ts's decodeTextBuffer comment - same rationale.
-    decodeTextBuffer(buf, offset, len) {
-        return parseFloat(buf.toString('latin1', offset, offset + len));
-    },
+    decodeTextBuffer: fastParseFloatBuffer,
     isType(v) {
         return typeof v === 'number';
     },

package/data-types/oid-type.js

@@ -1,15 +1,15 @@
 import { DataTypeNames, DataTypeOIDs } from '../constants.js';
+import { assertInteger } from '../util/assert-integer.js';
 import { fastParseInt, fastParseIntBuffer } from '../util/fast-parseint.js';
 export const OidType = {
     name: 'oid',
     oid: DataTypeOIDs.oid,
     jsType: 'number',
-    fixedBinarySize: 4,
     encodeText(v) {
         return '' + v;
     },
     encodeBinary(buf, v) {
-        buf.writeUInt32BE(fastParseInt(v));
+        buf.writeUInt32BE(assertInteger(fastParseInt(v), 'oid'));
     },
     decodeBinary(v, offset = 0) {
         return v.readUInt32BE(offset);

package/data-types/oid-vector-type.js

@@ -21,8 +21,9 @@ export const OidVectorType = {
     encodeCalculateDim(v) {
         return [v.length];
     },
-    decodeBinary(v) {
-        return decodeBinaryArray(v, 0, b => b.readUInt32BE()) || undefined;
+    decodeBinary(v, offset = 0) {
+        return (decodeBinaryArray(v, offset, (b, off) => b.readUInt32BE(off)) ||
+            undefined);
     },
     decodeText(str) {
         return str.split(' ').map(fastParseInt);

package/data-types/point-type.js

@@ -5,7 +5,6 @@ export const PointType = {
     name: 'point',
     oid: DataTypeOIDs.point,
     jsType: 'object',
-    fixedBinarySize: 16,
     encodeText(v) {
         return `(${v.x},${v.y})`;
     },

package/data-types/time-type.js

@@ -6,7 +6,6 @@ export const TimeType = {
     name: 'time',
     oid: DataTypeOIDs.time,
     jsType: 'string',
-    fixedBinarySize: 8,
     encodeText(v, options) {
         return formatTime(v, options);
     },
@@ -25,7 +24,7 @@ export const TimeType = {
         buf.writeInt32BE(hi);
         buf.writeUInt32BE(lo);
     },
-    decodeBinary(v, offset = 0, options) {
+    decodeBinary(v, offset = 0, _len, options) {
         const fetchAsString = options.fetchAsString?.includes(DataTypeOIDs.time);
         const hi = v.readInt32BE(offset);
         const lo = v.readUInt32BE(offset + 4);

package/data-types/timestamp-type.js

@@ -1,13 +1,13 @@
 import { DataTypeOIDs } from '../constants.js';
 import { formatTimestamp } from '../util/format-datetime.js';
 import { parseDateTime } from '../util/parse-datetime.js';
+import { parsePgTimestampBuffer } from '../util/parse-pg-timestamp.js';
 const timeShift = 946684800000;
 const timeMul = 4294967296;
 export const TimestampType = {
     name: 'timestamp',
     oid: DataTypeOIDs.timestamp,
     jsType: 'Date',
-    fixedBinarySize: 8,
     encodeText(v, options) {
         return formatTimestamp(v, options);
     },
@@ -36,7 +36,7 @@ export const TimestampType = {
         buf.writeInt32BE(hi);
         buf.writeUInt32BE(lo);
     },
-    decodeBinary(v, offset = 0, options) {
+    decodeBinary(v, offset = 0, _len, options) {
         const fetchAsString = options.fetchAsString?.includes(DataTypeOIDs.timestamp);
         const hi = v.readInt32BE(offset);
         const lo = v.readUInt32BE(offset + 4);
@@ -56,8 +56,18 @@ export const TimestampType = {
             return v;
         return parseDateTime(v, options.utcDates);
     },
-    // See date-type.ts's decodeTextBuffer comment - same rationale.
+    // Reads PostgreSQL's own timestamp shape straight from the wire bytes -
+    // see timestamptz-type.ts's decodeTextBuffer for why. The two guards are
+    // what decodeText()/parseDateTime() would have applied anyway: with
+    // fetchAsString the raw string is the answer, and with utcDates the
+    // string has to go through the regex path that reads it as UTC.
     decodeTextBuffer(buf, offset, len, options) {
+        if (!options.utcDates &&
+            !options.fetchAsString?.includes(DataTypeOIDs.timestamp)) {
+            const d = parsePgTimestampBuffer(buf, offset, offset + len);
+            if (d !== undefined)
+                return d;
+        }
         return TimestampType.decodeText(buf.toString('latin1', offset, offset + len), options);
     },
     isType(v) {