postgrejs 3.7.0 → 3.9.0

package/data-types/money-type.js

@@ -0,0 +1,203 @@
+import { DataTypeOIDs } from '../constants.js';
+import { readBigInt64BE } from '../util/bigint-methods.js';
+import { Numeric } from './classes/numeric.js';
+import { trimTrailingZeros } from './numeric-type.js';
+/**
+ * What the server's own `lc_monetary` does to a money value, when
+ * nothing has asked it. Two fraction digits and a dot is what the great
+ * majority of locales use, and it is only ever reached when the probe
+ * itself failed - see IntlConnection.ensureMoneyFormat().
+ */
+const DEFAULT_SCALE = 2;
+const DEFAULT_SEPARATOR = '.';
+/**
+ * Reads the server's own rendering of `1::money` - see
+ * `IntlConnection.ensureMoneyFormat()` for why it is that value: with no
+ * thousands separator in it, any separator present can only be the
+ * decimal one, and the digits after it can only be the fraction.
+ */
+export function parseMoneyFormat(text) {
+    let lastSep = -1;
+    let i;
+    const l = text.length;
+    let c;
+    for (i = 0; i < l; i++) {
+        c = text.charCodeAt(i);
+        if (c >= 48 && c <= 57)
+            continue;
+        if (c === 46 /* . */ || c === 44 /* , */)
+            lastSep = i;
+    }
+    if (lastSep < 0)
+        return { scale: 0, decimalSeparator: DEFAULT_SEPARATOR };
+    let scale = 0;
+    for (i = lastSep + 1; i < l; i++) {
+        c = text.charCodeAt(i);
+        if (c >= 48 && c <= 57)
+            scale++;
+    }
+    return { scale, decimalSeparator: text[lastSep] };
+}
+const FALLBACK_FORMAT = {
+    scale: DEFAULT_SCALE,
+    decimalSeparator: DEFAULT_SEPARATOR,
+};
+function formatOf(options) {
+    return options?.moneyFormat || FALLBACK_FORMAT;
+}
+/** The exact decimal `minorUnits` stands for at `scale` fraction digits. */
+export function moneyToString(minorUnits, scale) {
+    if (!scale)
+        return minorUnits.toString();
+    const neg = minorUnits < 0n;
+    let digits = (neg ? -minorUnits : minorUnits).toString();
+    if (digits.length <= scale)
+        digits = digits.padStart(scale + 1, '0');
+    return ((neg ? '-' : '') +
+        digits.slice(0, digits.length - scale) +
+        '.' +
+        digits.slice(digits.length - scale));
+}
+/**
+ * A number while a double carries the value exactly, a Numeric after
+ * that - the same rule `numeric` decodes by, and for the same reason.
+ * money is an int64 of minor units, so it reaches past 2^53 long before
+ * it runs out of range.
+ */
+function toNumberOrNumeric(s) {
+    const n = parseFloat(s);
+    // The fraction is always written out to the full scale - `1` at scale
+    // 2 is `1.00` - and those zeroes are padding, not a difference.
+    return String(n) === trimTrailingZeros(s) ? n : new Numeric(s);
+}
+/**
+ * Every digit in `s`, read as minor units at `scale` - which is how a
+ * rendered money value is read back without knowing the locale that
+ * rendered it. `-$1,234.50` is `-123450` at scale 2, whatever the symbol
+ * and the separators were.
+ */
+function parseMoneyText(s) {
+    let digits = '';
+    let neg = false;
+    let i;
+    const l = s.length;
+    let c;
+    for (i = 0; i < l; i++) {
+        c = s.charCodeAt(i);
+        if (c >= 48 && c <= 57)
+            digits += s[i];
+        else if (c === 45 /* - */ || c === 40 /* ( */)
+            neg = true;
+    }
+    if (!digits)
+        digits = '0';
+    const v = BigInt(digits);
+    return neg ? -v : v;
+}
+/**
+ * PostgreSQL's fixed-point currency type.
+ *
+ * On the wire it is an int64 of the smallest currency unit - `$12.34`
+ * arrives as `1234` - and how many of those make a unit is `lc_monetary`,
+ * which the server does not report in its startup parameters. So the
+ * connection asks it once, on its way up, and every money value is read
+ * against that answer. See `IntlConnection.ensureMoneyFormat()`.
+ *
+ * The value decodes to a plain number, or a `Numeric` when a double
+ * cannot carry it. The currency symbol is *not* part of it: it is the
+ * server's rendering of the value, not the value, and
+ * `fetchAsString: [DataTypeOIDs.money]` asks for that rendering when it
+ * is what the caller wants - which is also what `pg` always returns.
+ *
+ * The question is asked the first time a money column is on its way
+ * back, while the rows are still raw bytes - so no value is ever read
+ * against a scale nobody confirmed, and a caller who never touches
+ * money never asks. `execute()` and `pipeline()` decode inside the
+ * message loop, where there is nowhere left to ask from, so those two
+ * set the rows aside and read them once the loop is over.
+ *
+ * `moneyFormat` in the options answers it in advance, for a caller who
+ * knows the server or is reading a value some other server rendered.
+ */
+export const MoneyType = {
+    name: 'money',
+    oid: DataTypeOIDs.money,
+    jsType: 'number',
+    /**
+     * Written in the server's own decimal separator, so that the value the
+     * server parses is the value that was meant - money input is read in
+     * `lc_monetary` too, and `12.34` is not `12,34` to a locale that
+     * separates with a comma.
+     */
+    encodeText(v, options) {
+        const { scale, decimalSeparator } = formatOf(options);
+        const s = moneyToString(toExactMinor(v, scale), scale);
+        return decimalSeparator === '.' ? s : s.replace('.', decimalSeparator);
+    },
+    encodeBinary(buf, v, options) {
+        const { scale } = formatOf(options);
+        buf.writeBigInt64BE(toExactMinor(v, scale));
+    },
+    decodeBinary(buf, offset = 0, _len, options) {
+        const v = typeof buf.readBigInt64BE === 'function'
+            ? buf.readBigInt64BE(offset)
+            : readBigInt64BE(buf, offset);
+        return toNumberOrNumeric(moneyToString(v, formatOf(options).scale));
+    },
+    decodeText(s, options) {
+        const { scale } = formatOf(options);
+        return toNumberOrNumeric(moneyToString(parseMoneyText(s), scale));
+    },
+    /**
+     * Never inferred: a JavaScript number is `int4`, `float8` or `numeric`
+     * long before anyone means money by it, and nothing about the value
+     * says which. `new BindParam(DataTypeOIDs.money, 12.34)` asks for it.
+     */
+    inferrable: false,
+    isType(v) {
+        return typeof v === 'number' || v instanceof Numeric;
+    },
+};
+/** The int64 of minor units `v` stands for, without going through a double. */
+function toExactMinor(v, scale) {
+    if (typeof v === 'bigint')
+        return v;
+    const s = v instanceof Numeric ? v.value : String(v ?? 0);
+    const neg = s.trimStart().startsWith('-');
+    let digits = '';
+    let frac = -1;
+    let i;
+    const l = s.length;
+    let c;
+    for (i = 0; i < l; i++) {
+        c = s.charCodeAt(i);
+        if (c >= 48 && c <= 57) {
+            digits += s[i];
+            if (frac >= 0)
+                frac++;
+        }
+        else if (c === 46 /* . */ || c === 44 /* , */)
+            frac = 0;
+    }
+    if (!digits)
+        return 0n;
+    if (frac < 0)
+        frac = 0;
+    // Pad or round to exactly `scale` fraction digits.
+    if (frac < scale)
+        digits = digits.padEnd(digits.length + scale - frac, '0');
+    else if (frac > scale) {
+        const cut = frac - scale;
+        const keep = digits.slice(0, digits.length - cut);
+        const next = digits.charCodeAt(digits.length - cut) - 48;
+        digits = (BigInt(keep || '0') + (next >= 5 ? 1n : 0n)).toString();
+    }
+    const out = BigInt(digits || '0');
+    return neg ? -out : out;
+}
+export const ArrayMoneyType = {
+    ...MoneyType,
+    name: '_money',
+    oid: DataTypeOIDs._money,
+    elementsOID: DataTypeOIDs.money,
+};

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

