postgrejs 3.1.3 → 3.4.0

package/data-types/timestamptz-type.js

@@ -2,13 +2,13 @@ import { DataTypeOIDs } from '../constants.js';
 import { SmartBuffer } from '../protocol/smart-buffer.js';
 import { formatTimestamptz } from '../util/format-datetime.js';
 import { parseDateTimeTz } from '../util/parse-datetime.js';
+import { parsePgTimestampBuffer } from '../util/parse-pg-timestamp.js';
 const timeShift = 946684800000;
 const timeMul = 4294967296;
 export const TimestamptzType = {
     name: 'timestamptz',
     oid: DataTypeOIDs.timestamptz,
     jsType: 'Date',
-    fixedBinarySize: 8,
     encodeText(v) {
         return formatTimestamptz(v);
     },
@@ -34,7 +34,7 @@ export const TimestamptzType = {
         buf.writeInt32BE(hi);
         buf.writeUInt32BE(lo);
     },
-    decodeBinary(v, offset = 0, options) {
+    decodeBinary(v, offset = 0, _len, options) {
         const fetchAsString = options.fetchAsString?.includes(DataTypeOIDs.timestamptz);
         const hi = v.readInt32BE(offset);
         const lo = v.readUInt32BE(offset + 4);
@@ -42,11 +42,16 @@ export const TimestamptzType = {
             return fetchAsString ? 'infinity' : Infinity;
         if (lo === 0x00000000 && hi === -0x80000000)
             return fetchAsString ? '-infinity' : -Infinity;
-        // Shift from 2000 to 1970
-        let d = new Date((lo + hi * timeMul) / 1000 + timeShift);
-        if (fetchAsString || !options.utcDates) {
-            d = new Date(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());
-        }
+        // Shift from 2000 to 1970. A timestamptz is an absolute instant, so
+        // this is already the value - there is nothing to reinterpret against
+        // the local zone the way `timestamp` (which carries no zone of its
+        // own) has to. Rebuilding the Date from its own local getters, as this
+        // used to, gave back the same instant for every value except one: an
+        // instant inside the hour that repeats when local time falls back is
+        // ambiguous read as wall-clock, so the rebuild silently picked the
+        // other one and moved the value an hour. The text path never did that,
+        // so the same row decoded binary and text disagreed.
+        const d = new Date((lo + hi * timeMul) / 1000 + timeShift);
         return fetchAsString ? dateToTimestamptzString(d) : d;
     },
     decodeText(v, options) {
@@ -64,11 +69,23 @@ export const TimestamptzType = {
         }
         return d;
     },
-    // See date-type.ts's decodeTextBuffer comment - same rationale. Note this
-    // type's decodeText always parses first and only branches on
+    // Reads PostgreSQL's own timestamp shape straight from the wire bytes.
+    // Building the string first and handing it to decodeText() costs about
+    // as much again as the parse itself, for a string that exists only to be
+    // scanned a character at a time. Anything not in that exact shape
+    // (infinity, a BC suffix, an LMT-style offset) has no Date to give back
+    // and takes the original path, which still needs the string.
+    //
+    // Note this type's decodeText always parses first and only branches on
     // fetchAsString afterward (unlike date/time/timestamp, which early-return
-    // the raw string) - delegating by reference preserves that as-is.
+    // the raw string), so the same order is kept here.
     decodeTextBuffer(buf, offset, len, options) {
+        const d = parsePgTimestampBuffer(buf, offset, offset + len);
+        if (d !== undefined) {
+            return options.fetchAsString?.includes(DataTypeOIDs.timestamptz)
+                ? dateToTimestamptzString(d)
+                : d;
+        }
         return TimestamptzType.decodeText(buf.toString('latin1', offset, offset + len), options);
     },
     isType(v) {

package/data-types/uuid-type.js

@@ -4,7 +4,6 @@ export const UuidType = {
     name: 'uuid',
     oid: DataTypeOIDs.uuid,
     jsType: 'String',
-    fixedBinarySize: 16,
     encodeText(v) {
         return '' + v;
     },
@@ -12,7 +11,7 @@ export const UuidType = {
         if (!GUID_PATTERN.test(v))
             throw new Error(`"${v}" is not a valid guid value`);
         const b = Buffer.from(v.replace(/-/g, ''), 'hex');
-        buf.writeBuffer(b);
+        buf.writeBytes(b);
     },
     decodeBinary(v, offset = 0) {
         return (v.toString('hex', offset, offset + 4) +

package/data-types/varchar-type.js

@@ -9,8 +9,8 @@ export const VarcharType = {
     encodeBinary(buf, v) {
         buf.writeString('' + v, 'utf8');
     },
-    decodeBinary(v, offset = 0) {
-        return v.toString('utf8', offset);
+    decodeBinary(v, offset = 0, len) {
+        return v.toString('utf8', offset, offset + len);
     },
     decodeText(v) {
         // The wire decoder always hands this a string (see intl-connection.ts's

package/index.d.ts

@@ -8,13 +8,16 @@ export * from './connection/pool.js';
 export * from './connection/prepared-statement.js';
 export * from './constants.js';
 export * from './data-type-map.js';
+export * from './interfaces/batch-result.js';
 export * from './interfaces/command-result.js';
+export * from './interfaces/copy-from-rows-options.js';
 export * from './interfaces/data-mapping-options.js';
 export * from './interfaces/data-type.js';
 export * from './interfaces/database-connection-params.js';
 export * from './interfaces/field-info.js';
 export * from './interfaces/function-call-options.js';
 export * from './interfaces/function-call-result.js';
+export * from './interfaces/pipeline-request.js';
 export * from './interfaces/query-options.js';
 export * from './interfaces/query-result.js';
 export * from './interfaces/script-execute-options.js';
@@ -27,6 +30,7 @@ export * from './util/connection-config.js';
 export * from './util/escape-identifier.js';
 export * from './util/escape-literal.js';
 export * from './util/parse-datetime.js';
+export * from './util/row-decoder.js';
 export * from './util/sql-tag.js';
 export * from './util/stringify-arrayliteral.js';
 export * from './util/stringify-for-sql.js';

package/index.js

@@ -8,13 +8,16 @@ export * from './connection/pool.js';
 export * from './connection/prepared-statement.js';
 export * from './constants.js';
 export * from './data-type-map.js';
+export * from './interfaces/batch-result.js';
 export * from './interfaces/command-result.js';
+export * from './interfaces/copy-from-rows-options.js';
 export * from './interfaces/data-mapping-options.js';
 export * from './interfaces/data-type.js';
 export * from './interfaces/database-connection-params.js';
 export * from './interfaces/field-info.js';
 export * from './interfaces/function-call-options.js';
 export * from './interfaces/function-call-result.js';
+export * from './interfaces/pipeline-request.js';
 export * from './interfaces/query-options.js';
 export * from './interfaces/query-result.js';
 export * from './interfaces/script-execute-options.js';
@@ -27,6 +30,7 @@ export * from './util/connection-config.js';
 export * from './util/escape-identifier.js';
 export * from './util/escape-literal.js';
 export * from './util/parse-datetime.js';
+export * from './util/row-decoder.js';
 export * from './util/sql-tag.js';
 export * from './util/stringify-arrayliteral.js';
 export * from './util/stringify-for-sql.js';

package/interfaces/batch-result.d.ts

@@ -0,0 +1,42 @@
+import type { FieldInfo } from './field-info.js';
+/**
+ * What one parameter set in a batch produced. There is exactly one of
+ * these per set handed to `PreparedStatement.executeBatch()`, in the same
+ * order - the server answers each Execute with its own CommandComplete,
+ * so the mapping is positional and does not depend on the statement.
+ */
+export interface BatchCommandResult {
+    /** The command tag PostgreSQL reported for this set (INSERT/UPDATE/...). */
+    command?: string;
+    /** Rows affected, for INSERT/UPDATE/DELETE - as in QueryResult. */
+    rowsAffected?: number;
+    /**
+     * Rows this set returned, decoded the same way `execute()` decodes them
+     * (including any `rowDecoder` given in the options). Only present when
+     * the statement actually returns rows - a plain UPDATE without RETURNING
+     * leaves this undefined rather than setting it to an empty array.
+     */
+    rows?: any[];
+}
+/**
+ * The result of `PreparedStatement.executeBatch()`.
+ *
+ * `results` is always the full set of *completed* sets. On success that is
+ * every set that was submitted; when the server rejects one, the batch
+ * stops there (see the class doc) and the completed prefix is attached to
+ * the thrown error as `batchResults` instead.
+ */
+export interface BatchResult {
+    /** One entry per parameter set, in submission order. */
+    results: BatchCommandResult[];
+    /** Sum of every set's `rowsAffected`, for the common bulk-write case. */
+    totalRowsAffected: number;
+    /**
+     * Column descriptions, when the statement returns rows. One copy for the
+     * whole batch rather than per set: every set runs the same prepared
+     * statement, so the shape cannot differ between them.
+     */
+    fields?: FieldInfo[];
+    /** Wall time for the whole batch, when `timing` is enabled. */
+    executeTime?: number;
+}

package/interfaces/batch-result.js

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

package/interfaces/command-result.d.ts

@@ -14,9 +14,10 @@ export interface CommandResult {
      */
     rows?: Row[];
     /**
-     * Contains row type
+     * Contains row type - `'custom'` when a custom `RowDecoder` instance was
+     * supplied via `rowDecoder` (there's no way to know what shape it returns)
      */
-    rowType?: 'array' | 'object';
+    rowType?: 'array' | 'object' | 'custom';
     /**
      * Time elapsed to execute command - only measured when `timing` is
      * enabled (off by default; see `DatabaseConnectionParams.timing`).

package/interfaces/copy-from-rows-options.d.ts

@@ -0,0 +1,58 @@
+import type { DataTypeMap } from '../data-type-map.js';
+import type { OID } from '../types.js';
+import type { DataMappingOptions } from './data-mapping-options.js';
+export interface CopyFromRowsOptions extends DataMappingOptions {
+    /** Type registry used to encode values; defaults to GlobalTypeMap. */
+    typeMap?: DataTypeMap;
+    /**
+     * Destination columns, in the order the rows supply them. Omitted means
+     * every column of the table, in table order - the same default `COPY
+     * table FROM STDIN` has without a column list.
+     */
+    columns?: string[];
+    /**
+     * Type OIDs for those columns, skipping the round trip that would
+     * otherwise ask the server for them.
+     *
+     * Only worth setting to avoid that probe on a hot path, and only when the
+     * OIDs are known to match the table: binary COPY does no conversion, so a
+     * wrong OID here is not a mismatch the server can reconcile - it either
+     * rejects the stream or, for two types that happen to share a width,
+     * stores the bytes as the wrong value.
+     */
+    columnTypes?: OID[];
+    /**
+     * Bytes to accumulate before sending a CopyData message. Defaults to
+     * 128KB; anything from 64KB to 256KB measures much the same, while a
+     * message per row is roughly ten times slower.
+     */
+    chunkSize?: number;
+    /**
+     * What to do with a value the destination column's type cannot encode -
+     * `'abc'` for an integer column, `{}` for a numeric one.
+     *
+     * `'throw'` (default) aborts the copy, naming the row and column. The
+     * other two exist for a load big enough that abandoning it over one bad
+     * record costs more than the record is worth: `'null'` writes NULL in
+     * that column and keeps the row, `'skip'` drops the row entirely. Both
+     * report how many they touched, so a tolerant load still says what it
+     * swallowed rather than looking clean.
+     *
+     * None of them apply to NaN or Infinity in a float or numeric column -
+     * PostgreSQL stores those as values distinct from NULL, so they encode
+     * normally and are never "invalid".
+     */
+    onInvalidValue?: 'throw' | 'null' | 'skip';
+}
+/** What `copyFromRows()` reports back. */
+export interface CopyFromRowsResult {
+    /** Rows actually sent to the server. */
+    rowCount: number;
+    /**
+     * Rows dropped under `onInvalidValue: 'skip'`. Always 0 otherwise, and a
+     * non-zero value here is the only sign a tolerant load lost anything.
+     */
+    skippedRows: number;
+    /** Values replaced with NULL under `onInvalidValue: 'null'`. */
+    nulledValues: number;
+}

package/interfaces/copy-from-rows-options.js

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

package/interfaces/data-type.d.ts

@@ -10,7 +10,6 @@ export interface DataType {
     decodeBinary: DecodeBinaryFunction;
     decodeText: DecodeTextFunction;
     decodeTextBuffer?: DecodeTextBufferFunction;
-    fixedBinarySize?: number;
     encodeAsNull?: EncodeAsNullFunction;
     encodeBinary?: EncodeBinaryFunction;
     encodeText?: EncodeTextFunction;

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

@@ -83,6 +83,31 @@ export interface DatabaseConnectionParams {
      * @default false
      */
     autoCommit?: boolean;
+    /**
+     * Reuse a server-side prepared statement for SQL this connection has run
+     * before, instead of parsing it again every time.
+     *
+     * On by default. A repeated query then costs Bind/Execute rather than
+     * Parse/Bind/Describe/Execute, which on fifty concurrent calls of one
+     * statement measured 0.97ms against 3.13ms.
+     *
+     * Turn it off when named prepared statements cannot survive between
+     * calls - the usual case being PgBouncer in transaction pooling mode
+     * before 1.21, which hands each transaction a different backend, so a
+     * statement prepared on one is missing on the next.
+     *
+     * @default true
+     */
+    prepare?: boolean;
+    /**
+     * How many prepared statements one connection keeps. The least recently
+     * used is closed when the limit is reached, so an application that
+     * builds SQL text dynamically cannot accumulate statements on the server
+     * without bound.
+     *
+     * @default 64
+     */
+    preparedStatementCacheSize?: number;
     /**
      * When on, if a statement in a transaction block generates an error,
      * the error is ignored and the transaction continues.

package/interfaces/pipeline-request.d.ts

@@ -0,0 +1,16 @@
+import type { Maybe, OID } from '../types.js';
+/**
+ * One statement in a `Connection.pipeline()` call. The `sql` tag's own
+ * output satisfies this shape, so a pipeline can be written straight from
+ * tagged templates without any conversion.
+ */
+export interface PipelineRequest {
+    sql: string;
+    params?: any[];
+    /**
+     * Parameter type OIDs for this statement. Per statement rather than per
+     * pipeline: the statements differ, so one shared list could only ever be
+     * right for one of them.
+     */
+    paramTypes?: Maybe<OID>[];
+}

package/interfaces/pipeline-request.js

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

package/interfaces/query-options.d.ts

@@ -1,6 +1,7 @@
 import type { BindParam } from '../connection/bind-param.js';
 import type { DataFormat } from '../constants.js';
 import type { DataTypeMap } from '../data-type-map.js';
+import type { RowDecoder } from '../util/row-decoder.js';
 import type { DataMappingOptions } from './data-mapping-options.js';
 export interface QueryOptions extends DataMappingOptions {
     /**
@@ -10,9 +11,26 @@ export interface QueryOptions extends DataMappingOptions {
     autoCommit?: 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
+     * as before, it's just the same thing `rowDecoder` now also expresses.
      * @default false
      */
     objectRows?: boolean;
+    /**
+     * Overrides the connection's `prepare` setting for this call - `false`
+     * to keep a one-off statement out of the cache, `true` to use it on a
+     * connection that has caching off.
+     */
+    prepare?: boolean;
+    /**
+     * Controls how each row's raw column data is turned into the value handed back to the
+     * caller. `'array'` and `'object'` select the built-in decoders (the same output
+     * `objectRows` has always produced); pass an instance of your own `RowDecoder` subclass
+     * to take over decoding entirely instead - e.g. for lazy per-cell decoding. Takes
+     * precedence over `objectRows` when both are set.
+     * @default 'array'
+     */
+    rowDecoder?: 'array' | 'object' | RowDecoder;
     /**
      * Data type map instance
      * @default GlobalTypeMap

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

@@ -1,4 +1,5 @@
 import type { DataTypeMap } from '../data-type-map.js';
+import type { RowDecoder } from '../util/row-decoder.js';
 import type { DataMappingOptions } from './data-mapping-options.js';
 export interface ScriptExecuteOptions extends DataMappingOptions {
     /**
@@ -8,9 +9,20 @@ export interface ScriptExecuteOptions extends DataMappingOptions {
     autoCommit?: 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
+     * as before, it's just the same thing `rowDecoder` now also expresses.
      * @default false
      */
     objectRows?: boolean;
+    /**
+     * Controls how each row's raw column data is turned into the value handed back to the
+     * caller. `'array'` and `'object'` select the built-in decoders (the same output
+     * `objectRows` has always produced); pass an instance of your own `RowDecoder` subclass
+     * to take over decoding entirely instead - e.g. for lazy per-cell decoding. Takes
+     * precedence over `objectRows` when both are set.
+     * @default 'array'
+     */
+    rowDecoder?: 'array' | 'object' | RowDecoder;
     /**
      * Data type map instance
      * @default GlobalTypeMap

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "postgrejs",
   "description": "Professional PostgreSQL client NodeJS",
-  "version": "3.1.3",
+  "version": "3.4.0",
   "author": "Panates",
   "license": "BSD-3-Clause",
   "dependencies": {
     "@jsopen/objects": "^2.2.3",
     "doublylinked": "^2.5.6",
+    "flexy-buffer": "^1.1.0",
     "lightning-pool": "^4.12.0",
     "power-tasks": "^1.14.2",
     "putil-promisify": "^1.10.1",
@@ -28,7 +29,10 @@
   },
   "homepage": "https://www.postgrejs.com/",
   "contributors": [
-    "Eray Hanoglu <e.hanoglu@panates.com>"
+    "Eray Hanoglu <e.hanoglu@panates.com>",
+    "Ilker Gurelli <i.gurelli@panates.com>",
+    "Onur Tokel <o.tokel@panates.com>",
+    "Bircan Yuruk <b.yuruk@panates.com>"
   ],
   "repository": {
     "type": "git",
@@ -45,7 +49,18 @@
     "client",
     "backend",
     "rdbms",
-    "sql"
+    "sql",
+    "typescript",
+    "wire-protocol",
+    "no-native-bindings",
+    "cursor",
+    "server-side-cursor",
+    "logical-replication",
+    "copy",
+    "connection-pool",
+    "prepared-statements",
+    "bun",
+    "bunjs"
   ],
   "publishConfig": {
     "access": "public"

package/protocol/backend.js

@@ -124,7 +124,7 @@ function parseAuthentication(io, code, len) {
         case 5:
             return {
                 kind: 'MD5Password',
-                salt: io.readBuffer(len - 8),
+                salt: io.readBytes(len - 8),
             };
         case 6:
             return {
@@ -141,7 +141,7 @@ function parseAuthentication(io, code, len) {
         case 8:
             return {
                 kind: 'GSSContinue',
-                data: io.readBuffer(len - 8),
+                data: io.readBytes(len - 8),
             };
         case 10: {
             const out = {
@@ -174,7 +174,7 @@ function parseBackendKeyData(io) {
     // this message's body (see Backend.parse()), so the secret key is
     // simply whatever bytes remain - 4 of them before protocol 3.2, up to
     // 256 with it (see VERSION_MINOR_LONG_CANCEL_KEY).
-    const secretKey = io.readBuffer();
+    const secretKey = io.readBytes();
     return { processID, secretKey };
 }
 function parseCommandComplete(io) {
@@ -184,7 +184,7 @@ function parseCommandComplete(io) {
 }
 function parseCopyData(io, code, len) {
     return {
-        data: io.readBuffer(len - 4),
+        data: io.readBytes(len - 4),
     };
 }
 function parseCopyResponse(io) {
@@ -208,7 +208,7 @@ function parseCopyResponse(io) {
 }
 function parseDataRow(io, code, len) {
     const columnCount = io.readUInt16BE();
-    const data = io.readBuffer(len - 6);
+    const data = io.readBytes(len - 6);
     return { columnCount, data };
 }
 function parseErrorResponse(io) {
@@ -234,7 +234,7 @@ function parseFunctionCallResponse(io) {
     // bytes following) - not deducible from the outer message length alone,
     // unlike most fixed-shape messages this codebase parses.
     const len = io.readInt32BE();
-    return { result: len < 0 ? null : io.readBuffer(len) };
+    return { result: len < 0 ? null : io.readBytes(len) };
 }
 function parseNegotiateProtocolVersion(io) {
     const supportedVersionMinor = io.readUInt32BE();

package/protocol/buffer-reader.d.ts

@@ -1,15 +1,10 @@
-export declare class BufferReader {
-    buffer: Buffer;
-    offset: number;
-    constructor(buffer: Buffer);
-    get length(): number;
-    readUInt8(): number;
-    readUInt16BE(): number;
-    readInt16BE(): number;
-    readUInt32BE(): number;
-    readInt32BE(): number;
+import { BufferReader as FlexyBufferReader } from 'flexy-buffer';
+/**
+ * Adds the PostgreSQL wire format's two string encodings on top of
+ * flexy-buffer's `BufferReader`: a NUL-terminated C string, and a
+ * length-prefixed string where a negative length is the NULL sentinel.
+ */
+export declare class BufferReader extends FlexyBufferReader {
     readCString(encoding?: BufferEncoding): string;
     readLString(len: number, encoding?: BufferEncoding): string | null;
-    readBuffer(len?: number): Buffer;
-    private _checkReadable;
 }

package/protocol/buffer-reader.js

@@ -1,68 +1,21 @@
-export class BufferReader {
-    buffer;
-    offset = 0;
-    constructor(buffer) {
-        this.buffer = buffer;
-    }
-    get length() {
-        return this.buffer.length;
-    }
-    readUInt8() {
-        this._checkReadable(1);
-        const v = this.buffer.readUInt8(this.offset);
-        this.offset++;
-        return v;
-    }
-    readUInt16BE() {
-        this._checkReadable(2);
-        const v = this.buffer.readUInt16BE(this.offset);
-        this.offset += 2;
-        return v;
-    }
-    readInt16BE() {
-        this._checkReadable(2);
-        const v = this.buffer.readInt16BE(this.offset);
-        this.offset += 2;
-        return v;
-    }
-    readUInt32BE() {
-        this._checkReadable(4);
-        const v = this.buffer.readUInt32BE(this.offset);
-        this.offset += 4;
-        return v;
-    }
-    readInt32BE() {
-        this._checkReadable(4);
-        const v = this.buffer.readInt32BE(this.offset);
-        this.offset += 4;
-        return v;
-    }
+import { BufferReader as FlexyBufferReader } from 'flexy-buffer';
+/**
+ * Adds the PostgreSQL wire format's two string encodings on top of
+ * flexy-buffer's `BufferReader`: a NUL-terminated C string, and a
+ * length-prefixed string where a negative length is the NULL sentinel.
+ */
+export class BufferReader extends FlexyBufferReader {
     readCString(encoding) {
-        const idx = this.buffer.indexOf(0, this.offset);
+        const idx = this.buffer.indexOf(0, this.position);
         if (idx === -1)
             throw new Error('Eof in buffer detected (readCString)');
-        const v = this.buffer.toString(encoding, this.offset, idx);
-        this.offset = idx + 1;
+        const v = this.buffer.toString(encoding, this.position, idx);
+        this.position = idx + 1;
         return v;
     }
     readLString(len, encoding) {
         if (len < 0)
             return null;
-        this._checkReadable(len);
-        const v = this.buffer.toString(encoding, this.offset, this.offset + len);
-        this.offset += len;
-        return v;
-    }
-    readBuffer(len) {
-        if (len)
-            this._checkReadable(len);
-        const end = len !== undefined ? this.offset + len : this.length;
-        const buf = this.buffer.subarray(this.offset, end);
-        this.offset = end;
-        return buf;
-    }
-    _checkReadable(size) {
-        if (this.offset + size - 1 >= this.length)
-            throw new Error('Eof in buffer detected');
+        return this.readString(len, encoding);
     }
 }

package/protocol/database-error.d.ts

@@ -1,5 +1,21 @@
+import type { BatchCommandResult } from '../interfaces/batch-result.js';
 import { Protocol } from './protocol.js';
 export declare class DatabaseError extends Error {
+    /**
+     * Which entry of a multi-statement submission the server rejected -
+     * PreparedStatement.executeBatch()'s parameter sets, or the statements
+     * given to Connection.pipeline(). Entries after this index never ran:
+     * PostgreSQL discards everything between an error and the single Sync
+     * that closes such a submission.
+     */
+    failedIndex?: number;
+    /**
+     * The sets that had already completed when the batch failed, in
+     * submission order - only set by PreparedStatement.executeBatch(). They
+     * did run, but the batch shares one implicit transaction, so unless an
+     * explicit transaction was already open they are rolled back with it.
+     */
+    batchResults?: BatchCommandResult[];
     severity?: string;
     code?: string;
     detail?: string;

package/protocol/database-error.js

@@ -1,5 +1,20 @@
 import { Protocol } from './protocol.js';
 export class DatabaseError extends Error {
+    /**
+     * Which entry of a multi-statement submission the server rejected -
+     * PreparedStatement.executeBatch()'s parameter sets, or the statements
+     * given to Connection.pipeline(). Entries after this index never ran:
+     * PostgreSQL discards everything between an error and the single Sync
+     * that closes such a submission.
+     */
+    failedIndex;
+    /**
+     * The sets that had already completed when the batch failed, in
+     * submission order - only set by PreparedStatement.executeBatch(). They
+     * did run, but the batch shares one implicit transaction, so unless an
+     * explicit transaction was already open they are rolled back with it.
+     */
+    batchResults;
     severity;
     code;
     detail;