postgrejs 3.1.2 → 3.3.0

package/CHANGELOG.md

@@ -1,6 +1,53 @@
 ## Changelog
 
-### [v3.1.2](https://github.com/panates/postgrejs/compare/v3.1.1...v3.1.2) - 
+### [v3.3.0](https://github.com/panates/postgrejs/compare/v3.2.0...v3.3.0) - 
+
+#### 🚀 New Features
+
+- feat: add first-class Bun support with dedicated benchmark suite @Eray Hanoğlu 
+- feat: add pluggable RowDecoder for custom row decoding @Eray Hanoğlu 
+
+#### 🪲 Fixes
+
+- fix: return the actual instant when decoding timestamptz from binary @Eray Hanoğlu 
+- fix: point coverage badge at dev instead of the abandoned master branch @Eray Hanoğlu 
+
+#### 📖 Documentation Changes
+
+- docs: refresh both benchmark reports on 3.3.0 @Eray Hanoğlu 
+- docs: document Bun support and the Bun benchmark report in the README @Eray Hanoğlu 
+- docs: cover the Bun benchmarks in the README's speed section too @Eray Hanoğlu 
+- docs: document RowDecoder's data-immutability contract @Eray Hanoğlu 
+
+#### ⚡️ Performance Improvments
+
+- perf: decode timestamps from the wire bytes instead of a string @Eray Hanoğlu 
+- perf: build object rows from a compiled literal instead of per-column assignment @Eray Hanoğlu 
+- perf: decode float and numeric text without materialising a string @Eray Hanoğlu 
+- perf: decode PostgreSQL's own timestamp text shape without the engine parser @Eray Hanoğlu 
+- perf: write protocol messages immediately instead of deferring a tick @Eray Hanoğlu 
+
+#### 💬 General Changes
+
+- bench: report near-ties as ties instead of ranking them @Eray Hanoğlu 
+- feat!: give decodeBinary the value's length, not a slice of it @Eray Hanoğlu 
+- bench: stop measuring type-declaration policy in the Extended Query scenarios @Eray Hanoğlu 
+- bench: stop one stalled repeat from making every result a tie @Eray Hanoğlu 
+- bench: document why concurrent Simple Query varies its literal @Eray Hanoğlu 
+
+### [v3.2.0](https://github.com/panates/postgrejs/compare/v3.1.3...v3.2.0) -  12 September 2026 
+
+#### 🛠 Refactoring and Updates
+
+- refactor: build SmartBuffer/BufferReader on top of flexy-buffer @Eray Hanoğlu 
+
+### [v3.1.3](https://github.com/panates/postgrejs/compare/v3.1.2...v3.1.3) -  11 September 2026 
+
+#### 🪲 Fixes
+
+- fix: reset transaction depth after prepareTransaction() @Eray Hanoğlu 
+
+### [v3.1.2](https://github.com/panates/postgrejs/compare/v3.1.1...v3.1.2) -  11 September 2026 
 
 #### 💬 General Changes
 

package/README.md

@@ -12,7 +12,7 @@
 
 ## Why PostgreJS?
 
-**PostgreJS** is a PostgreSQL driver for Node.js built from the wire protocol up - no `libpq`, no native bindings,
+**PostgreJS** is a PostgreSQL driver for Node.js and Bun built from the wire protocol up - no `libpq`, no native bindings,
 just TypeScript talking directly to PostgreSQL. That from-scratch design is also what makes it fast and light: every
 byte on the wire is handled by code written for exactly that purpose, with a binary-first protocol, shared buffers,
 and row/column decoding pipelines built to avoid unnecessary allocation, instead of generic string plumbing bolted
