postgrejs 3.1.3 → 3.4.0

package/util/bigint-methods.d.ts

@@ -1,2 +1 @@
 export declare function readBigInt64BE(buf: Buffer, offset?: number): bigint;
-export declare function writeBigUInt64BE(buf: Buffer, value: BigInt, offset?: number): number;

package/util/bigint-methods.js

@@ -1,6 +1,5 @@
 /* eslint-disable */
 const big0 = BigInt(0);
-const beAnd = BigInt('0xffffffff');
 const big32 = BigInt(32);
 // https://github.com/nodejs/node/blob/v13.9.0/lib/internal/buffer.js
 export function readBigInt64BE(buf, offset = 0) {
@@ -18,24 +17,3 @@ export function readBigInt64BE(buf, offset = 0) {
             buf[++offset] * 2 ** 8 +
             last));
 }
-export function writeBigUInt64BE(buf, value, offset = 0) {
-    // @ts-ignore
-    let lo = Number(value & beAnd);
-    buf[offset + 7] = lo;
-    lo = lo >> 8;
-    buf[offset + 6] = lo;
-    lo = lo >> 8;
-    buf[offset + 5] = lo;
-    lo = lo >> 8;
-    buf[offset + 4] = lo;
-    // @ts-ignore
-    let hi = Number((value >> big32) & beAnd);
-    buf[offset + 3] = hi;
-    hi = hi >> 8;
-    buf[offset + 2] = hi;
-    hi = hi >> 8;
-    buf[offset + 1] = hi;
-    hi = hi >> 8;
-    buf[offset] = hi;
-    return offset + 8;
-}

package/util/copy-from-rows.d.ts

@@ -0,0 +1,56 @@
+import type { Readable } from 'node:stream';
+import type { CopyFromRowsOptions } from '../interfaces/copy-from-rows-options.js';
+import type { OID } from '../types.js';
+/** Default bytes accumulated before a CopyData message goes out. */
+export declare const DEFAULT_COPY_CHUNK_SIZE: number;
+export type CopyRow = any[] | Record<string, any>;
+export type CopyRowSource = Iterable<CopyRow> | AsyncIterable<CopyRow> | Readable;
+/**
+ * Quotes a possibly schema-qualified name. A single dot separates schema
+ * from table, which is what PostgreSQL's own client tools assume for a name
+ * given as one string; a table whose name genuinely contains a dot has to
+ * be reached through a view or a plain (unqualified) name instead.
+ */
+export declare function quoteQualifiedName(name: string): string;
+/**
+ * The statement whose RowDescription tells us the destination columns'
+ * type OIDs. `where false` keeps the server from producing rows for a
+ * Describe that is never followed by an Execute, and letting PostgreSQL
+ * resolve the name is the point: schemas, quoting, search_path and views
+ * all behave exactly as they will for the COPY itself, which parsing the
+ * name here could only approximate.
+ */
+export declare function buildProbeSql(table: string, columns?: string[]): string;
+export declare function buildCopySql(table: string, columns?: string[]): string;
+export interface CopyFromRowsContext {
+    columns: string[];
+    dataTypeIds: OID[];
+    options: CopyFromRowsOptions;
+    /**
+     * Sends one CopyData message, resolving once the socket has taken it -
+     * immediately when it had room, and only after it drains when it did
+     * not. Awaiting this is what makes backpressure reach the source: the
+     * `for await` below cannot ask for another row until it settles.
+     */
+    write: (chunk: Buffer) => Promise<void>;
+}
+/**
+ * Encodes `source` into binary COPY chunks and hands them to `write`,
+ * accumulating rows until a chunk is worth sending.
+ *
+ * The chunk size is the difference between this being fast and being
+ * pointless: one CopyData per row costs a message header and a socket write
+ * each time, which measured 1208ms against 129ms at 64KB for the same
+ * 200,000 rows. Sizes from 64KB to 256KB all land near the floor, so the
+ * default sits inside that range rather than at either edge.
+ *
+ * Pulls from `source` rather than being pushed into, so an async iterable -
+ * which every Readable is - only produces the next row once the previous
+ * chunk has been accepted, making backpressure the caller's own loop
+ * pausing rather than an unbounded queue here.
+ */
+export declare function writeCopyBinaryRows(source: CopyRowSource, ctx: CopyFromRowsContext): Promise<{
+    rowCount: number;
+    skippedRows: number;
+    nulledValues: number;
+}>;