@@ -1,4 +1,6 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** The decimal without the zeroes a declared scale pads it out to. */
+export declare function trimTrailingZeros(s: string): string;
 export declare const NumericType: DataType;
 export declare const ArrayNumericType: DataType;
 /**

package/data-types/numeric-type.js

@@ -16,7 +16,7 @@ const PAIRS = new Array(100);
 for (let i = 0; i < 100; i++)
     PAIRS[i] = i < 10 ? '0' + i : '' + i;
 /** The decimal without the zeroes a declared scale pads it out to. */
-function trimTrailingZeros(s) {
+export function trimTrailingZeros(s) {
     const dot = s.indexOf('.');
     if (dot < 0)
         return s;

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

@@ -16,7 +16,10 @@ export const OidVectorType = {
     encodeBinary(buf, v) {
         encodeBinaryArray(buf, v, DataTypeOIDs.oid, {}, (io, x) => {
             io.writeUInt32BE(x);
-        });
+        }, 
+        // A vector is genuinely 0-based, unlike every ordinary array -
+        // `array_lower(pg_index.indkey, 1)` is 0 on the server.
+        undefined, 0);
     },
     encodeCalculateDim(v) {
         return [v.length];

package/data-types/timestamp-type.js

@@ -13,7 +13,7 @@ export const TimestampType = {
     },
     encodeBinary(buf, v, options) {
         if (typeof v === 'string')
-            v = parseDateTime(v, options.utcDates);
+            v = parseDateTime(v, options.utcDates, options.dateStyle);
         if (v === Infinity) {
             buf.writeInt32BE(0x7fffffff); // hi
             buf.writeUInt32BE(0xffffffff); // lo
@@ -51,7 +51,7 @@ export const TimestampType = {
         return d;
     },
     decodeText(v, options) {
-        return parseDateTime(v, options.utcDates);
+        return parseDateTime(v, options.utcDates, options.dateStyle);
     },
     // Reads PostgreSQL's own timestamp shape straight from the wire bytes -
     // see timestamptz-type.ts's decodeTextBuffer for why. The guard is what

package/data-types/timestamptz-type.js

@@ -14,7 +14,7 @@ export const TimestamptzType = {
     },
     encodeBinary(buf, v, options) {
         if (typeof v === 'string')
-            v = parseDateTimeTz(v, options.utcDates);
+            v = parseDateTimeTz(v, options.utcDates, options.dateStyle);
         if (v === Infinity) {
             buf.writeInt32BE(0x7fffffff); // hi
             buf.writeUInt32BE(0xffffffff); // lo
@@ -53,7 +53,7 @@ export const TimestamptzType = {
         return new Date((lo + hi * timeMul) / 1000 + timeShift);
     },
     decodeText(v, options) {
-        return parseDateTimeTz(v, options.utcDates);
+        return parseDateTimeTz(v, options.utcDates, options.dateStyle);
     },
     // Reads PostgreSQL's own timestamp shape straight from the wire bytes.
     // Building the string first and handing it to decodeText() costs about
@@ -67,6 +67,15 @@ export const TimestamptzType = {
             return d;
         return TimestamptzType.decodeText(buf.toString('latin1', offset, offset + len), options);
     },
+    /**
+     * Unreachable through `determine()`: TimestampType, TimeType and
+     * DateType are all consulted before this one and every Date is claimed
+     * by one of them. Nothing depends on it - a Date parameter goes out
+     * unspecified and the column decides what it means (see
+     * format-datetime.ts's formatDateParam) - so this stays as the
+     * truthful answer to a direct call rather than being narrowed to
+     * describe a walk it never wins.
+     */
     isType(v) {
         return v instanceof Date;
     },

package/index.d.ts

@@ -27,6 +27,7 @@ export * from './interfaces/query-result.js';
 export * from './interfaces/script-execute-options.js';
 export * from './interfaces/script-result.js';
 export * from './interfaces/statement-prepare-options.js';
+export * from './interfaces/transaction-options.js';
 export * from './protocol/connection-lost-error.js';
 export * from './protocol/database-error.js';
 export * from './protocol/smart-buffer.js';

package/index.js

@@ -27,6 +27,7 @@ export * from './interfaces/query-result.js';
 export * from './interfaces/script-execute-options.js';
 export * from './interfaces/script-result.js';
 export * from './interfaces/statement-prepare-options.js';
+export * from './interfaces/transaction-options.js';
 export * from './protocol/connection-lost-error.js';
 export * from './protocol/database-error.js';
 export * from './protocol/smart-buffer.js';

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

@@ -1,5 +1,32 @@
 import type { OID } from '../types.js';
+import type { PgDateStyle } from '../util/date-style.js';
+/** How a server renders `money` - see `DataMappingOptions.moneyFormat`. */
+export interface MoneyFormat {
+    /** Fraction digits: 2 for `$1.00`, 0 for `¥1`, 3 for a dinar. */
+    scale: number;
+    /** The decimal separator the server prints, `.` or `,`. */
+    decimalSeparator: string;
+}
 export interface DataMappingOptions {
+    /**
+     * How the server renders dates, when it is not rendering them in ISO.
+     *
+     * Only the text wire format is affected - binary carries no formatting
+     * at all - and the connection fills this in from the `DateStyle` the
+     * server reports, so a caller normally never sets it. See
+     * `util/date-style.ts` for what each setting prints.
+     */
+    dateStyle?: PgDateStyle;
+    /**
+     * How the server renders money, which is what `money`'s wire format
+     * cannot say on its own: it is an int64 of the smallest currency unit,
+     * and how many of those make one is `lc_monetary` - a setting the
+     * server does not report. A connection asks it once on its way up (see
+     * `IntlConnection.ensureMoneyFormat()`) and fills this in; set it here
+     * to skip that question, or to read a value rendered by a different
+     * server than the one at hand.
+     */
+    moneyFormat?: MoneyFormat;
     /**
      * If true UTC time will be used for date decoding, else system time offset will be used
      * @default false

package/interfaces/database-connection-params.d.ts

@@ -2,6 +2,8 @@ import type { PoolConfiguration as LPoolConfiguration } from 'lightning-pool';
 import type { ConnectionOptions as TlsConnectionOptions } from 'tls';
 import type { SmartBufferConfig } from '../protocol/smart-buffer.js';
 import type { DebugLogger } from '../types.js';
+import type { DataMappingOptions } from './data-mapping-options.js';
+import type { QueryOptions } from './query-options.js';
 export interface DatabaseConnectionParams {
     host?: string;
     port?: number;
@@ -147,8 +149,32 @@ export type TargetSessionAttrs = 'read-write' | 'read-only' | 'primary' | 'stand
 export interface SocketOptions {
     keepAlive?: boolean;
 }
-export interface ConnectionConfiguration extends DatabaseConnectionParams, SocketOptions {
+/**
+ * The data-mapping options a connection can answer for every statement
+ * on it, so a caller that always wants the same shape says so once.
+ *
+ * Each is the default for `QueryOptions`'s field of the same name and
+ * is described there; a value on the call always wins. `fetchAsString`
+ * and `unknownTypesAsString` are the two with a cost worth knowing
+ * about - see `fetchAsString` in QueryOptions.
+ */
+export type ConnectionMappingDefaults = DataMappingOptions & Pick<QueryOptions, 'objectRows' | 'rowDecoder' | 'typeMap' | 'columnFormat'>;
+export interface ConnectionConfiguration extends DatabaseConnectionParams, SocketOptions, ConnectionMappingDefaults {
     buffer?: SmartBufferConfig;
+    /**
+     * Whether statements may share a connection with statements already in
+     * flight - the default for every call here, which
+     * `QueryOptions.pipeline` overrides per statement and describes in
+     * full.
+     *
+     * Defaults to **on for a `Connection`** (what one has always done) and
+     * **off for a `Pool`**, where sharing also means running on a
+     * connection other callers are using. `true` on a pool turns it on for
+     * every query that can take it; `false` on a connection gives the
+     * behaviour of a client that waits for each reply before sending the
+     * next statement.
+     */
+    pipeline?: boolean;
 }
 export interface PoolConfiguration extends ConnectionConfiguration, LPoolConfiguration {
     /**
@@ -162,10 +188,11 @@ export interface PoolConfiguration extends ConnectionConfiguration, LPoolConfigu
      * ceiling on connections - with the default pool of 10, a burst of 1000
      * queries no longer has to run as 100 sequential rounds of 10.
      *
-     * Set to 1 for the older behaviour, where Pool.query() holds a
-     * connection exclusively for the duration of each query. Connections
-     * handed out by acquire() are never shared, whatever this is set to, so
-     * transactions, cursors and prepared statements are unaffected.
+     * Only queries that asked to be pipelined are counted, since sharing a
+     * pooled connection is opt-in - see `pipeline`. Setting this to 1 is
+     * the other way to turn it off. Connections handed out by acquire()
+     * are never shared whatever either is set to, so transactions, cursors
+     * and prepared statements are unaffected.
      */
     pipelineMaxQueries?: number;
     /**

package/interfaces/query-options.d.ts

@@ -9,6 +9,38 @@ export interface QueryOptions extends DataMappingOptions {
      * @default true
      */
     autoCommit?: boolean;
+    /**
+     * Whether this statement may share a connection with statements that
+     * are already in flight.
+     *
+     * PostgreSQL correlates responses to requests by order, so several
+     * statements can be on the wire at once, each under its own Sync and
+     * therefore with its own error boundary.
+     *
+     * **The default differs by where the statement runs, because the two
+     * places are not the same question:**
+     *
+     * - On a `Connection`, **on**. The connection is the caller's own, and
+     *   concurrent `query()` calls on one have always overlapped this way.
+     * - On a `Pool`, **off**. Here it also decides *which* connection the
+     *   statement runs on: sharing puts it on a connection other callers
+     *   are using, where session state - `SET`, an advisory lock, a
+     *   temporary table - is no longer the caller's alone. That is opt-in,
+     *   per call or with `pipeline: true` on the pool.
+     *
+     * `false` asks for the wire to itself: the statement waits until
+     * nothing else is running on the connection, and nothing else starts
+     * until it finishes, whichever mode those asked for. Nothing orders
+     * two pipelined statements against each other, so this is how a
+     * statement that depends on what another one left behind says so.
+     *
+     * Some statements never share a *pooled* connection however this is
+     * set, because they need one to themselves for longer than the call:
+     * anything carrying an `AbortSignal`, anything with
+     * `autoCommit: false`, a cursor, and SQL that opens a transaction or a
+     * COPY. On a `Connection` the setting is only about the wire.
+     */
+    pipeline?: boolean;
     /**
      * Specifies if rows will be fetched as <FieldName, Value> pair objects or array of values
      * @deprecated Use `rowDecoder: 'object'` instead - `objectRows: true` still works exactly

package/interfaces/script-execute-options.d.ts

@@ -7,6 +7,38 @@ export interface ScriptExecuteOptions extends DataMappingOptions {
      * @default true
      */
     autoCommit?: boolean;
+    /**
+     * Whether this statement may share a connection with statements that
+     * are already in flight.
+     *
+     * PostgreSQL correlates responses to requests by order, so several
+     * statements can be on the wire at once, each under its own Sync and
+     * therefore with its own error boundary.
+     *
+     * **The default differs by where the statement runs, because the two
+     * places are not the same question:**
+     *
+     * - On a `Connection`, **on**. The connection is the caller's own, and
+     *   concurrent `query()` calls on one have always overlapped this way.
+     * - On a `Pool`, **off**. Here it also decides *which* connection the
+     *   statement runs on: sharing puts it on a connection other callers
+     *   are using, where session state - `SET`, an advisory lock, a
+     *   temporary table - is no longer the caller's alone. That is opt-in,
+     *   per call or with `pipeline: true` on the pool.
+     *
+     * `false` asks for the wire to itself: the statement waits until
+     * nothing else is running on the connection, and nothing else starts
+     * until it finishes, whichever mode those asked for. Nothing orders
+     * two pipelined statements against each other, so this is how a
+     * statement that depends on what another one left behind says so.
+     *
+     * Some statements never share a *pooled* connection however this is
+     * set, because they need one to themselves for longer than the call:
+     * anything carrying an `AbortSignal`, anything with
+     * `autoCommit: false`, a cursor, and SQL that opens a transaction or a
+     * COPY. On a `Connection` the setting is only about the wire.
+     */
+    pipeline?: boolean;
     /**
      * Specifies if rows will be fetched as <FieldName, Value> pair objects or array of values
      * @deprecated Use `rowDecoder: 'object'` instead - `objectRows: true` still works exactly

package/interfaces/transaction-options.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The modes PostgreSQL takes on the `BEGIN` itself.
+ *
+ * Setting them this way is one round trip where `BEGIN` followed by
+ * `SET TRANSACTION` is two - measured at 0.500ms against 0.740ms for
+ * opening and closing one isolated transaction, which is most of what a
+ * short transaction costs.
+ *
+ * `SET TRANSACTION SNAPSHOT` is deliberately absent: PostgreSQL does not
+ * accept it on `BEGIN`, so it still needs a statement of its own.
+ */
+export interface TransactionOptions {
+    /**
+     * What this transaction may see of the ones running beside it.
+     * Defaults to the server's `default_transaction_isolation`, which is
+     * `read committed` unless the server says otherwise.
+     */
+    isolationLevel?: 'serializable' | 'repeatable read' | 'read committed' | 'read uncommitted';
+    /** Refuses anything that would write, at the server. */
+    readOnly?: boolean;
+    /**
+     * Lets a `serializable` `readOnly` transaction wait until it can run
+     * without the serialization failures that level otherwise risks -
+     * ignored by the server for any other combination.
+     */
+    deferrable?: boolean;
+}

package/interfaces/transaction-options.js

@@ -0,0 +1 @@
+export {};

package/package.json

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

package/protocol/database-error.d.ts

@@ -16,6 +16,21 @@ export declare class DatabaseError extends Error {
      * explicit transaction was already open they are rolled back with it.
      */
     batchResults?: BatchCommandResult[];
+    /**
+     * The message exactly as PostgreSQL sent it.
+     *
+     * `message` is decorated where the server reported a position - the
+     * line and column, the offending source line and a caret under it -
+     * which is what makes an error readable in a terminal with no extra
+     * work, and would otherwise leave nothing holding the original. A
+     * consumer that parses the text needs the original: PostgreSQL does
+     * not always put the interesting part in a field, so an anchored
+     * pattern like `/^column (.+) does not exist$/` is how the column name
+     * is read, and a suffix defeats it.
+     *
+     * Always set, and equal to `message` when nothing was decorated.
+     */
+    readonly serverMessage: string;
     severity?: string;
     code?: string;
     detail?: string;

package/protocol/database-error.js

@@ -15,6 +15,21 @@ export class DatabaseError extends Error {
      * explicit transaction was already open they are rolled back with it.
      */
     batchResults;
+    /**
+     * The message exactly as PostgreSQL sent it.
+     *
+     * `message` is decorated where the server reported a position - the
+     * line and column, the offending source line and a caret under it -
+     * which is what makes an error readable in a terminal with no extra
+     * work, and would otherwise leave nothing holding the original. A
+     * consumer that parses the text needs the original: PostgreSQL does
+     * not always put the interesting part in a field, so an anchored
+     * pattern like `/^column (.+) does not exist$/` is how the column name
+     * is read, and a suffix defeats it.
+     *
+     * Always set, and equal to `message` when nothing was decorated.
+     */
+    serverMessage;
     severity;
     code;
     detail;
@@ -41,5 +56,9 @@ export class DatabaseError extends Error {
         });
         if (msg.position)
             this.position = parseInt(msg.position, 10) || undefined;
+        // Read off `message` rather than off `msg`, and after the assign
+        // above, so the two cannot drift apart - whatever this error was
+        // built to say, before anything decorates it.
+        this.serverMessage = this.message;
     }
 }

package/protocol/frontend.js

@@ -1,6 +1,8 @@
 import { DEFAULT_COLUMN_FORMAT } from '../constants.js';
 import { DataTypeMap } from '../data-type-map.js';
+import { arrayLeaf } from '../util/array-leaf.js';
 import { encodeBinaryArray } from '../util/encode-binaryarray.js';
+import { formatDateParam } from '../util/format-datetime.js';
 import { stringifyArrayLiteral } from '../util/stringify-arrayliteral.js';
 import { Protocol } from './protocol.js';
 import { SmartBuffer } from './smart-buffer.js';
@@ -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);

package/protocol/pg-socket.js

@@ -899,16 +899,13 @@ export class PgSocket extends SafeEventEmitter {
             socket.write(data, cb);
             return true;
         }
-        socket.cork();
-        try {
-            const l = data.length;
-            let i;
-            for (i = 0; i < l; i++)
-                socket.write(data[i], i === l - 1 ? cb : undefined);
-        }
-        finally {
-            socket.uncork();
-        }
+        // Joined rather than written one by one under a cork: a statement is
+        // three messages (Bind, Execute, Sync) of a few dozen bytes, and a
+        // write apiece costs three trips through the stream machinery - a
+        // WriteReq, a buffer entry, a cork/uncork pair - to save a copy of
+        // 43 bytes. Measured at 50 concurrent queries, 150 writes against
+        // 50.
+        socket.write(data.length === 1 ? data[0] : Buffer.concat(data), cb);
         return true;
     }
     /**

package/util/array-leaf.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The first value inside `v` that is neither an array nor null - what an
+ * array's element type is read from. A scalar answers itself, and an
+ * array with nothing but nulls (or nothing at all) answers `undefined`.
+ *
+ * Reading `v[0]` instead is wrong twice over: `[[1, 2], [3, 4]]` asks
+ * what type `[1, 2]` is, and `[null, 2, 3]` asks what type `null` is.
+ * Neither has an answer, and both are ordinary values to send.
+ */
+export declare function arrayLeaf(v: any): any;

package/util/array-leaf.js

@@ -0,0 +1,22 @@
+/**
+ * The first value inside `v` that is neither an array nor null - what an
+ * array's element type is read from. A scalar answers itself, and an
+ * array with nothing but nulls (or nothing at all) answers `undefined`.
+ *
+ * Reading `v[0]` instead is wrong twice over: `[[1, 2], [3, 4]]` asks
+ * what type `[1, 2]` is, and `[null, 2, 3]` asks what type `null` is.
+ * Neither has an answer, and both are ordinary values to send.
+ */
+export function arrayLeaf(v) {
+    if (!Array.isArray(v))
+        return v;
+    const l = v.length;
+    let i;
+    let x;
+    for (i = 0; i < l; i++) {
+        x = arrayLeaf(v[i]);
+        if (x != null)
+            return x;
+    }
+    return undefined;
+}