@@ -22,11 +22,14 @@ onto a client meant for text.
 
 The numbers back it up. In PostgreJS's own benchmark suite - run head-to-head against
 [`pg`](https://github.com/brianc/node-postgres) (node-postgres) and [`postgres`](https://github.com/porsager/postgres)
-(postgres.js) on identical workloads - PostgreJS opens a connection up to **3x faster** than postgres.js and
-**2x faster** than pg, pushes pooled queries through up to **6.6x faster** than postgres.js, and fetches large
-result sets nearly **5x faster** than pg. It's also the only one of the three with a complete binary wire protocol
-across every data type, rather than falling back to text for most of them. See
-[`doc/BENCHMARKS.md`](doc/BENCHMARKS.md) for the full methodology and every scenario.
+(postgres.js) on identical workloads - PostgreJS opens a connection up to **3x faster** than postgres.js, pushes
+pooled queries through up to **6.6x faster** than postgres.js, and fetches large result sets nearly **5x faster**
+than pg. It's also the only one of the three Node drivers with a complete binary wire protocol across every data
+type, rather than falling back to text for most of them. See [`doc/BENCHMARKS.md`](doc/BENCHMARKS.md) for the full
+methodology and every scenario.
+
+The same suite runs under Bun, where Bun's own built-in `Bun.sql` joins the comparison as a fourth client - see
+[`doc/BENCHMARKS-bun.md`](doc/BENCHMARKS-bun.md).
 
 ### 🪶 Small Footprint
 
@@ -223,14 +226,27 @@ concurrency, each library run through its own idiomatic fast path. The numbers t
 machine via `npm run bench` against the repo's own
 `docker/docker-compose.yml` Postgres instance; see [`benchmark/README.md`](./benchmark/README.md) for details.
 
+The same suite runs under Bun via `npm run bench:bun`, where it also measures Bun's own built-in `Bun.sql` client as
+a fourth library. Those results live in [`doc/BENCHMARKS-bun.md`](doc/BENCHMARKS-bun.md) and are deliberately kept
+in a separate report rather than merged into the Node one: GC instrumentation, cursor streaming and binary-format
+control all differ enough between the two runtimes that a single table would conflate a library difference with a
+runtime difference.
+
+Both reports list libraries in a fixed order rather than fastest-first, and mark every result statistically tied
+with the leader rather than bolding a lone winner - several scenarios separate the leading drivers by about a
+percent, which is less than the run-to-run spread of the measurement itself.
+
 ## Support
 
 You can report bugs and discuss features on the [GitHub issues](https://github.com/panates/postgrejs/issues) page When
 you open an issue please provide version of NodeJS and PostgreSQL server.
 
-## Node Compatibility
+## Runtime Compatibility
 
-- node >= 20.x
+- Node.js >= 20.x
+- Bun - the same test suite runs under Bun in CI against PostgreSQL 18 on every push, so Bun is a supported target
+  rather than an untested coincidence. (Coverage is collected on the Node matrix only: `c8` instruments V8's
+  coverage APIs, which JavaScriptCore doesn't have.)
 
 ## License
 
@@ -242,5 +258,5 @@ PostgreJS is available under the [BSD 3-Clause](LICENSE) license.
 [downloads-url]: https://npmjs.org/package/postgrejs
 [ci-test-image]: https://github.com/panates/postgrejs/actions/workflows/test.yml/badge.svg
 [ci-test-url]: https://github.com/panates/postgrejs/actions/workflows/test.yml
-[coveralls-image]: https://img.shields.io/coveralls/panates/postgrejs/master.svg
+[coveralls-image]: https://img.shields.io/coveralls/panates/postgrejs/dev.svg
 [coveralls-url]: https://coveralls.io/r/panates/postgrejs

package/connection/cursor.d.ts

@@ -9,12 +9,13 @@ export declare class Cursor extends SafeEventEmitter implements AsyncDisposable
     private readonly _portal;
     private readonly _parsers;
     private readonly _queryOptions;
+    private readonly _rowDecoder;
     private _taskQueue;
     private _rows;
     private _closed;
     readonly fields: FieldInfo[];
     constructor(statement: PreparedStatement, portal: Portal, fields: FieldInfo[], parsers: AnyParseFunction[], queryOptions: QueryOptions);
-    get rowType(): 'array' | 'object';
+    get rowType(): 'array' | 'object' | 'custom';
     get isClosed(): boolean;
     next(): Promise<Maybe<Row>>;
     fetch(nRows: number): Promise<Row[]>;

package/connection/cursor.js

@@ -1,12 +1,13 @@
 import DoublyLinked from 'doublylinked';
 import { TaskQueue } from 'power-tasks';
 import { SafeEventEmitter } from '../safe-event-emitter.js';
-import { parseObjectRow, parseRow } from '../util/parse-row.js';
+import { resolveRowDecoder, resolveRowType } from '../util/row-decoder.js';
 export class Cursor extends SafeEventEmitter {
     _statement;
     _portal;
     _parsers;
     _queryOptions;
+    _rowDecoder;
     _taskQueue = new TaskQueue({ concurrency: 1 });
     _rows = new DoublyLinked();
     _closed = false;
@@ -18,9 +19,10 @@ export class Cursor extends SafeEventEmitter {
         this._parsers = parsers;
         this._queryOptions = queryOptions;
         this.fields = fields;
+        this._rowDecoder = resolveRowDecoder(queryOptions);
     }
     get rowType() {
-        return this._queryOptions.objectRows ? 'object' : 'array';
+        return resolveRowType(this._queryOptions);
     }
     get isClosed() {
         return this._closed;
@@ -71,16 +73,14 @@ export class Cursor extends SafeEventEmitter {
             if (r && r.rows && r.rows.length) {
                 const rows = r.rows;
                 if (this._parsers) {
-                    const objectRows = queryOptions.objectRows;
                     const fields = this.fields;
                     const parsers = this._parsers;
+                    const rowDecoder = this._rowDecoder;
                     const rowLen = rows.length;
                     let i;
                     for (i = 0; i < rowLen; i++) {
                         const { data, columnCount } = rows[i];
-                        rows[i] = objectRows
-                            ? parseObjectRow(parsers, data, columnCount, this._queryOptions, fields)
-                            : parseRow(parsers, data, columnCount, this._queryOptions);
+                        rows[i] = rowDecoder.decode(parsers, data, columnCount, this._queryOptions, fields);
                     }
                 }
                 this._rows.push(...rows);

package/connection/intl-connection.d.ts

@@ -101,6 +101,13 @@ export declare class IntlConnection extends SafeEventEmitter {
      *
      * Requires `max_prepared_transactions` above zero on the server, which is
      * not the default; the server's own error says so if it is not.
+     *
+     * Resets `_transactionDepth` like commit()/rollback() do: PREPARE
+     * TRANSACTION ends the session's transaction on the wire regardless of
+     * how many nested startTransaction() calls led up to it, so a stale,
+     * nonzero depth left behind here would make a later, unrelated commit()
+     * on this same connection treat itself as still nested and silently skip
+     * sending COMMIT.
      */
     prepareTransaction(name: string): Promise<void>;
     /** Commits a transaction left waiting by prepareTransaction(). */

package/connection/intl-connection.js

@@ -7,7 +7,7 @@ import { SafeEventEmitter } from '../safe-event-emitter.js';
 import { getConnectionConfig } from '../util/connection-config.js';
 import { escapeLiteral } from '../util/escape-literal.js';
 import { getParsers } from '../util/get-parsers.js';
-import { parseObjectRow, parseRow } from '../util/parse-row.js';
+import { resolveRowDecoder, resolveRowType } from '../util/row-decoder.js';
 import { wrapRowDescription } from '../util/wrap-row-description.js';
 import { CopyFromStream, CopyToStream } from './copy-stream.js';
 const DataFormat = Protocol.DataFormat;
@@ -293,9 +293,17 @@ export class IntlConnection extends SafeEventEmitter {
      *
      * Requires `max_prepared_transactions` above zero on the server, which is
      * not the default; the server's own error says so if it is not.
+     *
+     * Resets `_transactionDepth` like commit()/rollback() do: PREPARE
+     * TRANSACTION ends the session's transaction on the wire regardless of
+     * how many nested startTransaction() calls led up to it, so a stale,
+     * nonzero depth left behind here would make a later, unrelated commit()
+     * on this same connection treat itself as still nested and silently skip
+     * sending COMMIT.
      */
     async prepareTransaction(name) {
         await this._execute('PREPARE TRANSACTION ' + escapeLiteral(name));
+        this._transactionDepth = 0;
     }
     /** Commits a transaction left waiting by prepareTransaction(). */
     async commitPrepared(name) {
@@ -390,6 +398,7 @@ export class IntlConnection extends SafeEventEmitter {
             let fields;
             let error;
             const typeMap = options.typeMap || GlobalTypeMap;
+            const rowDecoder = resolveRowDecoder(options);
             this.runningQueryCount++;
             return await this.socket.sendQueryMessage(sql, (code, msg, done) => {
                 switch (code) {
@@ -418,9 +427,7 @@ export class IntlConnection extends SafeEventEmitter {
                         break;
                     case Protocol.BackendMessageCode.DataRow:
                         {
-                            const row = options.objectRows && current.fields
-                                ? parseObjectRow(parsers, msg.data, msg.columnCount, options, current.fields)
-                                : parseRow(parsers, msg.data, msg.columnCount, options);
+                            const row = rowDecoder.decode(parsers, msg.data, msg.columnCount, options, current.fields);
                             if (cb)
                                 cb('row', row);
                             current.rows = current.rows || [];
@@ -438,8 +445,7 @@ export class IntlConnection extends SafeEventEmitter {
                         if (timingEnabled)
                             current.executeTime = performance.now() - currentStart;
                         if (current.rows)
-                            current.rowType =
-                                options.objectRows && current.fields ? 'object' : 'array';
+                            current.rowType = resolveRowType(options);
                         result.results.push(current);
                         if (cb)
                             cb('command-complete', current);
@@ -489,6 +495,7 @@ export class IntlConnection extends SafeEventEmitter {
             let resultFields;
             let commandTag;
             let error;
+            const rowDecoder = resolveRowDecoder(options);
             this.runningQueryCount++;
             await this.socket
                 .sendExtendedQueryMessages({
@@ -508,7 +515,7 @@ export class IntlConnection extends SafeEventEmitter {
                         parsers = getParsers(typeMap, msg.fields);
                         resultFields = wrapRowDescription(typeMap, msg.fields, options.columnFormat || DEFAULT_COLUMN_FORMAT);
                         result.fields = resultFields;
-                        result.rowType = options.objectRows ? 'object' : 'array';
+                        result.rowType = resolveRowType(options);
                         break;
                     case Protocol.BackendMessageCode.DataRow:
                         rows.push(msg);
@@ -539,9 +546,7 @@ export class IntlConnection extends SafeEventEmitter {
                 const l = rows.length;
                 let i;
                 for (i = 0; i < l; i++) {
-                    rows[i] = options.objectRows
-                        ? parseObjectRow(parsers, rows[i].data, rows[i].columnCount, options, resultFields)
-                        : parseRow(parsers, rows[i].data, rows[i].columnCount, options);
+                    rows[i] = rowDecoder.decode(parsers, rows[i].data, rows[i].columnCount, options, resultFields);
                 }
             }
             if (result.command === 'DELETE' ||
@@ -628,6 +633,7 @@ export class IntlConnection extends SafeEventEmitter {
             let resultFields;
             let commandTag;
             let error;
+            const rowDecoder = resolveRowDecoder(options);
             if (cachedFields) {
                 const columnFormat = options.columnFormat != null
                     ? options.columnFormat
@@ -656,7 +662,7 @@ export class IntlConnection extends SafeEventEmitter {
                     });
                 }
                 result.fields = resultFields;
-                result.rowType = options.objectRows ? 'object' : 'array';
+                result.rowType = resolveRowType(options);
             }
             this.runningQueryCount++;
             await this.socket
@@ -704,9 +710,7 @@ export class IntlConnection extends SafeEventEmitter {
                 const l = rows.length;
                 let i;
                 for (i = 0; i < l; i++) {
-                    rows[i] = options.objectRows
-                        ? parseObjectRow(parsers, rows[i].data, rows[i].columnCount, options, resultFields)
-                        : parseRow(parsers, rows[i].data, rows[i].columnCount, options);
+                    rows[i] = rowDecoder.decode(parsers, rows[i].data, rows[i].columnCount, options, resultFields);
                 }
             }
             if (result.command === 'DELETE' ||

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';
@@ -124,7 +125,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++;

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,9 +1,9 @@
 import { DataTypeOIDs } from '../constants.js';
+import { fastParseFloatBuffer } from '../util/fast-parsefloat.js';
 export const Float4Type = {
     name: 'float4',
     oid: DataTypeOIDs.float4,
     jsType: 'number',
-    fixedBinarySize: 4,
     encodeText(v) {
         return '' + v;
     },
@@ -14,9 +14,7 @@ export const Float4Type = {
         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,9 +1,9 @@
 import { DataTypeOIDs } from '../constants.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;
@@ -15,10 +15,7 @@ export const Float8Type = {
         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

@@ -4,7 +4,6 @@ export const Int2Type = {
     name: 'int2',
     oid: DataTypeOIDs.int2,
     jsType: 'number',
-    fixedBinarySize: 2,
     encodeText(v) {
         return '' + v;
     },

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

@@ -4,7 +4,6 @@ export const Int4Type = {
     name: 'int4',
     oid: DataTypeOIDs.int4,
     jsType: 'number',
-    fixedBinarySize: 4,
     encodeText(v) {
         return '' + v;
     },

package/data-types/int8-type.js

@@ -6,7 +6,6 @@ export const Int8Type = {
     name: 'int8',
     oid: DataTypeOIDs.int8,
     jsType: 'BigInt',
-    fixedBinarySize: 8,
     encodeText(v) {
         return '' + v;
     },

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,5 @@
 import { DataTypeOIDs } from '../constants.js';
+import { fastParseFloatBuffer } from '../util/fast-parsefloat.js';
 const NUMERIC_NEG = 0x4000;
 const NUMERIC_NAN = 0xc000;
 const NUMERIC_PINF = 0xd000;
@@ -109,10 +110,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

@@ -4,7 +4,6 @@ export const OidType = {
     name: 'oid',
     oid: DataTypeOIDs.oid,
     jsType: 'number',
-    fixedBinarySize: 4,
     encodeText(v) {
         return '' + v;
     },

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) {