postgrejs 3.6.1 → 3.8.0

package/data-types/timetz-type.js

@@ -0,0 +1,184 @@
+import { DataTypeOIDs } from '../constants.js';
+import { readBigInt64BE } from '../util/bigint-methods.js';
+/**
+ * `timetz` decodes to a string, alone among the date/time types, and the
+ * reason is the one thing that distinguishes it from `time`: the offset.
+ * A JavaScript Date has no field for one. Handing back a Date would mean
+ * either dropping the offset - throwing away the only part that makes
+ * this type different - or folding it into the instant, so that
+ * `12:00:00+03` and `09:00:00+00` became indistinguishable and writing
+ * the value back changed it. The string keeps both parts, is exactly what
+ * the server printed, and casts straight back. `pg` also leaves it a
+ * string.
+ *
+ * PostgreSQL's own documentation calls this type's definition of
+ * questionable usefulness - a time with no date cannot resolve a real
+ * zone, only a fixed offset - which is a further reason not to invent a
+ * richer representation for it here.
+ */
+/**
+ * Hours may reach 24 (`24:00:00` is a legal `timetz`), the fraction is
+ * microseconds, and the offset may carry seconds - `12:34:56+03:00:30`
+ * is a value the server stores and prints.
+ */
+const TIMETZ_PATTERN = /^\s*(\d{1,2}):(\d{1,2})(?::(\d{1,2}))?(?:\.(\d{1,6}))?\s*(?:(Z|z)|([+-])(\d{1,2})(?::?(\d{2}))?(?::?(\d{2}))?)?\s*$/;
+const MICROS_PER_DAY = 86400000000;
+/** What the server accepts: ±15:59:59, and ±16 is out of range. */
+const MAX_ZONE_SECONDS = 15 * 3600 + 59 * 60 + 59;
+const pad = (n) => (n < 10 ? '0' + n : '' + n);
+function parseTimeTzText(v) {
+    const m = TIMETZ_PATTERN.exec(v);
+    if (!m)
+        throw new Error(`"${v}" is not a valid timetz value`);
+    if (!m[5] && !m[6]) {
+        // The server would resolve this against the session's time zone,
+        // which is not knowable here - and guessing the Node process's zone
+        // instead would silently shift the value. The text path does not go
+        // through this function and still accepts the bare form, since there
+        // the server does the resolving itself.
+        throw new Error(`"${v}" has no time zone offset - give it one ("12:34:56+03"), or ` +
+            'pass a Date, whose own offset is used');
+    }
+    const hours = +m[1];
+    const minutes = +m[2];
+    const seconds = m[3] ? +m[3] : 0;
+    const micros = ((hours * 60 + minutes) * 60 + seconds) * 1000000 +
+        (m[4] ? +m[4].padEnd(6, '0') : 0);
+    if (minutes > 59 || seconds > 59 || micros > MICROS_PER_DAY)
+        throw new Error(`"${v}" is out of range for a timetz value`);
+    let zone = 0;
+    if (m[6]) {
+        zone = +m[7] * 3600 + (m[8] ? +m[8] : 0) * 60 + (m[9] ? +m[9] : 0);
+        if (zone > MAX_ZONE_SECONDS)
+            throw new Error(`"${v}" has a time zone displacement out of range`);
+        // Stored west-positive, the opposite sign from the way it is written.
+        if (m[6] === '+')
+            zone = -zone;
+    }
+    return { micros, zone };
+}
+/**
+ * A Date carries no offset of its own, but its local components and the
+ * zone they are read in go together: `getHours()` means "in the local
+ * zone", so that zone's offset is the value's, not a guess. Under
+ * `utcDates` the encoders read UTC components instead, and then the
+ * offset that matches is zero - the same rule the rest of the date/time
+ * types follow.
+ */
+function fromDate(v, options) {
+    const utc = !!options.utcDates;
+    const hours = utc ? v.getUTCHours() : v.getHours();
+    const minutes = utc ? v.getUTCMinutes() : v.getMinutes();
+    const seconds = utc ? v.getUTCSeconds() : v.getSeconds();
+    const ms = utc ? v.getUTCMilliseconds() : v.getMilliseconds();
+    return {
+        micros: (((hours * 60 + minutes) * 60 + seconds) * 1000 + ms) * 1000,
+        // getTimezoneOffset() is already minutes west of UTC, the same
+        // direction the wire uses.
+        zone: utc ? 0 : v.getTimezoneOffset() * 60,
+    };
+}
+function toParts(v, options) {
+    if (typeof v === 'string')
+        return parseTimeTzText(v);
+    if (v instanceof Date)
+        return fromDate(v, options);
+    throw new TypeError(`"${typeof v}" cannot be encoded as a timetz - pass the string form ` +
+        'with its offset, or a Date');
+}
+/**
+ * Prints what the server prints: the clock time, then microseconds with
+ * trailing zeroes dropped and the whole fraction omitted when it is zero,
+ * then the offset - always with hours, with minutes when they are not
+ * zero and seconds only when they are not either.
+ */
+function formatTimeTz(micros, zone) {
+    const us = micros % 1000000;
+    let rest = (micros - us) / 1000000;
+    const seconds = rest % 60;
+    rest = (rest - seconds) / 60;
+    const minutes = rest % 60;
+    const hours = (rest - minutes) / 60;
+    let out = pad(hours) + ':' + pad(minutes) + ':' + pad(seconds);
+    if (us)
+        out += '.' + String(us).padStart(6, '0').replace(/0+$/, '');
+    // Back to the way it is written, east-positive.
+    let z = -zone;
+    out += z < 0 ? '-' : '+';
+    if (z < 0)
+        z = -z;
+    const zs = z % 60;
+    z = (z - zs) / 60;
+    const zm = z % 60;
+    out += pad((z - zm) / 60);
+    if (zm || zs)
+        out += ':' + pad(zm);
+    if (zs)
+        out += ':' + pad(zs);
+    return out;
+}
+export const TimeTzType = {
+    name: 'timetz',
+    oid: DataTypeOIDs.timetz,
+    jsType: 'string',
+    // `time` already claims any string that looks like a clock time,
+    // offset and all, so inference here would only take those strings away
+    // from it - and a plain "12:34:56" is far more often a `time`. Name
+    // this type to reach it: `new BindParam(DataTypeOIDs.timetz, v)`.
+    inferrable: false,
+    /**
+     * Twelve bytes: microseconds since midnight as an int64, then the zone
+     * as an int32 of seconds west of UTC.
+     */
+    decodeBinary(v, offset = 0) {
+        const micros = typeof v.readBigInt64BE === 'function'
+            ? v.readBigInt64BE(offset)
+            : readBigInt64BE(v, offset);
+        // A day of microseconds is far inside the safe integer range, so
+        // this is only about the wire type, not the value.
+        return formatTimeTz(Number(micros), v.readInt32BE(offset + 8));
+    },
+    encodeBinary(buf, v, options) {
+        const p = toParts(v, options);
+        buf.writeBigInt64BE(BigInt(p.micros));
+        buf.writeInt32BE(p.zone);
+    },
+    decodeText(v) {
+        return v;
+    },
+    encodeText(v, options) {
+        // A string goes over as written - the server accepts spellings this
+        // file does not have to know, including a bare time, which it
+        // resolves against the session's own zone.
+        if (typeof v === 'string')
+            return v;
+        const p = toParts(v, options);
+        return formatTimeTz(p.micros, p.zone);
+    },
+    // Digits, colons and a sign - see inet-type.ts for why 'latin1'.
+    decodeTextBuffer(buf, offset, len) {
+        return buf.toString('latin1', offset, offset + len);
+    },
+    isType(v) {
+        // The type's own JavaScript shape is the string the server prints,
+        // which always carries an offset. A Date is accepted by the encoder
+        // as a convenience, but it is `time`'s shape, not this one's - the
+        // same line IntervalType draws between what it encodes and what it
+        // claims.
+        if (typeof v !== 'string')
+            return false;
+        try {
+            parseTimeTzText(v);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+};
+export const ArrayTimeTzType = {
+    ...TimeTzType,
+    name: '_timetz',
+    oid: DataTypeOIDs._timetz,
+    elementsOID: DataTypeOIDs.timetz,
+};

package/data-types/tsvector-type.d.ts

@@ -0,0 +1,5 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const TsVectorType: DataType;
+export declare const ArrayTsVectorType: DataType;
+export declare const TsQueryType: DataType;
+export declare const ArrayTsQueryType: DataType;

package/data-types/tsvector-type.js

@@ -0,0 +1,216 @@
+import { DataTypeOIDs } from '../constants.js';
+/**
+ * `tsvector` and `tsquery` decode to the strings PostgreSQL prints -
+ * `'cat':1,3 'dog':2` and `'a' & !'b'` - and encode by handing a string
+ * straight back to the server. They share this file because they share
+ * that decision and half their quoting.
+ *
+ * **Why the text form.** It is the canonical spelling of both types: what
+ * the server accepts back, what the documentation is written in, and what
+ * someone inspecting an indexed document or a stored search wants to
+ * read. A structure of lexemes and positions, or a query tree, would be a
+ * second representation to convert to and from for values that are
+ * produced by `to_tsvector`/`to_tsquery` and consumed by a match
+ * operator, rather than walked. `pg` leaves both as strings.
+ *
+ * **Why no encodeBinary.** The server's own input parser is what defines
+ * these values. A `tsvector` literal is sorted and deduplicated on the
+ * way in, by a byte ordering and a position-merging rule that belong to
+ * the server; a `tsquery` literal is a small expression language, with
+ * operators that have been added across releases. Re-implementing either
+ * here would mean `'b a'::tsvector` or `'a<->b'::tsquery` quietly meaning
+ * one thing as a literal and another as a parameter, depending only on
+ * which column format the value travelled in. Handing the string over
+ * instead makes them the same by construction - the cost is that these
+ * two types cannot appear in a binary `COPY`, which `copyFrom` reports
+ * by name before it writes a row.
+ *
+ * Decoding is a different matter and is done here: the tree has already
+ * been built by the server, so reading it back is not parsing a grammar.
+ */
+/** The four weights, in the order the top two bits of a position hold. */
+const VECTOR_WEIGHTS = ['', 'C', 'B', 'A'];
+/** The weights a query value carries, as a bit each. */
+const QUERY_WEIGHTS = [
+    [8, 'A'],
+    [4, 'B'],
+    [2, 'C'],
+    [1, 'D'],
+];
+const POSITION_MASK = 0x3fff;
+const QI_VAL = 1;
+const OP_NOT = 1;
+const OP_AND = 2;
+const OP_OR = 3;
+const OP_PHRASE = 4;
+/**
+ * How tightly each operator binds, which is what decides where the
+ * server puts parentheses - and so where this has to put them too.
+ */
+const PRIORITY = {
+    [OP_NOT]: 4,
+    [OP_PHRASE]: 3,
+    [OP_AND]: 2,
+    [OP_OR]: 1,
+};
+/** A lexeme is printed quoted, with `'` doubled and `\` escaped. */
+function quote(lexeme) {
+    let out = "'";
+    const l = lexeme.length;
+    let i;
+    let c;
+    for (i = 0; i < l; i++) {
+        c = lexeme[i];
+        if (c === "'" || c === '\\')
+            out += c;
+        out += c;
+    }
+    return out + "'";
+}
+/**
+ * An int32 lexeme count, then for each: the lexeme as a NUL-terminated
+ * string, an int16 count of positions, and that many int16s holding the
+ * weight in the top two bits and the position in the low fourteen. A
+ * weight of D is the default and is not printed.
+ */
+function decodeVector(v, offset) {
+    const count = v.readInt32BE(offset);
+    let p = offset + 4;
+    let out = '';
+    let i;
+    let j;
+    let end;
+    let positions;
+    let entry;
+    for (i = 0; i < count; i++) {
+        end = v.indexOf(0, p);
+        if (i)
+            out += ' ';
+        out += quote(v.toString('utf8', p, end));
+        p = end + 1;
+        positions = v.readInt16BE(p);
+        p += 2;
+        for (j = 0; j < positions; j++) {
+            entry = v.readUInt16BE(p);
+            p += 2;
+            out +=
+                (j ? ',' : ':') + (entry & POSITION_MASK) + VECTOR_WEIGHTS[entry >> 14];
+        }
+    }
+    return out;
+}
+/**
+ * An int32 node count, then the nodes themselves: an operator before its
+ * operands, and its right operand before its left. A value node carries
+ * a weight bitmask, a prefix flag and a NUL-terminated lexeme; a phrase
+ * operator carries an int16 distance.
+ */
+function readQueryNode(v, pos) {
+    const type = v[pos.p++];
+    if (type === QI_VAL) {
+        const weights = v[pos.p++];
+        const prefix = !!v[pos.p++];
+        const end = v.indexOf(0, pos.p);
+        const lexeme = v.toString('utf8', pos.p, end);
+        pos.p = end + 1;
+        return { lexeme, weights, prefix };
+    }
+    const oper = v[pos.p++];
+    if (oper === OP_NOT)
+        return { oper, right: readQueryNode(v, pos) };
+    let distance = 0;
+    if (oper === OP_PHRASE) {
+        distance = v.readInt16BE(pos.p);
+        pos.p += 2;
+    }
+    // Right before left, which is the order they were written in.
+    const right = readQueryNode(v, pos);
+    const left = readQueryNode(v, pos);
+    return { oper, distance, left, right };
+}
+/**
+ * Prints the tree the way the server prints it, parentheses included.
+ * An operand is wrapped when it binds more loosely than what it sits
+ * under; the extra `rightPhraseOp` case is what keeps
+ * `'a' <-> ( 'b' <-> 'c' )` distinct from `'a' <-> 'b' <-> 'c'`, which
+ * are different queries.
+ */
+function printQuery(node, parentPriority, rightPhraseOp) {
+    if (node.oper === undefined) {
+        let out = quote(node.lexeme);
+        if (node.weights || node.prefix) {
+            // The star comes before the letters - `'d':*AB`, not `'d':AB*`.
+            out += ':';
+            if (node.prefix)
+                out += '*';
+            let w;
+            for (w of QUERY_WEIGHTS)
+                if (node.weights & w[0])
+                    out += w[1];
+        }
+        return out;
+    }
+    const priority = PRIORITY[node.oper];
+    if (node.oper === OP_NOT)
+        return '!' + printQuery(node.right, priority, false);
+    const op = node.oper === OP_AND
+        ? '&'
+        : node.oper === OP_OR
+            ? '|'
+            : node.distance === 1
+                ? '<->'
+                : '<' + node.distance + '>';
+    const out = printQuery(node.left, priority, false) +
+        ' ' +
+        op +
+        ' ' +
+        printQuery(node.right, priority, node.oper === OP_PHRASE);
+    return priority < parentPriority ||
+        (rightPhraseOp && priority === parentPriority)
+        ? '( ' + out + ' )'
+        : out;
+}
+export const TsVectorType = {
+    name: 'tsvector',
+    oid: DataTypeOIDs.tsvector,
+    jsType: 'string',
+    // The text form is ordinary-looking text - see inet-type.ts for why
+    // none of these string-shaped types join inference.
+    inferrable: false,
+    encodeText(v) {
+        return '' + v;
+    },
+    decodeBinary(v, offset = 0) {
+        return decodeVector(v, offset);
+    },
+    decodeText(v) {
+        return v;
+    },
+    isType(v) {
+        return typeof v === 'string';
+    },
+};
+export const ArrayTsVectorType = {
+    ...TsVectorType,
+    name: '_tsvector',
+    oid: DataTypeOIDs._tsvector,
+    elementsOID: DataTypeOIDs.tsvector,
+};
+export const TsQueryType = {
+    ...TsVectorType,
+    name: 'tsquery',
+    oid: DataTypeOIDs.tsquery,
+    decodeBinary(v, offset = 0) {
+        const count = v.readInt32BE(offset);
+        // An empty query prints as nothing, and has no root to read.
+        if (!count)
+            return '';
+        return printQuery(readQueryNode(v, { p: offset + 4 }), 0, false);
+    },
+};
+export const ArrayTsQueryType = {
+    ...TsQueryType,
+    name: '_tsquery',
+    oid: DataTypeOIDs._tsquery,
+    elementsOID: DataTypeOIDs.tsquery,
+};

package/data-types/xid-type.d.ts

@@ -0,0 +1,7 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const XidType: DataType;
+export declare const ArrayXidType: DataType;
+export declare const CidType: DataType;
+export declare const ArrayCidType: DataType;
+export declare const Xid8Type: DataType;
+export declare const ArrayXid8Type: DataType;

package/data-types/xid-type.js

@@ -0,0 +1,110 @@
+import { DataTypeOIDs } from '../constants.js';
+import { fastParseInt, fastParseIntBuffer } from '../util/fast-parseint.js';
+/**
+ * `xid`, `xid8` and `cid` - the transaction and command counters behind
+ * the `xmin`, `xmax`, `cmin` and `cmax` system columns, which an
+ * application selects when it wants a row's identity for optimistic
+ * locking. They are counters, so they decode to numbers.
+ *
+ * None of the three joins inference. A JavaScript number says nothing
+ * about which of these it is, and claiming integers here would take them
+ * from `int4` and `int8`, where they almost always belong - name the
+ * type to use one.
+ */
+const BIG32 = BigInt(32);
+/**
+ * A 64-bit value is only exactly a JavaScript number while its high half
+ * is at most this: 0x1fffff * 2^32 + 0xffffffff is exactly
+ * Number.MAX_SAFE_INTEGER.
+ */
+const MAX_SAFE_HIGH = 0x1fffff;
+/** Both 64-bit types here are unsigned, so the halves are read apart. */
+function readUInt64(v, offset) {
+    const hi = v.readUInt32BE(offset);
+    const lo = v.readUInt32BE(offset + 4);
+    if (hi <= MAX_SAFE_HIGH)
+        return hi * 4294967296 + lo;
+    return (BigInt(hi) << BIG32) | BigInt(lo);
+}
+function writeUInt64(buf, v) {
+    const n = typeof v === 'bigint' ? v : BigInt(fastParseInt(v));
+    buf.writeUInt32BE(Number(n >> BIG32));
+    buf.writeUInt32BE(Number(n & BigInt(0xffffffff)));
+}
+function createUInt32Type(name, oid) {
+    return {
+        name,
+        oid,
+        jsType: 'number',
+        inferrable: false,
+        encodeText(v) {
+            return '' + v;
+        },
+        encodeBinary(buf, v) {
+            buf.writeUInt32BE(fastParseInt(v));
+        },
+        decodeBinary(v, offset = 0) {
+            return v.readUInt32BE(offset);
+        },
+        decodeText: fastParseInt,
+        decodeTextBuffer: fastParseIntBuffer,
+        isType(v) {
+            return (typeof v === 'number' &&
+                Number.isInteger(v) &&
+                v >= 0 &&
+                v <= 4294967295);
+        },
+    };
+}
+export const XidType = createUInt32Type('xid', DataTypeOIDs.xid);
+export const ArrayXidType = {
+    ...XidType,
+    name: '_xid',
+    oid: DataTypeOIDs._xid,
+    elementsOID: DataTypeOIDs.xid,
+};
+export const CidType = createUInt32Type('cid', DataTypeOIDs.cid);
+export const ArrayCidType = {
+    ...CidType,
+    name: '_cid',
+    oid: DataTypeOIDs._cid,
+    elementsOID: DataTypeOIDs.cid,
+};
+export const Xid8Type = {
+    name: 'xid8',
+    oid: DataTypeOIDs.xid8,
+    // A number while the value fits one exactly, a BigInt after that -
+    // the same contract int8 has.
+    jsType: 'BigInt',
+    inferrable: false,
+    encodeText(v) {
+        return '' + v;
+    },
+    encodeBinary: writeUInt64,
+    decodeBinary(v, offset = 0) {
+        return readUInt64(v, offset);
+    },
+    decodeText(s) {
+        // A full transaction id never has a sign, so the digit count alone
+        // decides whether it can be a number.
+        if (s.length <= 15)
+            return Number(s);
+        const v = BigInt(s);
+        return v <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(v) : v;
+    },
+    decodeTextBuffer(buf, offset, len) {
+        if (len <= 15)
+            return fastParseIntBuffer(buf, offset, len);
+        return Xid8Type.decodeText(buf.toString('latin1', offset, offset + len), {});
+    },
+    isType(v) {
+        return (typeof v === 'bigint' ||
+            (typeof v === 'number' && Number.isInteger(v) && v >= 0));
+    },
+};
+export const ArrayXid8Type = {
+    ...Xid8Type,
+    name: '_xid8',
+    oid: DataTypeOIDs._xid8,
+    elementsOID: DataTypeOIDs.xid8,
+};

package/index.d.ts

@@ -8,6 +8,10 @@ export * from './connection/pool.js';
 export * from './connection/prepared-statement.js';
 export * from './constants.js';
 export * from './data-type-map.js';
+export * from './data-types/classes/geometric.js';
+export * from './data-types/classes/interval.js';
+export * from './data-types/classes/numeric.js';
+export * from './data-types/classes/range.js';
 export * from './interfaces/batch-result.js';
 export * from './interfaces/command-result.js';
 export * from './interfaces/copy-from-rows-options.js';

package/index.js

@@ -8,6 +8,10 @@ export * from './connection/pool.js';
 export * from './connection/prepared-statement.js';
 export * from './constants.js';
 export * from './data-type-map.js';
+export * from './data-types/classes/geometric.js';
+export * from './data-types/classes/interval.js';
+export * from './data-types/classes/numeric.js';
+export * from './data-types/classes/range.js';
 export * from './interfaces/batch-result.js';
 export * from './interfaces/command-result.js';
 export * from './interfaces/copy-from-rows-options.js';

package/interfaces/data-mapping-options.d.ts

@@ -22,4 +22,30 @@ export interface DataMappingOptions {
      * that comes back.
      */
     fetchAsString?: OID[];
+    /**
+     * Ask the server for text on any column this client has no way to
+     * decode, instead of taking bytes it cannot read.
+     *
+     * Result columns are requested in binary, and there is a decoder only
+     * for the types registered in the type map - so an enum, a composite,
+     * an extension type, and 54 of PostgreSQL's own built-ins (`interval`,
+     * `inet`, the range family, `tsvector`, `money`, ...) arrive as a raw
+     * `Buffer` that nothing can interpret. With this on they arrive as the
+     * string PostgreSQL would have printed, which is what `pg` gives for
+     * the same column.
+     *
+     * Off by default, and it is not free: the column types have to be known
+     * before the Bind that asks for them, so a query that has not been
+     * prepared yet is prepared on first sight (one extra round trip per
+     * distinct statement per connection, measured at 233µs -> 447µs on
+     * loopback), and one run with `prepare: false` asks for the whole row
+     * as text.
+     *
+     * A registered type is untouched, so nothing that decodes today starts
+     * arriving as a string. An array whose own OID is unregistered comes
+     * back as the array literal rather than a JS array - there is no way to
+     * know it is an array without reading the catalog, and `pg` answers the
+     * same way. `fields[i].dataTypeName` stays empty for the same reason.
+     */
+    unknownTypesAsString?: boolean;
 }

package/interfaces/data-type.d.ts

@@ -26,15 +26,14 @@ export interface DataType {
     encodeText?: EncodeTextFunction;
     encodeCalculateDim?: EncodeCalculateDimFunction;
 }
-export interface Point {
-    x: number;
-    y: number;
-}
-export interface Circle {
-    x: number;
-    y: number;
-    r: number;
-}
+/**
+ * The shape `box` and `lseg` share.
+ *
+ * @deprecated Both types now decode to a class of their own - `Box` and
+ *   `LineSegment` - which is what tells them apart; they were
+ *   indistinguishable while both were only this. Kept because a plain
+ *   object of these four numbers is still accepted as a parameter.
+ */
 export interface Rectangle {
     x1: number;
     y1: number;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "postgrejs",
   "description": "Professional PostgreSQL client NodeJS",
-  "version": "3.6.1",
+  "version": "3.8.0",
   "author": "Panates",
   "license": "BSD-3-Clause",
   "dependencies": {

package/protocol/connection-lost-error.d.ts

@@ -2,9 +2,11 @@
  * A connection whose socket closed without anyone asking it to - the
  * backend terminated by an administrator, a failover, a network fault.
  *
- * Reported on `Connection`'s `'close'` event as its reason, and for a
- * pooled connection on `Pool`'s `'destroy'` (as the second argument) and
- * `'error'`. `Pool` emits `'error'` for this and for a connection that
+ * Reported on `Connection`'s `'close'` event as its reason, for a pooled
+ * connection on `Pool`'s `'destroy'` (as the second argument) and
+ * `'error'`, and as the rejection of whatever query was in flight when it
+ * happened - one object for all of them, so a caller that needs both can
+ * pair them by identity. `Pool` emits `'error'` for this and for a connection that
  * could not be created in the first place, and those want different
  * handling - this class is how a listener tells them apart:
  *

package/protocol/connection-lost-error.js

@@ -2,9 +2,11 @@
  * A connection whose socket closed without anyone asking it to - the
  * backend terminated by an administrator, a failover, a network fault.
  *
- * Reported on `Connection`'s `'close'` event as its reason, and for a
- * pooled connection on `Pool`'s `'destroy'` (as the second argument) and
- * `'error'`. `Pool` emits `'error'` for this and for a connection that
+ * Reported on `Connection`'s `'close'` event as its reason, for a pooled
+ * connection on `Pool`'s `'destroy'` (as the second argument) and
+ * `'error'`, and as the rejection of whatever query was in flight when it
+ * happened - one object for all of them, so a caller that needs both can
+ * pair them by identity. `Pool` emits `'error'` for this and for a connection that
  * could not be created in the first place, and those want different
  * handling - this class is how a listener tells them apart:
  *

package/protocol/frontend.js

@@ -1,7 +1,9 @@
 import { DEFAULT_COLUMN_FORMAT } from '../constants.js';
 import { DataTypeMap } from '../data-type-map.js';
 import { encodeBinaryArray } from '../util/encode-binaryarray.js';
+import { formatDateParam } from '../util/format-datetime.js';
 import { stringifyArrayLiteral } from '../util/stringify-arrayliteral.js';
+import { arrayLeaf } from '../util/unspecified-param.js';
 import { Protocol } from './protocol.js';
 import { SmartBuffer } from './smart-buffer.js';
 const DataFormat = Protocol.DataFormat;
@@ -186,6 +188,21 @@ export class Frontend {
                         io.writeLString(v, 'utf8');
                     }
                 }
+                else if (v instanceof Date) {
+                    // No declared type, so the server resolves it from the column
+                    // - which is the whole point, and why the text has to carry
+                    // the zone. `String(v)` is a JavaScript date string the server
+                    // cannot parse at all, which is what a prepared statement with
+                    // no paramTypes used to send.
+                    io.writeLString(formatDateParam(v, queryOptions), 'utf8');
+                }
+                else if (Array.isArray(v)) {
+                    // Also undeclared, so the server reads an array literal and
+                    // takes the element type from the column. `'' + v` would hand
+                    // it `a,b`, which is not one - the elements have to be quoted
+                    // and the braces written, and a nested array needs its own.
+                    io.writeLString(stringifyArrayLiteral(v, queryOptions, arrayLeaf(v) instanceof Date ? formatDateParam : undefined), 'utf8');
+                }
                 else if (Buffer.isBuffer(v)) {
                     // Set param format to binary
                     io.buffer.writeInt16BE(Protocol.DataFormat.binary, formatOffset + i * 2);