postgrejs 3.1.2 → 3.3.0

package/protocol/smart-buffer.js

@@ -1,172 +1,29 @@
+import { FlexyBuffer } from 'flexy-buffer';
 import * as os from 'os';
-import { writeBigUInt64BE } from '../util/bigint-methods.js';
-import { BufferReader } from './buffer-reader.js';
-export class SmartBuffer extends BufferReader {
+/**
+ * Adds the PostgreSQL wire format's two string encodings on top of
+ * flexy-buffer's `FlexyBuffer`: a NUL-terminated C string, and a
+ * length-prefixed string where a `null`/`undefined` value is written as a
+ * length of -1 with no bytes following.
+ */
+export class SmartBuffer extends FlexyBuffer {
     static DEFAULT_PAGE_SIZE = 512;
     static DEFAULT_MAX_SIZE = Math.min(Math.floor(os.totalmem() / 2), 1024 * 1024 * 1024 * 2);
-    _houseKeepInterval;
-    _houseKeepTimer;
-    _stMaxPages = 1;
-    _length = 0;
-    pageSize;
-    maxSize;
     constructor(cfg) {
-        super(Buffer.allocUnsafe(cfg?.pageSize || SmartBuffer.DEFAULT_PAGE_SIZE));
-        this._houseKeepInterval = cfg?.houseKeepInterval || 5000;
-        this.pageSize = this.buffer.length;
-        this.maxSize = cfg?.maxLength || SmartBuffer.DEFAULT_MAX_SIZE;
-        this._length = 0;
-    }
-    get capacity() {
-        return this.buffer.length;
-    }
-    get length() {
-        return this._length;
-    }
-    start() {
-        this.offset = 0;
-        this._length = 0;
-        if (this._houseKeepTimer) {
-            clearTimeout(this._houseKeepTimer);
-            this._houseKeepTimer = undefined;
-        }
-        return this;
-    }
-    flush() {
-        if (this._houseKeepTimer)
-            clearTimeout(this._houseKeepTimer);
-        const length = this.length;
-        this._length = 0;
-        const out = Buffer.from(this.buffer.subarray(0, length));
-        const pages = length ? Math.ceil(length / this.pageSize) : 1;
-        this._stMaxPages = Math.max(this._stMaxPages, pages);
-        this._houseKeep();
-        if (this.buffer.length > this.pageSize) {
-            this._houseKeepTimer = setTimeout(() => {
-                this._houseKeepTimer = undefined;
-                this._houseKeep();
-            }, this._houseKeepInterval).unref();
-        }
-        return out;
-    }
-    growSize(len) {
-        const endOffset = this.offset + len;
-        if (this.capacity < endOffset) {
-            if (endOffset > this.maxSize)
-                throw new Error('Buffer limit exceeded.');
-            const byPage = Math.ceil(endOffset / this.pageSize) * this.pageSize;
-            const newSize = Math.min(Math.max(byPage, this.capacity * 2), this.maxSize);
-            const newBuffer = Buffer.allocUnsafe(newSize);
-            this.buffer.copy(newBuffer);
-            this.buffer = newBuffer;
-        }
-        this._length = Math.max(this.length, endOffset);
-        return this;
+        super({
+            pageSize: cfg?.pageSize || SmartBuffer.DEFAULT_PAGE_SIZE,
+            maxLength: cfg?.maxLength || SmartBuffer.DEFAULT_MAX_SIZE,
+            houseKeepMs: cfg?.houseKeepMs,
+        });
     }
     writeCString(str, encoding) {
-        const len = str ? Buffer.byteLength(str, encoding) : 0;
-        this.ensureSize(len + 1);
-        if (str) {
-            this.buffer.write(str, this.offset, encoding);
-            this.offset += len;
-        }
-        this.writeUInt8(0);
-        return this;
+        const written = this.writeString(str, encoding);
+        return written + this.writeUInt8(0);
     }
     writeLString(str, encoding) {
-        const len = str ? Buffer.byteLength(str, encoding) : 0;
-        this.ensureSize(len + 4);
-        this.writeInt32BE(str == null ? -1 : len);
-        if (str) {
-            if (encoding)
-                this.offset += this.buffer.write(str, this.offset, encoding);
-            else
-                this.offset += this.buffer.write(str, this.offset);
-        }
-        return this;
-    }
-    writeString(str, encoding) {
-        if (str) {
-            const len = Buffer.byteLength(str, encoding);
-            this.ensureSize(len);
-            this.offset += this.buffer.write(str, this.offset, encoding);
-        }
-        return this;
-    }
-    writeInt8(n) {
-        this.ensureSize(1);
-        this.buffer.writeInt8(n, this.offset);
-        this.offset++;
-        return this;
-    }
-    writeUInt8(n) {
-        this.ensureSize(1);
-        this.buffer.writeUInt8(n, this.offset);
-        this.offset++;
-        return this;
-    }
-    writeUInt16BE(n) {
-        this.ensureSize(2);
-        this.buffer.writeUInt16BE(n, this.offset);
-        this.offset += 2;
-        return this;
-    }
-    writeUInt32BE(n) {
-        this.ensureSize(4);
-        this.buffer.writeUInt32BE(n, this.offset);
-        this.offset += 4;
-        return this;
-    }
-    writeInt16BE(n) {
-        this.ensureSize(2);
-        this.buffer.writeInt16BE(n, this.offset);
-        this.offset += 2;
-        return this;
-    }
-    writeInt32BE(n) {
-        this.ensureSize(4);
-        this.buffer.writeInt32BE(n, this.offset);
-        this.offset += 4;
-        return this;
-    }
-    writeBigInt64BE(n) {
-        n = typeof n === 'bigint' ? n : BigInt(n);
-        this.ensureSize(8);
-        if (typeof this.buffer.writeBigInt64BE === 'function')
-            this.buffer.writeBigInt64BE(n, this.offset);
-        else
-            writeBigUInt64BE(this.buffer, n, this.offset);
-        this.offset += 8;
-        return this;
-    }
-    writeFloatBE(n) {
-        this.ensureSize(4);
-        this.buffer.writeFloatBE(n, this.offset);
-        this.offset += 4;
-        return this;
-    }
-    writeDoubleBE(n) {
-        this.ensureSize(8);
-        this.buffer.writeDoubleBE(n, this.offset);
-        this.offset += 8;
-        return this;
-    }
-    writeBuffer(buffer) {
-        this.ensureSize(buffer.length);
-        buffer.copy(this.buffer, this.offset, 0, buffer.length);
-        this.offset += buffer.length;
-        return this;
-    }
-    ensureSize(len) {
-        const n = this.offset + len - this.length;
-        if (n > 0)
-            this.growSize(n);
-        return this;
-    }
-    _houseKeep() {
-        const needSize = this._stMaxPages * this.pageSize;
-        if (this.buffer.length > needSize)
-            this.buffer = Buffer.allocUnsafe(needSize);
-        this._stMaxPages = this.length ? Math.ceil(this.length / this.pageSize) : 1;
+        if (str == null)
+            return this.writeInt32BE(-1);
+        const len = Buffer.byteLength(str, encoding);
+        return this.writeInt32BE(len) + this.writeString(str, encoding);
     }
 }

package/types.d.ts

@@ -5,7 +5,19 @@ export type Maybe<T> = T | undefined;
 export type Nullable<T> = T | null;
 export type Row = any;
 export type Callback = (err?: Error | null) => void;
-export type DecodeBinaryFunction = (buf: Buffer, offset: number, options: DataMappingOptions & Record<string, any>) => any;
+/**
+ * What a DataType's own `decodeBinary` implements. `buf` is a shared
+ * buffer - the whole row, or the whole array - and this value occupies
+ * exactly `len` bytes starting at `offset`.
+ *
+ * Honouring `len` is the implementation's responsibility, and reading past
+ * it is not a bounds error: it silently returns the next column's or
+ * element's bytes. A type whose binary form says how long it is - a fixed
+ * width like int4's four bytes, or a count it carries itself like
+ * numeric's - can ignore `len`; anything that would otherwise read "to the
+ * end of the buffer" must not.
+ */
+export type DecodeBinaryFunction = (buf: Buffer, offset: number, len: number, options: DataMappingOptions & Record<string, any>) => any;
 export type DecodeTextBufferFunction = (buf: Buffer, offset: number, len: number, options: DataMappingOptions & Record<string, any>) => any;
 export type EncodeBinaryFunction = (buf: SmartBuffer, v: any, options: DataMappingOptions) => void;
 export type EncodeCalculateDimFunction = (v: any[]) => number[];

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/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/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;