package/util/copy-from-rows.js

@@ -0,0 +1,95 @@
+import { GlobalTypeMap } from '../data-type-map.js';
+import { SmartBuffer } from '../protocol/smart-buffer.js';
+import { assertCopyBinaryEncodable, COPY_BINARY_HEADER, COPY_BINARY_TRAILER, encodeCopyBinaryRow, } from './encode-copy-binary.js';
+import { escapeIdentifier } from './escape-identifier.js';
+/** Default bytes accumulated before a CopyData message goes out. */
+export const DEFAULT_COPY_CHUNK_SIZE = 128 * 1024;
+/**
+ * Quotes a possibly schema-qualified name. A single dot separates schema
+ * from table, which is what PostgreSQL's own client tools assume for a name
+ * given as one string; a table whose name genuinely contains a dot has to
+ * be reached through a view or a plain (unqualified) name instead.
+ */
+export function quoteQualifiedName(name) {
+    const dot = name.indexOf('.');
+    return dot < 0
+        ? escapeIdentifier(name)
+        : escapeIdentifier(name.slice(0, dot)) +
+            '.' +
+            escapeIdentifier(name.slice(dot + 1));
+}
+/**
+ * The statement whose RowDescription tells us the destination columns'
+ * type OIDs. `where false` keeps the server from producing rows for a
+ * Describe that is never followed by an Execute, and letting PostgreSQL
+ * resolve the name is the point: schemas, quoting, search_path and views
+ * all behave exactly as they will for the COPY itself, which parsing the
+ * name here could only approximate.
+ */
+export function buildProbeSql(table, columns) {
+    const cols = columns?.length ? columns.map(escapeIdentifier).join(', ') : '*';
+    return `select ${cols} from ${quoteQualifiedName(table)} where false`;
+}
+export function buildCopySql(table, columns) {
+    const cols = columns?.length
+        ? ' (' + columns.map(escapeIdentifier).join(', ') + ')'
+        : '';
+    return (`copy ${quoteQualifiedName(table)}${cols} ` +
+        `from stdin with (format binary)`);
+}
+/** Positional array, or an object read by column name. */
+function toValues(row, columns) {
+    if (Array.isArray(row))
+        return row;
+    const l = columns.length;
+    const out = new Array(l);
+    let i;
+    for (i = 0; i < l; i++)
+        out[i] = row[columns[i]];
+    return out;
+}
+/**
+ * Encodes `source` into binary COPY chunks and hands them to `write`,
+ * accumulating rows until a chunk is worth sending.
+ *
+ * The chunk size is the difference between this being fast and being
+ * pointless: one CopyData per row costs a message header and a socket write
+ * each time, which measured 1208ms against 129ms at 64KB for the same
+ * 200,000 rows. Sizes from 64KB to 256KB all land near the floor, so the
+ * default sits inside that range rather than at either edge.
+ *
+ * Pulls from `source` rather than being pushed into, so an async iterable -
+ * which every Readable is - only produces the next row once the previous
+ * chunk has been accepted, making backpressure the caller's own loop
+ * pausing rather than an unbounded queue here.
+ */
+export async function writeCopyBinaryRows(source, ctx) {
+    const { columns, dataTypeIds, options } = ctx;
+    const typeMap = options.typeMap || GlobalTypeMap;
+    assertCopyBinaryEncodable(dataTypeIds, columns, typeMap);
+    const chunkSize = options.chunkSize || DEFAULT_COPY_CHUNK_SIZE;
+    const io = new SmartBuffer();
+    io.start();
+    io.writeBytes(COPY_BINARY_HEADER);
+    const onInvalidValue = options.onInvalidValue || 'throw';
+    let rowCount = 0;
+    let skippedRows = 0;
+    const stats = { nulled: 0 };
+    let index = 0;
+    for await (const row of source) {
+        const written = encodeCopyBinaryRow(io, toValues(row, columns), dataTypeIds, columns, typeMap, options, index, onInvalidValue, stats);
+        index++;
+        if (!written) {
+            skippedRows++;
+            continue;
+        }
+        rowCount++;
+        if (io.size >= chunkSize) {
+            await ctx.write(io.flush());
+            io.start();
+        }
+    }
+    io.writeBytes(COPY_BINARY_TRAILER);
+    await ctx.write(io.flush());
+    return { rowCount, skippedRows, nulledValues: stats.nulled };
+}

