postgrejs 3.11.1 → 3.12.1

package/data-types/tid-type.js

@@ -11,6 +11,7 @@ import { DataTypeOIDs } from '../constants.js';
  * leaves it a string too.
  */
 const TID_PATTERN = /^\(\s*(\d+)\s*,\s*(\d+)\s*\)$/;
+/** `tid`, a physical row address, as the `(block,offset)` text the server prints. */
 export const TidType = {
     name: 'tid',
     oid: DataTypeOIDs.tid,
@@ -42,6 +43,7 @@ export const TidType = {
         return typeof v === 'string' && TID_PATTERN.test(v);
     },
 };
+/** The `_tid` array of {@link TidType}. */
 export const ArrayTidType = {
     ...TidType,
     name: '_tid',

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

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `time`, as a `Date` on the epoch day carrying that clock time. */
 export declare const TimeType: DataType;
+/** The `_time` array of {@link TimeType}. */
 export declare const ArrayTimeType: DataType;

package/data-types/time-type.js

@@ -3,6 +3,7 @@ import { formatTime } from '../util/format-datetime.js';
 import { utcPartsAsLocal } from '../util/local-date.js';
 import { parseTime, STRICT_TIME_PATTERN } from '../util/parse-time.js';
 const timeMul = 4294967296;
+/** `time`, as a `Date` on the epoch day carrying that clock time. */
 export const TimeType = {
     name: 'time',
     oid: DataTypeOIDs.time,
@@ -46,6 +47,7 @@ export const TimeType = {
             (typeof v === 'string' && STRICT_TIME_PATTERN.test(v)));
     },
 };
+/** The `_time` array of {@link TimeType}. */
 export const ArrayTimeType = {
     ...TimeType,
     name: '_time',

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

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `timestamp` (without time zone), as a `Date` reading that wall clock locally - or in UTC with `utcDates`. */
 export declare const TimestampType: DataType;
+/** The `_timestamp` array of {@link TimestampType}. */
 export declare const ArrayTimestampType: DataType;

package/data-types/timestamp-type.js

@@ -5,6 +5,7 @@ import { parseDateTime } from '../util/parse-datetime.js';
 import { parsePgTimestampBuffer } from '../util/parse-pg-timestamp.js';
 const timeShift = 946684800000;
 const timeMul = 4294967296;
+/** `timestamp` (without time zone), as a `Date` reading that wall clock locally - or in UTC with `utcDates`. */
 export const TimestampType = {
     name: 'timestamp',
     oid: DataTypeOIDs.timestamp,
@@ -72,6 +73,7 @@ export const TimestampType = {
             !(v.getFullYear() === 1970 && v.getMonth() === 0 && v.getDate() === 1));
     },
 };
