postgrejs 3.12.0 → 3.12.1

package/util/escape-literal.js

@@ -1,4 +1,17 @@
 // Ported from PostgreSQL 9.2.4 source code in src/interfaces/libpq/fe-exec.c
+/**
+ * Quotes a string as an SQL literal, escaping what has to be escaped.
+ *
+ * For the `sql` tag and anything else that has to put a value into the
+ * statement text; a parameter never needs this.
+ *
+ * @param str The value to quote.
+ * @returns The quoted literal, `E`-prefixed when it carries a backslash.
+ * @throws Error When the string holds a NUL byte, which PostgreSQL text
+ * cannot.
+ */
+/* Ported from PostgreSQL's own src/interfaces/libpq/fe-exec.c (9.2.4),
+   so it quotes what libpq quotes, the way libpq quotes it. */
 export function escapeLiteral(str) {
     if (str.indexOf('\0') >= 0) {
         throw new Error('PostgreSQL text values cannot contain NUL (\\0) bytes');

package/util/fast-parseint.d.ts

@@ -1,2 +1,16 @@
+/**
+ * Reads an integer out of what a decoder was handed.
+ *
+ * @param str The text, or a number already.
+ * @returns The integer, or NaN when there is none to read.
+ */
 export declare function fastParseInt(str: string | number): number;
+/**
+ * The same, straight from the wire bytes - no string is made.
+ *
+ * @param buf The buffer holding the digits.
+ * @param offset Where they start.
+ * @param len How many bytes they run for.
+ * @returns The integer the digits spell.
+ */
 export declare function fastParseIntBuffer(buf: Buffer, offset?: number, len?: number): number;

package/util/fast-parseint.js

@@ -1,3 +1,9 @@
+/**
+ * Reads an integer out of what a decoder was handed.
+ *
+ * @param str The text, or a number already.
+ * @returns The integer, or NaN when there is none to read.
+ */
 export function fastParseInt(str) {
     /* c8 ignore next */
     if (typeof str === 'number')
@@ -7,6 +13,14 @@ export function fastParseInt(str) {
         return NaN;
     return parseInt(str, 10);
 }
+/**
+ * The same, straight from the wire bytes - no string is made.
+ *
+ * @param buf The buffer holding the digits.
+ * @param offset Where they start.
+ * @param len How many bytes they run for.
+ * @returns The integer the digits spell.
+ */
 export function fastParseIntBuffer(buf, offset = 0, len = buf.length - offset) {
     const end = offset + len;
     let i = offset;

package/util/format-datetime.d.ts

@@ -1,6 +1,32 @@
 import type { DataMappingOptions } from '../interfaces/data-mapping-options.js';
+/**
+ * Renders a value as the `YYYY-MM-DD` a `date` parameter goes out as.
+ *
+ * @param v The date, an epoch milliseconds, or text to pass through.
+ * @param options `utcDates` decides which clock its components are read
+ * from.
+ * @returns The date's text.
+ */
 export declare function formatDate(v: Date | number | string, options?: DataMappingOptions): string;
+/**
+ * Renders a value as the `HH:MM:SS.mmm` a `time` parameter goes out as.
+ *
+ * @param v The time, an epoch milliseconds, or text to pass through.
+ * @param options `utcDates` decides which clock its components are read
+ * from.
+ * @returns The time's text.
+ */
 export declare function formatTime(v: Date | number | string, options?: DataMappingOptions): string;
+/**
+ * Renders a value as the `YYYY-MM-DD HH:MM:SS.mmm` a `timestamp`
+ * parameter goes out as.
+ *
+ * @param v The timestamp, an epoch milliseconds, or text to pass
+ * through.
+ * @param options `utcDates` decides which clock its components are read
+ * from.
+ * @returns The timestamp's text.
+ */
 export declare function formatTimestamp(v: Date | number | string, options?: DataMappingOptions): string;
 /**
  * timestamptz is an absolute instant - its binary encoder uses getTime()

package/util/format-datetime.js

@@ -38,6 +38,14 @@ function coerce(v) {
         return '-infinity';
     return v instanceof Date ? v : new Date(v);
 }
+/**
+ * Renders a value as the `YYYY-MM-DD` a `date` parameter goes out as.
+ *
+ * @param v The date, an epoch milliseconds, or text to pass through.
+ * @param options `utcDates` decides which clock its components are read
+ * from.
+ * @returns The date's text.
+ */
 export function formatDate(v, options) {
     const d = coerce(v);
     if (typeof d === 'string')
@@ -45,6 +53,14 @@ export function formatDate(v, options) {
     const p = parts(d, options);
     return `${pad(p.year, 4)}-${pad(p.month)}-${pad(p.day)}`;
 }
+/**
+ * Renders a value as the `HH:MM:SS.mmm` a `time` parameter goes out as.
+ *
+ * @param v The time, an epoch milliseconds, or text to pass through.
+ * @param options `utcDates` decides which clock its components are read
+ * from.
+ * @returns The time's text.
+ */
 export function formatTime(v, options) {
     const d = coerce(v);
     if (typeof d === 'string')
@@ -52,6 +68,16 @@ export function formatTime(v, options) {
     const p = parts(d, options);
     return `${pad(p.hour)}:${pad(p.minute)}:${pad(p.second)}.${pad(p.ms, 3)}`;
 }
+/**
+ * Renders a value as the `YYYY-MM-DD HH:MM:SS.mmm` a `timestamp`
+ * parameter goes out as.
+ *
+ * @param v The timestamp, an epoch milliseconds, or text to pass
+ * through.
+ * @param options `utcDates` decides which clock its components are read
+ * from.
+ * @returns The timestamp's text.
+ */
 export function formatTimestamp(v, options) {
     const d = coerce(v);
     if (typeof d === 'string')

package/util/get-parsers.d.ts

@@ -2,4 +2,13 @@ import type { DataTypeMap } from '../data-type-map.js';
 import type { DataMappingOptions } from '../interfaces/data-mapping-options.js';
 import type { Protocol } from '../protocol/protocol.js';
 import type { AnyParseFunction } from '../types.js';
+/**
+ * Chooses one parser per column, for the format that column is coming
+ * back in.
+ *
+ * @param typeMap Where the types are registered.
+ * @param fields The columns, as the server described them.
+ * @param options `fetchAsString` and the rest of the mapping options.
+ * @returns One parser per column, in order.
+ */
 export declare function getParsers(typeMap: DataTypeMap, fields: Protocol.RowDescription[], mappingOptions?: DataMappingOptions): AnyParseFunction[];

package/util/get-parsers.js

@@ -4,6 +4,15 @@ import { fetchAsStringNamesElement, fetchAsStringNamesOid, } from './fetch-as-st
 import { parsePostgresArray } from './parse-array.js';
 const DefaultColumnParser = (data, offset, len) => data.subarray(offset, offset + len);
 const DefaultTextColumnParser = (data, offset, len) => data.toString('utf8', offset, offset + len);
+/**
+ * Chooses one parser per column, for the format that column is coming
+ * back in.
+ *
+ * @param typeMap Where the types are registered.
+ * @param fields The columns, as the server described them.
+ * @param options `fetchAsString` and the rest of the mapping options.
+ * @returns One parser per column, in order.
+ */
 export function getParsers(typeMap, fields, mappingOptions) {
     const parsers = new Array(fields.length);
     const asString = mappingOptions?.fetchAsString;

package/util/hex-text.d.ts

@@ -1,26 +1,18 @@
 /**
- * Writes `count` bytes of `src` into `scratch` as lowercase hex, each
- * byte's two characters starting at `positions[i]` - so the separators
- * a type writes between its bytes are put in once, when the scratch is
- * built, and never again.
+ * Writes `count` bytes of `src` into `scratch` as lowercase hex, two
+ * characters per byte, the first at `positions[i]`.
  *
- * The scratch is then read back with `latin1`, which is what the text
- * paths of these types already use: the output is fixed-format ASCII,
- * so it decodes identically to `utf8` and skips V8's multi-byte-sequence
- * detection.
+ * The positions are what let a type keep the separators of its own text
+ * form - a uuid's dashes, a macaddr's colons - in the scratch, written
+ * once when it is built and never again. The scratch is read back with
+ * `latin1`, which is what these types' text paths already use: the
+ * output is fixed-format ASCII, so it decodes identically to `utf8` and
+ * skips V8's multi-byte-sequence detection.
  *
- * Why not `Buffer.toString('hex')`: a type whose text has separators in
- * it has to call that once per group and join the pieces. For `uuid`
- * that was five calls and four concatenations per value - 25 000 strings
- * and 20 000 concatenations for a 5 000-row column, which is more work
- * than `pg` does for the same column despite this client reading half
- * the bytes. Measured over 5 000 values, medians of nine runs:
- *
- * ```
- * five toString + concat        1.86 ms
- * one toString, then slice      0.81 ms
- * a byte -> two-char table      0.64 ms
- * this                          0.33 ms
- * ```
+ * @param scratch The buffer to write into, reused across values.
+ * @param positions Where each byte's two characters go.
+ * @param src The bytes to render.
+ * @param offset Where they start in `src`.
+ * @param count How many to render.
  */
 export declare function writeHexBytes(scratch: Buffer, positions: number[], src: Buffer, offset: number, count: number): void;

package/util/hex-text.js

@@ -1,30 +1,33 @@
 /** `0`-`f` as bytes, so a nibble indexes straight into it. */
 const HEX = Buffer.from('0123456789abcdef', 'latin1');
 /**
- * Writes `count` bytes of `src` into `scratch` as lowercase hex, each
- * byte's two characters starting at `positions[i]` - so the separators
- * a type writes between its bytes are put in once, when the scratch is
- * built, and never again.
+ * Writes `count` bytes of `src` into `scratch` as lowercase hex, two
+ * characters per byte, the first at `positions[i]`.
  *
- * The scratch is then read back with `latin1`, which is what the text
- * paths of these types already use: the output is fixed-format ASCII,
- * so it decodes identically to `utf8` and skips V8's multi-byte-sequence
- * detection.
+ * The positions are what let a type keep the separators of its own text
+ * form - a uuid's dashes, a macaddr's colons - in the scratch, written
+ * once when it is built and never again. The scratch is read back with
+ * `latin1`, which is what these types' text paths already use: the
+ * output is fixed-format ASCII, so it decodes identically to `utf8` and
+ * skips V8's multi-byte-sequence detection.
  *
- * Why not `Buffer.toString('hex')`: a type whose text has separators in
- * it has to call that once per group and join the pieces. For `uuid`
- * that was five calls and four concatenations per value - 25 000 strings
- * and 20 000 concatenations for a 5 000-row column, which is more work
- * than `pg` does for the same column despite this client reading half
- * the bytes. Measured over 5 000 values, medians of nine runs:
- *
- * ```
- * five toString + concat        1.86 ms
- * one toString, then slice      0.81 ms
- * a byte -> two-char table      0.64 ms
- * this                          0.33 ms
- * ```
+ * @param scratch The buffer to write into, reused across values.
+ * @param positions Where each byte's two characters go.
+ * @param src The bytes to render.
+ * @param offset Where they start in `src`.
+ * @param count How many to render.
  */
+/* Why not Buffer.toString('hex'): a type whose text has separators in it
+   has to call that once per group and join the pieces. For uuid that was
+   five calls and four concatenations per value - 25 000 strings and
+   20 000 concatenations for a 5 000-row column, more work than pg does
+   for the same column despite this client reading half the bytes.
+   Measured over 5 000 values, medians of nine runs:
+
+     five toString + concat        1.86 ms
+     one toString, then slice      0.81 ms
+     a byte -> two-char table      0.64 ms
+     this                          0.33 ms */
 export function writeHexBytes(scratch, positions, src, offset, count) {
     let i;
     let p;

package/util/local-date.d.ts

@@ -7,46 +7,7 @@
  * comes back as a Date reading 10:30 locally rather than the instant
  * 10:30Z.
  *
- * Doing that by reading the seven `getUTC*` components off one Date and
- * handing them to another was the most expensive thing left in the
- * common decode path - the getters alone cost more than either Date:
- *
- * ```
- * new Date(epochMs)               43.6 ns
- * getUTC* x 7                     97.4 ns
- * new Date(y, m, d, h, mi, s, ms) 61.7 ns
- * ```
- *
- * Shifting the instant by the zone's own offset lands on the same wall
- * clock for a fraction of that, but only where the offset is a whole
- * number of minutes and holds either side of where the shift lands.
- * Two guards and a floor make that exact rather than usually-right:
- *
- * - **The offset must survive the shift.** Where it does not, the shift
- *   crossed a transition and the wall clock it landed on is not the one
- *   that was asked for - or does not exist at all.
- * - **The offset must hold for the hour before the landing too.** That
- *   is the hour a backward transition repeats, where both instants read
- *   the same wall clock and the shift keeps the wrong one of the two.
- *   Pacific/Chatham found this: `2024-04-07T03:00Z` is `03:00` in both
- *   +12:45 and +13:45, an hour apart.
- * - **Nothing before 1970.** A zone's pre-standard offset carries
- *   seconds - Europe/Istanbul was +01:55:52 - and `getTimezoneOffset()`
- *   answers in whole minutes, so the shift lands up to 59 seconds off.
- *   The tz database does not claim correctness before 1970 either.
- *
- * Whatever fails those goes back to the component route, which is what
- * this has always answered. Checked against it over 1850-2040 at
- * 90-minute steps - 1.1 million instants - in ten zones including the
- * 45-minute and 30-minute DST ones: no disagreement, and
- *
- * ```
- *                    before     after
- * Europe/Istanbul    157.5 ns   123.0 ns
- * America/New_York   245.6 ns   131.2 ns
- * ```
- *
- * The DST zone was dearer before because V8 pays for a transition lookup
- * on every local construction; here it pays for one instant instead.
+ * @param ms The instant whose UTC components are the wall clock wanted.
+ * @returns A Date reading that wall clock in the local zone.
  */
 export declare function utcPartsAsLocal(ms: number): Date;

package/util/local-date.js

@@ -7,48 +7,46 @@
  * comes back as a Date reading 10:30 locally rather than the instant
  * 10:30Z.
  *
- * Doing that by reading the seven `getUTC*` components off one Date and
- * handing them to another was the most expensive thing left in the
- * common decode path - the getters alone cost more than either Date:
- *
- * ```
- * new Date(epochMs)               43.6 ns
- * getUTC* x 7                     97.4 ns
- * new Date(y, m, d, h, mi, s, ms) 61.7 ns
- * ```
- *
- * Shifting the instant by the zone's own offset lands on the same wall
- * clock for a fraction of that, but only where the offset is a whole
- * number of minutes and holds either side of where the shift lands.
- * Two guards and a floor make that exact rather than usually-right:
- *
- * - **The offset must survive the shift.** Where it does not, the shift
- *   crossed a transition and the wall clock it landed on is not the one
- *   that was asked for - or does not exist at all.
- * - **The offset must hold for the hour before the landing too.** That
- *   is the hour a backward transition repeats, where both instants read
- *   the same wall clock and the shift keeps the wrong one of the two.
- *   Pacific/Chatham found this: `2024-04-07T03:00Z` is `03:00` in both
- *   +12:45 and +13:45, an hour apart.
- * - **Nothing before 1970.** A zone's pre-standard offset carries
- *   seconds - Europe/Istanbul was +01:55:52 - and `getTimezoneOffset()`
- *   answers in whole minutes, so the shift lands up to 59 seconds off.
- *   The tz database does not claim correctness before 1970 either.
- *
- * Whatever fails those goes back to the component route, which is what
- * this has always answered. Checked against it over 1850-2040 at
- * 90-minute steps - 1.1 million instants - in ten zones including the
- * 45-minute and 30-minute DST ones: no disagreement, and
- *
- * ```
- *                    before     after
- * Europe/Istanbul    157.5 ns   123.0 ns
- * America/New_York   245.6 ns   131.2 ns
- * ```
- *
- * The DST zone was dearer before because V8 pays for a transition lookup
- * on every local construction; here it pays for one instant instead.
+ * @param ms The instant whose UTC components are the wall clock wanted.
+ * @returns A Date reading that wall clock in the local zone.
  */
+/* Doing this by reading the seven getUTC* components off one Date and
+   handing them to another was the most expensive thing left in the
+   common decode path - the getters alone cost more than either Date:
+
+     new Date(epochMs)               43.6 ns
+     getUTC* x 7                     97.4 ns
+     new Date(y, m, d, h, mi, s, ms) 61.7 ns
+
+   Shifting the instant by the zone's own offset lands on the same wall
+   clock for a fraction of that, but only where the offset is a whole
+   number of minutes and holds either side of where the shift lands. Two
+   guards and a floor make that exact rather than usually-right:
+
+   - The offset must survive the shift. Where it does not, the shift
+     crossed a transition and the wall clock it landed on is not the one
+     that was asked for - or does not exist at all.
+   - The offset must hold for the hour before the landing too. That is
+     the hour a backward transition repeats, where both instants read the
+     same wall clock and the shift keeps the wrong one of the two.
+     Pacific/Chatham found this: 2024-04-07T03:00Z is 03:00 in both
+     +12:45 and +13:45, an hour apart.
+   - Nothing before 1970. A zone's pre-standard offset carries seconds -
+     Europe/Istanbul was +01:55:52 - and getTimezoneOffset() answers in
+     whole minutes, so the shift lands up to 59 seconds off. The tz
+     database does not claim correctness before 1970 either.
+
+   Whatever fails those goes back to the component route, which is what
+   this has always answered. Checked against it over 1850-2040 at
+   90-minute steps - 1.1 million instants - in ten zones including the
+   45-minute and 30-minute DST ones: no disagreement, and
+
+                      before     after
+     Europe/Istanbul    157.5 ns   123.0 ns
+     America/New_York   245.6 ns   131.2 ns
+
+   The DST zone was dearer before because V8 pays for a transition lookup
+   on every local construction; here it pays for one instant instead. */
 export function utcPartsAsLocal(ms) {
     if (ms >= 0) {
         const offset = new Date(ms).getTimezoneOffset();

package/util/parse-array.d.ts

@@ -1,4 +1,12 @@
 import type { Maybe } from '../types.js';
+/**
+ * Reads an array literal - `{1,2,{3,4}}` - into a nested array.
+ *
+ * @param s The literal, as the server wrote it.
+ * @param opts `transform` reads each element's text into a value, and
+ * `separator` is for the types that do not use a comma.
+ * @returns The array, or `undefined` when there was no literal.
+ */
 export declare function parsePostgresArray(s: string, opts?: {
     transform?: (v: string) => any;
     separator?: string;

package/util/parse-array.js

@@ -1,3 +1,11 @@
+/**
+ * Reads an array literal - `{1,2,{3,4}}` - into a nested array.
+ *
+ * @param s The literal, as the server wrote it.
+ * @param opts `transform` reads each element's text into a value, and
+ * `separator` is for the types that do not use a comma.
+ * @returns The array, or `undefined` when there was no literal.
+ */
 export function parsePostgresArray(s, opts) {
     if (!s)
         return;

package/util/parse-bytea.d.ts

@@ -1,2 +1,17 @@
+/**
+ * Reads a `bytea`'s text form into its bytes.
+ *
+ * @param v The value as the server wrote it - `\\x` hex, or the older
+ * escape form.
+ * @returns The bytes.
+ */
 export declare function parseBytea(v: string): Buffer;
+/**
+ * The same, straight from the wire bytes - no string is made.
+ *
+ * @param buf The buffer holding the value.
+ * @param offset Where it starts.
+ * @param len How many bytes it runs for.
+ * @returns The decoded bytes.
+ */
 export declare function parseByteaBuffer(buf: Buffer, offset: number, len: number): Buffer;

package/util/parse-bytea.js

@@ -36,6 +36,13 @@ function parseByteaEscape(input) {
     }
     return Buffer.from(output, 'binary');
 }
+/**
+ * Reads a `bytea`'s text form into its bytes.
+ *
+ * @param v The value as the server wrote it - `\\x` hex, or the older
+ * escape form.
+ * @returns The bytes.
+ */
 export function parseBytea(v) {
     // PostgreSQL's default bytea_output is "hex" (`\x`-prefixed) - check the
     // two marker chars directly rather than a regex test, and hex-decode
@@ -65,6 +72,14 @@ const HEX_NIBBLE = (() => {
 // format via a single 'latin1' string conversion - its own grammar (\ddd
 // octal triplets, ASCII digits, or a literal backslash) is pure ASCII, same
 // as the hex path, so 'latin1' is safe there too.
+/**
+ * The same, straight from the wire bytes - no string is made.
+ *
+ * @param buf The buffer holding the value.
+ * @param offset Where it starts.
+ * @param len How many bytes it runs for.
+ * @returns The decoded bytes.
+ */
 export function parseByteaBuffer(buf, offset, len) {
     if (buf[offset] === 0x5c /* '\' */ && buf[offset + 1] === 0x78 /* 'x' */) {
         // Truncate a trailing odd nibble instead of throwing, matching

package/util/parse-datetime.d.ts

@@ -1,4 +1,30 @@
 import { type PgDateStyle } from './date-style.js';
+/**
+ * Reads a `date` as the server wrote it.
+ *
+ * @param str The value's text.
+ * @param utc Whether to build the Date in UTC rather than locally.
+ * @param dateStyle The session's DateStyle, when it is not ISO - which
+ * is what says whether `01/02/2024` is January or February.
+ * @returns The date, or ±Infinity for the two that are not dates.
+ */
 export declare function parseDate(str: string, utc?: boolean, dateStyle?: PgDateStyle): Date | number;
+/**
+ * Reads a `timestamp` (without time zone) as the server wrote it.
+ *
+ * @param str The value's text.
+ * @param utc Whether to build the Date in UTC rather than locally.
+ * @param dateStyle The session's DateStyle, when it is not ISO.
+ * @returns The timestamp, or ±Infinity.
+ */
 export declare function parseDateTime(str: string, utc?: boolean, dateStyle?: PgDateStyle): Date | number;
+/**
+ * Reads a `timestamptz` as the server wrote it, offset included.
+ *
+ * @param str The value's text.
+ * @param utc Whether to build the Date in UTC rather than locally, for
+ * a value that carries no offset.
+ * @param dateStyle The session's DateStyle, when it is not ISO.
+ * @returns The instant, or ±Infinity.
+ */
 export declare function parseDateTimeTz(str: string, utc?: boolean, dateStyle?: PgDateStyle): Date | number;

package/util/parse-datetime.js

@@ -22,6 +22,15 @@ function fillTimeArgs(m, args) {
         }
     }
 }
+/**
+ * Reads a `date` as the server wrote it.
+ *
+ * @param str The value's text.
+ * @param utc Whether to build the Date in UTC rather than locally.
+ * @param dateStyle The session's DateStyle, when it is not ISO - which
+ * is what says whether `01/02/2024` is January or February.
+ * @returns The date, or ±Infinity for the two that are not dates.
+ */
 export function parseDate(str, utc, dateStyle) {
     if (dateStyle) {
         const styled = parseStyledDateTime(str, dateStyle, utc);
@@ -46,6 +55,14 @@ export function parseDate(str, utc, dateStyle) {
         return new Date(Date.UTC(...args));
     return new Date(...args);
 }
+/**
+ * Reads a `timestamp` (without time zone) as the server wrote it.
+ *
+ * @param str The value's text.
+ * @param utc Whether to build the Date in UTC rather than locally.
+ * @param dateStyle The session's DateStyle, when it is not ISO.
+ * @returns The timestamp, or ±Infinity.
+ */
 export function parseDateTime(str, utc, dateStyle) {
     if (dateStyle) {
         const styled = parseStyledDateTime(str, dateStyle, utc);
@@ -88,6 +105,15 @@ export function parseDateTime(str, utc, dateStyle) {
         return new Date(Date.UTC(...args));
     return new Date(...args);
 }
+/**
+ * Reads a `timestamptz` as the server wrote it, offset included.
+ *
+ * @param str The value's text.
+ * @param utc Whether to build the Date in UTC rather than locally, for
+ * a value that carries no offset.
+ * @param dateStyle The session's DateStyle, when it is not ISO.
+ * @returns The instant, or ±Infinity.
+ */
 export function parseDateTimeTz(str, utc, dateStyle) {
     if (dateStyle) {
         const styled = parseStyledDateTime(str, dateStyle, utc);

package/util/parse-row.d.ts

@@ -1,5 +1,26 @@
 import type { DataMappingOptions } from '../interfaces/data-mapping-options.js';
 import type { FieldInfo } from '../interfaces/field-info.js';
 import type { AnyParseFunction } from '../types.js';
-export declare function parseRow(parsers: AnyParseFunction[], data: Buffer, columnCount: number, options: DataMappingOptions): any[];
-export declare function parseObjectRow(parsers: AnyParseFunction[], data: Buffer, columnCount: number, options: DataMappingOptions, fields: FieldInfo[]): object;
+/**
+ * Reads one row into an array of values.
+ *
+ * @param parsers One per column, already chosen for its format.
+ * @param data The row's own bytes, from the DataRow message.
+ * @param columnCount How many values it holds.
+ * @param options Passed to each parser.
+ * @param start Where the row's values begin in `data`.
+ * @returns The values, in column order.
+ */
+export declare function parseRow(parsers: AnyParseFunction[], data: Buffer, columnCount: number, options: DataMappingOptions, start?: number): any[];
+/**
+ * Reads one row into an object keyed by column name.
+ *
+ * @param parsers One per column, already chosen for its format.
+ * @param data The row's own bytes, from the DataRow message.
+ * @param columnCount How many values it holds.
+ * @param options Passed to each parser.
+ * @param fields The columns, whose names become the keys.
+ * @param start Where the row's values begin in `data`.
+ * @returns The row as an object.
+ */
+export declare function parseObjectRow(parsers: AnyParseFunction[], data: Buffer, columnCount: number, options: DataMappingOptions, fields: FieldInfo[], start?: number): object;