package/util/decode-binaryarray.d.ts

@@ -1,3 +1,3 @@
 import type { DataMappingOptions } from '../interfaces/data-mapping-options.js';
 import type { DecodeBinaryFunction, Nullable } from '../types.js';
-export declare function decodeBinaryArray<T = any>(buf: Buffer, offset: number, decoder: DecodeBinaryFunction, options?: DataMappingOptions, fixedBinarySize?: number): Nullable<T[]>;
+export declare function decodeBinaryArray<T = any>(buf: Buffer, offset: number, decoder: DecodeBinaryFunction, options?: DataMappingOptions): Nullable<T[]>;

package/util/decode-binaryarray.js

@@ -1,9 +1,9 @@
 import { BufferReader } from '../protocol/buffer-reader.js';
-export function decodeBinaryArray(buf, offset, decoder, options = {}, fixedBinarySize) {
+export function decodeBinaryArray(buf, offset, decoder, options = {}) {
     if (!buf.length)
         return null;
     const io = new BufferReader(buf);
-    io.offset = offset;
+    io.position = offset;
     const ndims = io.readInt32BE();
     io.readInt32BE(); // hasNulls
     const elementOID = io.readInt32BE(); // element oid
@@ -26,12 +26,12 @@ export function decodeBinaryArray(buf, offset, decoder, options = {}, fixedBinar
             len = io.readInt32BE();
             if (len === -1)
                 target[i] = null;
-            else if (fixedBinarySize != null) {
-                target[i] = decoder(buf, io.offset, elementOptions);
-                io.offset += len;
-            }
             else {
-                target[i] = decoder(io.readBuffer(len), 0, elementOptions);
+                // Every element carries its own length on the wire, so the decoder
+                // can be pointed straight at it - no bounded slice per element,
+                // whether or not the element type has a fixed binary size.
+                target[i] = decoder(buf, io.position, len, elementOptions);
+                io.position += len;
             }
         }
         return target;

package/util/encode-binaryarray.js

@@ -5,10 +5,10 @@ export function encodeBinaryArray(io, value, itemOid, options, encode, encodeCal
     itemOid = itemOid || DataTypeOIDs.varchar;
     const dim = encodeCalculateDimFn(value);
     const ndims = dim.length;
-    const zeroOffset = io.offset;
-    io.writeInt32BE(ndims) // Number of dimensions
-        .writeInt32BE(0) // reserved for has-null flag
-        .writeInt32BE(itemOid);
+    const zeroOffset = io.position;
+    io.writeInt32BE(ndims); // Number of dimensions
+    io.writeInt32BE(0); // reserved for has-null flag
+    io.writeInt32BE(itemOid);
     let d;
     for (d = 0; d < ndims; d++) {
         io.writeInt32BE(dim[d]); // Number of items in dimension
@@ -33,10 +33,10 @@ export function encodeBinaryArray(io, value, itemOid, options, encode, encodeCal
                 continue;
             }
             io.writeInt32BE(0); // reserved for data len
-            pos = io.offset;
+            pos = io.position;
             encode(io, arr[i], options);
             // Update item data size
-            io.buffer.writeInt32BE(io.length - pos, pos - 4);
+            io.buffer.writeInt32BE(io.size - pos, pos - 4);
         }
     };
     writeDim(value, 0);

package/util/encode-copy-binary.d.ts

@@ -0,0 +1,48 @@
+import type { DataTypeMap } from '../data-type-map.js';
+import type { DataMappingOptions } from '../interfaces/data-mapping-options.js';
+import type { SmartBuffer } from '../protocol/smart-buffer.js';
+import type { OID } from '../types.js';
+/**
+ * `PGCOPY\n\377\r\n\0` followed by two int32 words: a flags field and the
+ * length of a header extension area. Bit 16 of the flags marks a stream
+ * that carries an OID per row - an obsolete variant PostgreSQL still reads
+ * but nothing should write - so both words are zero here.
+ */
+export declare const COPY_BINARY_HEADER: Buffer<ArrayBuffer>;
+/** A field count of -1 where a row would start, ending the stream. */
+export declare const COPY_BINARY_TRAILER: Buffer<ArrayBuffer>;
+/**
+ * Appends one row to `io` in PostgreSQL's binary COPY format: an int16
+ * field count, then per field an int32 byte length followed by that many
+ * bytes, with -1 standing in for NULL.
+ *
+ * Each value is written by its own type's `encodeBinary`, which is the same
+ * function a binary query parameter goes through (see Frontend's Bind) -
+ * both are the type's `send` representation, so there is one encoder per
+ * type rather than a COPY-specific set.
+ *
+ * Binary COPY performs no conversion on the server: the bytes have to be
+ * exactly what the destination column's type expects. `dataTypeIds` must
+ * therefore be the column's own OIDs, which is why the caller obtains them
+ * from the server rather than inferring them from the JavaScript values.
+ *
+ * @param rowIndex Only used to say which row failed, since a value that
+ *   cannot be encoded otherwise surfaces from the server as an opaque
+ *   "incorrect binary data format" naming neither row nor column.
+ * @returns Whether the row was written - false only under `'skip'`, where
+ *   the partial row has already been unwound.
+ */
+export declare function encodeCopyBinaryRow(io: SmartBuffer, values: any[], dataTypeIds: OID[], columnNames: string[], typeMap: DataTypeMap, options: DataMappingOptions, rowIndex: number, onInvalidValue?: 'throw' | 'null' | 'skip', 
+/** Incremented per value replaced under `'null'`; counted here rather
+ * than inferred by the caller, which cannot see inside a written row. */
+stats?: {
+    nulled: number;
+}): boolean;
+/**
+ * Fails before a single byte goes out when any column's type cannot be
+ * written in binary. Worth doing up front: once the server has answered
+ * CopyInResponse it is waiting for a complete stream, so discovering an
+ * unencodable column at row 900,000 means aborting a copy that was already
+ * most of the way done.
+ */
+export declare function assertCopyBinaryEncodable(dataTypeIds: OID[], columnNames: string[], typeMap: DataTypeMap): void;

package/util/encode-copy-binary.js

@@ -0,0 +1,112 @@
+import { encodeBinaryArray } from './encode-binaryarray.js';
+/**
+ * `PGCOPY\n\377\r\n\0` followed by two int32 words: a flags field and the
+ * length of a header extension area. Bit 16 of the flags marks a stream
+ * that carries an OID per row - an obsolete variant PostgreSQL still reads
+ * but nothing should write - so both words are zero here.
+ */
+export const COPY_BINARY_HEADER = Buffer.from([
+    0x50, 0x47, 0x43, 0x4f, 0x50, 0x59, 0x0a, 0xff, 0x0d, 0x0a, 0x00, 0, 0, 0, 0,
+    0, 0, 0, 0,
+]);
+/** A field count of -1 where a row would start, ending the stream. */
+export const COPY_BINARY_TRAILER = Buffer.from([0xff, 0xff]);
+/**
+ * Appends one row to `io` in PostgreSQL's binary COPY format: an int16
+ * field count, then per field an int32 byte length followed by that many
+ * bytes, with -1 standing in for NULL.
+ *
+ * Each value is written by its own type's `encodeBinary`, which is the same
+ * function a binary query parameter goes through (see Frontend's Bind) -
+ * both are the type's `send` representation, so there is one encoder per
+ * type rather than a COPY-specific set.
+ *
+ * Binary COPY performs no conversion on the server: the bytes have to be
+ * exactly what the destination column's type expects. `dataTypeIds` must
+ * therefore be the column's own OIDs, which is why the caller obtains them
+ * from the server rather than inferring them from the JavaScript values.
+ *
+ * @param rowIndex Only used to say which row failed, since a value that
+ *   cannot be encoded otherwise surfaces from the server as an opaque
+ *   "incorrect binary data format" naming neither row nor column.
+ * @returns Whether the row was written - false only under `'skip'`, where
+ *   the partial row has already been unwound.
+ */
+export function encodeCopyBinaryRow(io, values, dataTypeIds, columnNames, typeMap, options, rowIndex, onInvalidValue = 'throw', 
+/** Incremented per value replaced under `'null'`; counted here rather
+ * than inferred by the caller, which cannot see inside a written row. */
+stats) {
+    const rowStart = io.size;
+    const l = dataTypeIds.length;
+    io.writeInt16BE(l);
+    let i;
+    let v;
+    for (i = 0; i < l; i++) {
+        v = values[i];
+        if (v === null || v === undefined) {
+            io.writeInt32BE(-1);
+            continue;
+        }
+        const dt = typeMap.get(dataTypeIds[i]);
+        /* c8 ignore next 5 - unreachable: assertCopyBinaryEncodable() rejects
+           every column whose type has no encodeBinary before any row is
+           encoded, so this is a guard against a type map mutated mid-copy. */
+        if (!dt?.encodeBinary) {
+            throw new Error(`Column "${columnNames[i]}" has no binary encoder (type OID ${dataTypeIds[i]})`);
+        }
+        if (dt.encodeAsNull?.(v, options)) {
+            io.writeInt32BE(-1);
+            continue;
+        }
+        io.writeInt32BE(0); // placeholder, backfilled below
+        const dataOffset = io.position;
+        try {
+            if (dt.elementsOID) {
+                encodeBinaryArray(io, Array.isArray(v) ? v : [v], dt.elementsOID, options, dt.encodeBinary, dt.encodeCalculateDim);
+            }
+            else {
+                dt.encodeBinary(io, v, options);
+            }
+        }
+        catch (e) {
+            if (onInvalidValue === 'skip') {
+                // Unwind the partial row so the stream never carries half of it.
+                io.setSize(rowStart);
+                io.position = rowStart;
+                return false;
+            }
+            if (onInvalidValue === 'null') {
+                io.setSize(dataOffset);
+                io.position = dataOffset - 4;
+                io.writeInt32BE(-1);
+                if (stats)
+                    stats.nulled++;
+                continue;
+            }
+            throw new Error(`Cannot encode row ${rowIndex}, column "${columnNames[i]}" (${dt.name}): ${e.message}`, { cause: e });
+        }
+        io.buffer.writeInt32BE(io.size - dataOffset, dataOffset - 4);
+    }
+    return true;
+}
+/**
+ * Fails before a single byte goes out when any column's type cannot be
+ * written in binary. Worth doing up front: once the server has answered
+ * CopyInResponse it is waiting for a complete stream, so discovering an
+ * unencodable column at row 900,000 means aborting a copy that was already
+ * most of the way done.
+ */
+export function assertCopyBinaryEncodable(dataTypeIds, columnNames, typeMap) {
+    const missing = [];
+    const l = dataTypeIds.length;
+    let i;
+    for (i = 0; i < l; i++) {
+        const dt = typeMap.get(dataTypeIds[i]);
+        if (!dt?.encodeBinary)
+            missing.push(`"${columnNames[i]}" (OID ${dataTypeIds[i]})`);
+    }
+    if (missing.length) {
+        throw new Error(`Binary COPY cannot encode ${missing.join(', ')} - no binary encoder is ` +
+            `registered for that type. Use copyFrom() with a text format instead.`);
+    }
+}

package/util/fast-parsefloat.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Decodes a decimal number straight out of `buf`, without materialising the
+ * intermediate string `parseFloat(buf.toString(...))` needs - measured at
+ * over half the cost of decoding a float column.
+ *
+ * Only takes that shortcut when the result is provably identical to what
+ * parseFloat() would return: when the mantissa's digits fit exactly in a
+ * double and the decimal exponent is small enough that its power of ten
+ * does too, a single multiply (or divide) of two exact values is by
+ * definition correctly rounded. Everything else - more digits than that,
+ * a large exponent, `NaN`/`Infinity`, a leading `+`, whitespace, anything
+ * malformed - falls through to parseFloat() itself, so those values are
+ * decoded exactly as before.
+ */
+export declare function fastParseFloatBuffer(buf: Buffer, offset?: number, len?: number): number;

package/util/fast-parsefloat.js

@@ -0,0 +1,141 @@
+// 10^0 .. 10^22 - every one of these is exactly representable as a double,
+// which is what makes the single multiply/divide below correctly rounded.
+// 10^23 is the first that isn't, so the table stops here deliberately.
+const POW10 = [
+    1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14,
+    1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22,
+];
+const MAX_EXACT_EXPONENT = 22;
+// 10^15 - 1 still fits well inside 2^53, so a mantissa of at most this many
+// digits is carried exactly.
+const MAX_EXACT_DIGITS = 15;
+/**
+ * Decodes a decimal number straight out of `buf`, without materialising the
+ * intermediate string `parseFloat(buf.toString(...))` needs - measured at
+ * over half the cost of decoding a float column.
+ *
+ * Only takes that shortcut when the result is provably identical to what
+ * parseFloat() would return: when the mantissa's digits fit exactly in a
+ * double and the decimal exponent is small enough that its power of ten
+ * does too, a single multiply (or divide) of two exact values is by
+ * definition correctly rounded. Everything else - more digits than that,
+ * a large exponent, `NaN`/`Infinity`, a leading `+`, whitespace, anything
+ * malformed - falls through to parseFloat() itself, so those values are
+ * decoded exactly as before.
+ */
+export function fastParseFloatBuffer(buf, offset = 0, len = buf.length - offset) {
+    const end = offset + len;
+    // The longest value the exact path can possibly take is a sign, 15
+    // mantissa digits, a decimal point and a two-digit exponent with its own
+    // sign. Anything longer is going to parseFloat() regardless, so check
+    // that up front rather than after scanning digits that get discarded.
+    if (len > 21)
+        return parseFloat(buf.toString('latin1', offset, end));
+    let i = offset;
+    let negative = false;
+    if (i < end && buf[i] === 45 /* - */) {
+        negative = true;
+        i++;
+    }
+    let mantissa = 0;
+    let digits = 0;
+    let fractionDigits = 0;
+    let seenDot = false;
+    let c;
+    while (i < end) {
+        c = buf[i];
+        if (c >= 48 && c <= 57) {
+            // Bailing out the moment the mantissa outgrows what a double holds
+            // exactly, rather than after the loop: a long numeric's digits would
+            // otherwise all be scanned before being thrown away.
+            if (++digits > MAX_EXACT_DIGITS)
+                return parseFloat(buf.toString('latin1', offset, end));
+            mantissa = mantissa * 10 + (c - 48);
+            if (seenDot)
+                fractionDigits++;
+        }
+        else if (c === 46 /* . */ && !seenDot) {
+            seenDot = true;
+        }
+        else
+            break;
+        i++;
+    }
+    if (!digits)
+        return parseFloat(buf.toString('latin1', offset, end));
+    let exponent = 0;
+    if (i < end && ((c = buf[i]) === 101 /* e */ || c === 69) /* E */) {
+        i++;
+        let expNegative = false;
+        if (i < end) {
+            c = buf[i];
+            if (c === 45 /* - */) {
+                expNegative = true;
+                i++;
+            }
+            else if (c === 43 /* + */)
+                i++;
+        }
+        let expDigits = 0;
+        let value = 0;
+        while (i < end) {
+            c = buf[i];
+            if (c < 48 || c > 57)
+                break;
+            value = value * 10 + (c - 48);
+            // Pinned at a value far outside the exact range instead of being
+            // allowed to grow without bound. It must never be *truncated* toward
+            // a plausible one: an exponent quietly cut from 234 to 23 would be
+            // taken as exact and decode to a wrong number rather than falling
+            // back. Since the fractional digits that offset it number at most
+            // MAX_EXACT_DIGITS, nothing this large can come back into range.
+            if (value > 1000)
+                value = 1000;
+            expDigits++;
+            i++;
+        }
+        if (!expDigits)
+            return parseFloat(buf.toString('latin1', offset, end));
+        exponent = expNegative ? -value : value;
+    }
+    // The `| 0` is not redundant: without it this is -0 whenever there is
+    // nothing to subtract (any value with no fractional digits, e.g. "42").
+    // A -0 index can't be a small integer, so POW10[exponent] below misses
+    // V8's fast element access and takes a generic property lookup instead -
+    // and the site stays generic afterwards, slowing down every later value
+    // too, not just the one that poisoned it.
+    exponent = (exponent - fractionDigits) | 0;
+    // Trailing characters mean this wasn't a plain decimal number after all.
+    if (i !== end)
+        return parseFloat(buf.toString('latin1', offset, end));
+    let n;
+    if (exponent >= 0) {
+        if (exponent > MAX_EXACT_EXPONENT) {
+            // Too large a power of ten to be exact on its own, but the surplus
+            // can often be folded into the mantissa instead: if the mantissa is
+            // small enough that scaling it up stays a whole number a double
+            // holds exactly, both operands of the multiply below are still
+            // exact, so its single rounding is still the correct one. This is
+            // what keeps values like 1.2345678e+30 (a mantissa of only eight
+            // digits) on the exact path.
+            const shift = exponent - MAX_EXACT_EXPONENT;
+            if (shift > MAX_EXACT_EXPONENT)
+                return parseFloat(buf.toString('latin1', offset, end));
+            const scaled = mantissa * POW10[shift];
+            if (scaled > Number.MAX_SAFE_INTEGER)
+                return parseFloat(buf.toString('latin1', offset, end));
+            mantissa = scaled;
+            exponent = MAX_EXACT_EXPONENT;
+        }
+        n = mantissa * POW10[exponent];
+    }
+    else {
+        if (exponent < -MAX_EXACT_EXPONENT)
+            return parseFloat(buf.toString('latin1', offset, end));
+        n = mantissa / POW10[-exponent];
+    }
+    // `0 * -1` is -0, which is the value PostgreSQL's own "-0" has to decode
+    // to - so the sign is applied by multiplication rather than negation of
+    // a separately built positive result.
+    return negative ? n * -1 : n;
+}

package/util/get-parsers.js

@@ -17,16 +17,12 @@ export function getParsers(typeMap, fields) {
                 const decode = dataTypeReg.decodeBinary;
                 if (decode) {
                     if (isArray) {
-                        parsers[i] = (data, offset, len, options) => decodeBinaryArray(data, offset, decode, options, dataTypeReg.fixedBinarySize);
-                    }
-                    else if (dataTypeReg.fixedBinarySize != null) {
-                        const fixedSize = dataTypeReg.fixedBinarySize;
-                        parsers[i] = (data, offset, len, options) => len === fixedSize
-                            ? decode(data, offset, options)
-                            : decode(data.subarray(offset, offset + len), 0, options);
+                        parsers[i] = (data, offset, len, options) => decodeBinaryArray(data, offset, decode, options);
                     }
                     else {
-                        parsers[i] = (data, offset, len, options) => decode(data.subarray(offset, offset + len), 0, options);
+                        // Straight through: decodeBinary is told where its value starts
+                        // and how long it is, so there is nothing to slice first.
+                        parsers[i] = decode;
                     }
                 }
             }

package/util/parse-datetime.js

@@ -1,5 +1,6 @@
 // noinspection RegExpUnnecessaryNonCapturingGroup
 import { fastParseInt } from './fast-parseint.js';
+import { parsePgTimestampString } from './parse-pg-timestamp.js';
 // noinspection RegExpUnnecessaryNonCapturingGroup
 const TIMESTAMP_PATTERN = /^(\d{4})-?(0[1-9]|1[012])?-?([123]0|[012][1-9]|31)?(?:[T ]?([01][0-9]|2[0-3]):?([0-5][0-9]):?([0-5][0-9])?(?:\.(\d+))?(?:(Z)|(?:([+-])([01]?[0-9]|2[0-3]):?([0-5][0-9])?))?)?$/;
 function noMatch(str) {
@@ -45,6 +46,9 @@ export function parseDateTime(str, utc) {
             return Infinity;
         if (str === '-infinity')
             return -Infinity;
+        const fast = parsePgTimestampString(str);
+        if (fast)
+            return fast;
         const d = new Date(str);
         if (!isNaN(d.getTime()))
             return d;
@@ -73,6 +77,9 @@ export function parseDateTimeTz(str, utc) {
         return Infinity;
     if (str === '-infinity')
         return -Infinity;
+    const fast = parsePgTimestampString(str);
+    if (fast)
+        return fast;
     const native = new Date(str);
     if (!isNaN(native.getTime()))
         return native;

package/util/parse-pg-timestamp.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Decodes the exact shape PostgreSQL's own ISO output uses -
+ * `YYYY-MM-DD HH:MM:SS[.f+][(+|-)HH[:MM]]` - straight out of the wire
+ * bytes, instead of building a string and handing that to the engine's
+ * general-purpose date parser. `new Date(str)` costs ~150ns per value and
+ * dominates decode time on timestamp-heavy result sets; even the string
+ * this replaces costs ~43ns to materialise before any parsing starts.
+ *
+ * Returns undefined for anything that isn't *exactly* that shape, so every
+ * other input (compact forms, `T` separators, a `BC` suffix, years outside
+ * 1000-9999, LMT-style ±HH:MM:SS offsets) falls through to the original
+ * `new Date()`/regex path and keeps its existing result - including the
+ * engine's own quirks, which callers may already depend on:
+ * `0001-01-01` parsing as year 2001, and `-04:56:02` offsets being
+ * rejected outright.
+ *
+ * A missing offset means local time, matching what `new Date(str)` does
+ * with a space-separated, offset-less timestamp.
+ */
+export declare function parsePgTimestampBuffer(buf: Buffer, offset: number, end: number): Date | undefined;
+/**
+ * The same scan for a value that is already a string - the array-element
+ * and string-parameter paths, which never see the wire bytes.
+ *
+ * Copying into a scratch buffer first still beats scanning the string
+ * directly through a second, parallel implementation: the copy costs about
+ * half of what materialising the string cost in the first place, and there
+ * is only one scanner to keep correct. Safe to share one buffer because
+ * the copy and the scan that reads it are a single synchronous step.
+ */
+export declare function parsePgTimestampString(str: string): Date | undefined;