+/** The `_timestamp` array of {@link TimestampType}. */
 export const ArrayTimestampType = {
     ...TimestampType,
     name: '_timestamp',

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

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `timestamptz`, as a `Date` at the instant it names, which is what the type stores. */
 export declare const TimestamptzType: DataType;
+/** The `_timestamptz` array of {@link TimestamptzType}. */
 export declare const ArrayTimestamptzType: DataType;

package/data-types/timestamptz-type.js

@@ -5,6 +5,7 @@ import { parseDateTimeTz } from '../util/parse-datetime.js';
 import { parsePgTimestampBuffer } from '../util/parse-pg-timestamp.js';
 const timeShift = 946684800000;
 const timeMul = 4294967296;
+/** `timestamptz`, as a `Date` at the instant it names, which is what the type stores. */
 export const TimestamptzType = {
     name: 'timestamptz',
     oid: DataTypeOIDs.timestamptz,
@@ -80,6 +81,7 @@ export const TimestamptzType = {
         return v instanceof Date;
     },
 };
+/** The `_timestamptz` array of {@link TimestamptzType}. */
 export const ArrayTimestamptzType = {
     ...TimestamptzType,
     name: '_timestamptz',

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

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `timetz`, as a string: the clock time and its offset, which a `Date` has nowhere to keep. */
 export declare const TimeTzType: DataType;
+/** The `_timetz` array of {@link TimeTzType}. */
 export declare const ArrayTimeTzType: DataType;

package/data-types/timetz-type.js

@@ -117,6 +117,7 @@ function formatTimeTz(micros, zone) {
         out += ':' + pad(zs);
     return out;
 }
+/** `timetz`, as a string: the clock time and its offset, which a `Date` has nowhere to keep. */
 export const TimeTzType = {
     name: 'timetz',
     oid: DataTypeOIDs.timetz,
@@ -176,6 +177,7 @@ export const TimeTzType = {
         }
     },
 };
+/** The `_timetz` array of {@link TimeTzType}. */
 export const ArrayTimeTzType = {
     ...TimeTzType,
     name: '_timetz',

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

@@ -1,5 +1,9 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `tsvector`, as its own text - the lexemes with their positions and weights. */
 export declare const TsVectorType: DataType;
+/** The `_tsvector` array of {@link TsVectorType}. */
 export declare const ArrayTsVectorType: DataType;
+/** `tsquery`, as its own text. */
 export declare const TsQueryType: DataType;
+/** The `_tsquery` array of {@link TsQueryType}. */
 export declare const ArrayTsQueryType: DataType;

package/data-types/tsvector-type.js

@@ -170,6 +170,7 @@ function printQuery(node, parentPriority, rightPhraseOp) {
         ? '( ' + out + ' )'
         : out;
 }
+/** `tsvector`, as its own text - the lexemes with their positions and weights. */
 export const TsVectorType = {
     name: 'tsvector',
     oid: DataTypeOIDs.tsvector,
@@ -190,12 +191,14 @@ export const TsVectorType = {
         return typeof v === 'string';
     },
 };
+/** The `_tsvector` array of {@link TsVectorType}. */
 export const ArrayTsVectorType = {
     ...TsVectorType,
     name: '_tsvector',
     oid: DataTypeOIDs._tsvector,
     elementsOID: DataTypeOIDs.tsvector,
 };
+/** `tsquery`, as its own text. */
 export const TsQueryType = {
     ...TsVectorType,
     name: 'tsquery',
@@ -208,6 +211,7 @@ export const TsQueryType = {
         return printQuery(readQueryNode(v, { p: offset + 4 }), 0, false);
     },
 };
+/** The `_tsquery` array of {@link TsQueryType}. */
 export const ArrayTsQueryType = {
     ...TsQueryType,
     name: '_tsquery',

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

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `uuid`, as its canonical 36-character text. */
 export declare const UuidType: DataType;
+/** The `_uuid` array of {@link UuidType}. */
 export declare const ArrayUuidType: DataType;

package/data-types/uuid-type.js

@@ -11,6 +11,7 @@ TEXT[8] = TEXT[13] = TEXT[18] = TEXT[23] = 45; /* - */
 /** Where each of the sixteen bytes writes its two characters. */
 const POSITIONS = [0, 2, 4, 6, 9, 11, 14, 16, 19, 21, 24, 26, 28, 30, 32, 34];
 const GUID_PATTERN = /^[0-9a-fA-F]{8}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{4}-?[0-9a-fA-F]{12}$/;
+/** `uuid`, as its canonical 36-character text. */
 export const UuidType = {
     name: 'uuid',
     oid: DataTypeOIDs.uuid,
@@ -41,6 +42,7 @@ export const UuidType = {
         return typeof v === 'string' && GUID_PATTERN.test(v);
     },
 };
+/** The `_uuid` array of {@link UuidType}. */
 export const ArrayUuidType = {
     ...UuidType,
     name: '_uuid',

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

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `varchar`, `text`, `name` and the other string types, as strings. */
 export declare const VarcharType: DataType;
+/** The `_varchar` array of {@link VarcharType}. */
 export declare const ArrayVarcharType: DataType;

package/data-types/varchar-type.js

@@ -1,4 +1,5 @@
 import { DataTypeOIDs } from '../constants.js';
+/** `varchar`, `text`, `name` and the other string types, as strings. */
 export const VarcharType = {
     name: 'varchar',
     oid: DataTypeOIDs.varchar,
@@ -28,6 +29,7 @@ export const VarcharType = {
         return typeof v === 'string';
     },
 };
+/** The `_varchar` array of {@link VarcharType}. */
 export const ArrayVarcharType = {
     ...VarcharType,
     name: '_varchar',

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

@@ -1,7 +1,13 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `xid`, a 32-bit transaction id, as a number. */
 export declare const XidType: DataType;
+/** The `_xid` array of {@link XidType}. */
 export declare const ArrayXidType: DataType;
+/** `cid`, a command id within a transaction, as a number. */
 export declare const CidType: DataType;
+/** The `_cid` array of {@link CidType}. */
 export declare const ArrayCidType: DataType;
+/** `xid8`, the 64-bit transaction id, as a number while one is exact and a `BigInt` beyond. */
 export declare const Xid8Type: DataType;
+/** The `_xid8` array of {@link Xid8Type}. */
 export declare const ArrayXid8Type: DataType;

package/data-types/xid-type.js

@@ -1,4 +1,5 @@
 import { DataTypeOIDs } from '../constants.js';
+import { assertInteger } from '../util/assert-integer.js';
 import { fastParseInt, fastParseIntBuffer } from '../util/fast-parseint.js';
 /**
  * `xid`, `xid8` and `cid` - the transaction and command counters behind
@@ -41,7 +42,7 @@ function createUInt32Type(name, oid) {
             return '' + v;
         },
         encodeBinary(buf, v) {
-            buf.writeUInt32BE(fastParseInt(v));
+            buf.writeUInt32BE(assertInteger(v, name, 0, 4294967295));
         },
         decodeBinary(v, offset = 0) {
             return v.readUInt32BE(offset);
@@ -56,20 +57,25 @@ function createUInt32Type(name, oid) {
         },
     };
 }
+/** `xid`, a 32-bit transaction id, as a number. */
 export const XidType = createUInt32Type('xid', DataTypeOIDs.xid);
+/** The `_xid` array of {@link XidType}. */
 export const ArrayXidType = {
     ...XidType,
     name: '_xid',
     oid: DataTypeOIDs._xid,
     elementsOID: DataTypeOIDs.xid,
 };
+/** `cid`, a command id within a transaction, as a number. */
 export const CidType = createUInt32Type('cid', DataTypeOIDs.cid);
+/** The `_cid` array of {@link CidType}. */
 export const ArrayCidType = {
     ...CidType,
     name: '_cid',
     oid: DataTypeOIDs._cid,
     elementsOID: DataTypeOIDs.cid,
 };
+/** `xid8`, the 64-bit transaction id, as a number while one is exact and a `BigInt` beyond. */
 export const Xid8Type = {
     name: 'xid8',
     oid: DataTypeOIDs.xid8,
@@ -102,6 +108,7 @@ export const Xid8Type = {
             (typeof v === 'number' && Number.isInteger(v) && v >= 0));
     },
 };
+/** The `_xid8` array of {@link Xid8Type}. */
 export const ArrayXid8Type = {
     ...Xid8Type,
     name: '_xid8',

package/interfaces/command-result.d.ts

@@ -1,5 +1,12 @@
 import type { Row } from '../types.js';
 import type { FieldInfo } from './field-info.js';
+/**
+ * What one statement answered with: its rows, what its columns were, and
+ * what the server said it did.
+ *
+ * `QueryResult` is this plus a cursor; a script's results are a list of
+ * these, one per statement in it.
+ */
 export interface CommandResult {
     /**
      * Name of the command (INSERT, SELECT, UPDATE, etc.)

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

@@ -1,6 +1,10 @@
 import type { DataTypeMap } from '../data-type-map.js';
 import type { OID } from '../types.js';
 import type { DataMappingOptions } from './data-mapping-options.js';
+/**
+ * What `copyFromRows()` takes: which columns the rows line up with, how
+ * to encode their values, and how to stop.
+ */
 export interface CopyFromRowsOptions extends DataMappingOptions {
     /** Type registry used to encode values; defaults to GlobalTypeMap. */
     typeMap?: DataTypeMap;

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

@@ -34,6 +34,12 @@ export interface FetchAsStringSelector {
      */
     ranges?: boolean;
 }
+/**
+ * How values are turned into JavaScript and back.
+ *
+ * Set on the connection to apply to everything it runs, or per call to
+ * apply to one - a call that says nothing takes the connection's.
+ */
 export interface DataMappingOptions {
     /**
      * Decode `numeric` and `money` into the exact decimal string they

package/interfaces/data-type.d.ts

@@ -1,11 +1,34 @@
 import type { DecodeBinaryFunction, DecodeTextBufferFunction, DecodeTextFunction, EncodeAsNullFunction, EncodeBinaryFunction, EncodeCalculateDimFunction, EncodeTextFunction, OID } from '../types.js';
+/**
+ * How one PostgreSQL type is read and written.
+ *
+ * One of these per type in a `DataTypeMap`, and the extension point for
+ * a type this client does not know: register it on the global map or on
+ * one of a connection's own, and every column and parameter of that OID
+ * goes through it.
+ *
+ * A type needs to decode - both formats, since which one arrives depends
+ * on what the column asked for - and needs to encode only what callers
+ * will send. Registering the array counterpart is a separate entry, with
+ * `elementsOID` pointing back at this one.
+ */
 export interface DataType {
+    /** The type's own OID, as `pg_type` gives it. */
     oid: OID;
+    /** The type's name, for `FieldInfo.dataTypeName` and for errors. */
     name: string;
+    /** For an array type, the OID of what it is an array of. */
     elementsOID?: OID;
+    /** Whether this entry is the array counterpart. */
     isArray?: boolean;
+    /** What a decoded value is, named for `FieldInfo.jsType`. */
     jsType: string;
+    /** What separates elements in this type's array literal - a comma for all but `box`. */
     arraySeparator?: string;
+    /**
+     * Whether a JavaScript value could be of this type, asked when nothing
+     * declared one - see `inferrable` for when it is asked at all.
+     */
     isType: (v: any) => boolean;
     /**
      * Whether DataTypeMap.determine() may pick this type for a value, which
@@ -18,12 +41,22 @@ export interface DataType {
      * `new BindParam(oid, value)`.
      */
     inferrable?: boolean;
+    /** Reads a value out of the binary wire format. */
     decodeBinary: DecodeBinaryFunction;
+    /** Reads a value out of the text the server rendered. */
     decodeText: DecodeTextFunction;
+    /**
+     * Reads a text value straight from the wire buffer, when the type can
+     * do better than being handed a string.
+     */
     decodeTextBuffer?: DecodeTextBufferFunction;
+    /** Whether a value should go out as SQL NULL rather than be encoded. */
     encodeAsNull?: EncodeAsNullFunction;
+    /** Writes a value in the binary wire format. */
     encodeBinary?: EncodeBinaryFunction;
+    /** Renders a value as the text the server parses. */
     encodeText?: EncodeTextFunction;
+    /** Measures an array's dimensions, for a type whose values are arrays themselves. */
     encodeCalculateDim?: EncodeCalculateDimFunction;
 }
 /**
@@ -35,8 +68,12 @@ export interface DataType {
  *   object of these four numbers is still accepted as a parameter.
  */
 export interface Rectangle {
+    /** First corner's x. */
     x1: number;
+    /** First corner's y. */
     y1: number;
+    /** Second corner's x. */
     x2: number;
+    /** Second corner's y. */
     y2: number;
 }

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

@@ -4,6 +4,14 @@ 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';
+/**
+ * Where the server is and how to log in.
+ *
+ * Every field is optional: what is left out is taken from the
+ * environment - `PGHOST`, `PGPORT`, `PGUSER`, `PGPASSWORD`, `PGDATABASE`
+ * and the rest, the same variables `psql` reads - and what neither
+ * gives falls back to PostgreSQL's own defaults.
+ */
 export interface DatabaseConnectionParams {
     /**
      * A whole connection string, as an alternative to the fields below -
@@ -15,11 +23,20 @@ export interface DatabaseConnectionParams {
      * by one that was left in the object.
      */
     connectionString?: string;
+    /** Host name, IP, or the directory of a unix socket. */
     host?: string;
+    /** Port the server listens on. */
     port?: number;
+    /** Role to connect as. */
     user?: string;
+    /**
+     * The password, or a function asked for one when the server wants it -
+     * which is where a rotating credential or a secret store goes.
+     */
     password?: string | (() => string | Promise<string>);
+    /** Database to connect to. */
     database?: string;
+    /** What this connection calls itself, shown in `pg_stat_activity`. */
     applicationName?: string;
     /**
      * Opens the connection in replication mode, which is what lets it run
@@ -155,8 +172,14 @@ export interface DatabaseConnectionParams {
     timing?: boolean;
     debugLogger?: DebugLogger;
 }
+/**
+ * Which server in a list is acceptable, checked after connecting - the
+ * same values `libpq` takes, and how a client finds the primary.
+ */
 export type TargetSessionAttrs = 'read-write' | 'read-only' | 'primary' | 'standby' | 'prefer-standby';
+/** Options passed down to the socket itself. */
 export interface SocketOptions {
+    /** Whether TCP keep-alive is turned on. */
     keepAlive?: boolean;
 }
 /**
@@ -169,6 +192,10 @@ export interface SocketOptions {
  * about - see `fetchAsString` in QueryOptions.
  */
 export type ConnectionMappingDefaults = DataMappingOptions & Pick<QueryOptions, 'objectRows' | 'rowDecoder' | 'typeMap' | 'columnFormat'>;
+/**
+ * Everything a `Connection` can be given: where the server is, how to
+ * talk to it, and the defaults every statement on it inherits.
+ */
 export interface ConnectionConfiguration extends DatabaseConnectionParams, SocketOptions, ConnectionMappingDefaults {
     buffer?: SmartBufferConfig;
     /**
@@ -186,6 +213,10 @@ export interface ConnectionConfiguration extends DatabaseConnectionParams, Socke
      */
     pipeline?: boolean;
 }
+/**
+ * A connection's configuration, plus how many of them to keep and how
+ * long an idle one lives.
+ */
 export interface PoolConfiguration extends ConnectionConfiguration, LPoolConfiguration {
     /**
      * How many of Pool.query()'s one-shot queries may share a single pooled

package/interfaces/field-info.d.ts

@@ -1,3 +1,11 @@
+/**
+ * One column of a result, as the server described it and this client
+ * mapped it.
+ *
+ * The server's half - name, type OID, table and column - comes from the
+ * RowDescription; `jsType`, the element type of an array and the fixed
+ * size are what the type map made of it.
+ */
 export interface FieldInfo {
     /**
      * Name of the field

package/interfaces/function-call-options.d.ts

@@ -1,4 +1,5 @@
 import type { DataFormat } from '../constants.js';
+/** How a `Connection.callFunction()` sends its arguments and reads back its result. */
 export interface FunctionCallOptions {
     /**
      * Format of each argument, applied positionally - omit for text (the

package/interfaces/function-call-result.d.ts

@@ -1,3 +1,9 @@
+/**
+ * What a function call answered with, undecoded.
+ *
+ * The fast-call protocol says nothing about the return type, so the
+ * bytes are handed over as they arrived for the caller to read.
+ */
 export interface FunctionCallResult {
     /**
      * The function's return value, in the wire format requested via

package/interfaces/pipeline-request.d.ts

@@ -5,7 +5,9 @@ import type { Maybe, OID } from '../types.js';
  * tagged templates without any conversion.
  */
 export interface PipelineRequest {
+    /** The statement text. */
     sql: string;
+    /** Its parameters, for `$1`, `$2` and so on. */
     params?: any[];
     /**
      * Parameter type OIDs for this statement. Per statement rather than per

package/interfaces/query-options.d.ts

@@ -3,6 +3,13 @@ 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';
+/**
+ * What `query()` and `execute()` take: the parameters, the shape of the
+ * rows, how much of the result to read, and how to stop.
+ *
+ * Everything a `DataMappingOptions` carries applies here too, and a value
+ * left out falls back to the connection's own setting.
+ */
 export interface QueryOptions extends DataMappingOptions {
     /**
      * Specifies weather execute query in auto-commit mode

package/interfaces/query-result.d.ts

@@ -1,5 +1,12 @@
 import type { Cursor } from '../connection/cursor.js';
 import type { CommandResult } from './command-result.js';
+/**
+ * What `query()` answered with - a `CommandResult`, plus the cursor when
+ * one was asked for.
+ *
+ * With `cursor: true` the rows are read through `cursor` instead of
+ * `rows`, which stays empty.
+ */
 export interface QueryResult extends CommandResult {
     /**
      * Cursor instance

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

@@ -1,6 +1,10 @@
 import type { DataTypeMap } from '../data-type-map.js';
 import type { RowDecoder } from '../util/row-decoder.js';
 import type { DataMappingOptions } from './data-mapping-options.js';
+/**
+ * What `execute()` takes for a script of several statements - how much of
+ * each result to keep, and how to read the rows it does.
+ */
 export interface ScriptExecuteOptions extends DataMappingOptions {
     /**
      * Specifies weather execute query in auto-commit mode

package/interfaces/script-result.d.ts

@@ -1,4 +1,5 @@
 import type { CommandResult } from './command-result.js';
+/** What `execute()` answered with: one result per statement in the script. */
 export interface ScriptResult {
     /**
      * Array of command result for each sql command in the script

package/interfaces/statement-prepare-options.d.ts

@@ -1,5 +1,6 @@
 import type { DataTypeMap } from '../data-type-map.js';
 import type { OID } from '../types.js';
+/** What `prepare()` takes: the parameter types to declare, and which type map to read them with. */
 export interface StatementPrepareOptions {
     /**
      * Specifies data type for each parameter

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "postgrejs",
   "description": "Professional PostgreSQL client NodeJS",
-  "version": "3.11.1",
+  "version": "3.12.1",
   "author": "Panates",
   "license": "BSD-3-Clause",
   "dependencies": {
-    "@jsopen/objects": "^2.2.3",
+    "@jsopen/objects": "^2.3.4",
     "doublylinked": "^2.5.6",
-    "flexy-buffer": "^1.1.0",
-    "lightning-pool": "^4.12.0",
+    "flexy-buffer": "^1.1.1",
+    "lightning-pool": "^4.14.0",
     "power-tasks": "^1.14.2",
     "putil-promisify": "^1.10.1",
     "putil-varhelpers": "^1.7.0",
@@ -65,4 +65,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/protocol/backend.d.ts

@@ -1,5 +1,11 @@
 import { Protocol } from './protocol.js';
 declare type ParseCallback = (code: Protocol.BackendMessageCode, data?: any) => void;
+/**
+ * Reads the server's messages out of the bytes as they arrive.
+ *
+ * Keeps whatever a chunk left half-finished, so a message split across
+ * reads - or several in one read - comes out whole exactly once.
+ */
 export declare class Backend {
     private readonly _headerBuf;
     private _headerFilled;

package/protocol/backend.js

@@ -22,6 +22,12 @@ const ErrorFieldTypes = {
     L: 'line',
     R: 'routine',
 };
+/**
+ * Reads the server's messages out of the bytes as they arrive.
+ *
+ * Keeps whatever a chunk left half-finished, so a message split across
+ * reads - or several in one read - comes out whole exactly once.
+ */
 export class Backend {
     _headerBuf = Buffer.allocUnsafe(HEADER_LENGTH);
     _headerFilled = 0;
@@ -47,10 +53,17 @@ export class Backend {
                 const bodyStart = pos + HEADER_LENGTH;
                 const bodyEnd = bodyStart + (len - 4);
                 if (bodyEnd <= dataLen) {
-                    const io = new BufferReader(data.subarray(bodyStart, bodyEnd));
-                    const parser = MessageParsers[code];
-                    const v = parser && parser(io, code, len);
-                    callback(code, v);
+                    if (code === Protocol.BackendMessageCode.DataRow) {
+                        // Straight out of the read buffer: no view of the body, no
+                        // reader over it, and no view of the row's own bytes either.
+                        callback(code, dataRowMessage(data, bodyStart, bodyEnd));
+                    }
+                    else {
+                        const io = new BufferReader(data.subarray(bodyStart, bodyEnd));
+                        const parser = MessageParsers[code];
+                        const v = parser && parser(io, code, len);
+                        callback(code, v);
+                    }
                     pos = bodyEnd;
                     continue;
                 }
@@ -206,10 +219,27 @@ function parseCopyResponse(io) {
     }
     return out;
 }
+/**
+ * One row, pointing into the read buffer rather than copying out of it.
+ *
+ * A consumer that needs a `Buffer` of its own - a caller's RowDecoder,
+ * or a path that sets the row aside and reads it later - builds the view
+ * with `dataRowBytes()`. The decoders that read the row in place never
+ * do, which is the point.
+ */
+function dataRowMessage(buffer, bodyStart, bodyEnd) {
+    const offset = bodyStart + 2;
+    return {
+        columnCount: buffer.readUInt16BE(bodyStart),
+        buffer,
+        offset,
+        len: bodyEnd - offset,
+    };
+}
 function parseDataRow(io, code, len) {
     const columnCount = io.readUInt16BE();
     const data = io.readBytes(len - 6);
-    return { columnCount, data };
+    return { columnCount, buffer: data, offset: 0, len: data.length };
 }
 function parseErrorResponse(io) {
     const out = {};