postgrejs 3.6.1 → 3.7.0

package/data-types/range-type.js

@@ -0,0 +1,342 @@
+import { DataTypeOIDs } from '../constants.js';
+import { Range } from './classes/range.js';
+import { setTypeOid } from './classes/type-oid.js';
+import { DateType } from './date-type.js';
+import { Int4Type } from './int4-type.js';
+import { Int8Type } from './int8-type.js';
+import { NumericType } from './numeric-type.js';
+import { TimestampType } from './timestamp-type.js';
+import { TimestamptzType } from './timestamptz-type.js';
+// src/include/utils/rangetypes.h
+const RANGE_EMPTY = 0x01;
+const RANGE_LB_INC = 0x02;
+const RANGE_UB_INC = 0x04;
+const RANGE_LB_INF = 0x08;
+const RANGE_UB_INF = 0x10;
+/** `empty`, or two bounds with the brackets that say whether each is included. */
+const RANGE_PATTERN = /^\s*([[(])(.*),(.*)([\])])\s*$/s;
+function boundsOf(r) {
+    return ((r.lowerInclusive && r.lower !== null ? '[' : '(') +
+        (r.upperInclusive && r.upper !== null ? ']' : ')'));
+}
+/**
+ * Reads one bound out of a range literal. An empty string is an absent
+ * bound; a quoted one has its doubled quotes and backslashes put back.
+ */
+function parseBound(s, decode, options) {
+    const t = s.trim();
+    if (t === '')
+        return null;
+    if (t.charAt(0) === '"') {
+        let out = '';
+        let i = 1;
+        while (i < t.length) {
+            const c = t.charAt(i);
+            if (c === '\\') {
+                out += t.charAt(i + 1);
+                i += 2;
+                continue;
+            }
+            if (c === '"') {
+                // A doubled quote is one quote; a single one ends the bound.
+                if (t.charAt(i + 1) === '"') {
+                    out += '"';
+                    i += 2;
+                    continue;
+                }
+                break;
+            }
+            out += c;
+            i++;
+        }
+        return decode(out, options);
+    }
+    return decode(t, options);
+}
+function toRange(v) {
+    if (v instanceof Range)
+        return v;
+    if (Array.isArray(v))
+        return new Range(v[0] ?? null, v[1] ?? null);
+    throw new TypeError(`"${typeof v}" cannot be encoded as a range - pass a Range, or a ` +
+        '[lower, upper] pair');
+}
+/**
+ * Builds the DataType pair for one of PostgreSQL's range types.
+ *
+ * Every range shares one wire format regardless of what it ranges over -
+ * a flags byte, then each bound that exists as a length-prefixed value of
+ * the element type - so the element's own codec does the work and this
+ * only has to say which bounds are there.
+ *
+ * Note what is deliberately not set: `elementsOID`. That marks an *array*
+ * type, and get-parsers.ts routes anything carrying it through
+ * decodeBinaryArray. A range is a scalar whose parts happen to be typed.
+ */
+export function createRangeType(name, oid, element) {
+    return {
+        name,
+        oid,
+        jsType: 'Range',
+        decodeBinary(v, offset = 0, _len, options) {
+            const flags = v[offset];
+            // Stamped with the type it came from, so it can go back as that
+            // type without being named again - which nothing about a Range
+            // could otherwise tell.
+            if (flags & RANGE_EMPTY)
+                return Range.empty(oid);
+            let p = offset + 1;
+            let lower = null;
+            let upper = null;
+            let l;
+            if (!(flags & RANGE_LB_INF)) {
+                l = v.readInt32BE(p);
+                p += 4;
+                lower = element.decodeBinary(v, p, l, options);
+                p += l;
+            }
+            if (!(flags & RANGE_UB_INF)) {
+                l = v.readInt32BE(p);
+                p += 4;
+                upper = element.decodeBinary(v, p, l, options);
+            }
+            return new Range(lower, upper, ((flags & RANGE_LB_INC ? '[' : '(') +
+                (flags & RANGE_UB_INC ? ']' : ')')), oid);
+        },
+        encodeBinary(buf, v, options) {
+            const r = toRange(v);
+            if (r.isEmpty) {
+                buf.writeUInt8(RANGE_EMPTY);
+                return;
+            }
+            let flags = 0;
+            if (r.lower === null)
+                flags |= RANGE_LB_INF;
+            else if (r.lowerInclusive)
+                flags |= RANGE_LB_INC;
+            if (r.upper === null)
+                flags |= RANGE_UB_INF;
+            else if (r.upperInclusive)
+                flags |= RANGE_UB_INC;
+            buf.writeUInt8(flags);
+            let pos;
+            if (r.lower !== null) {
+                buf.writeInt32BE(0); // reserved for the bound's length
+                pos = buf.position;
+                element.encodeBinary(buf, r.lower, options);
+                buf.buffer.writeInt32BE(buf.size - pos, pos - 4);
+            }
+            if (r.upper !== null) {
+                buf.writeInt32BE(0);
+                pos = buf.position;
+                element.encodeBinary(buf, r.upper, options);
+                buf.buffer.writeInt32BE(buf.size - pos, pos - 4);
+            }
+        },
+        decodeText(v, options) {
+            if (v.trim() === 'empty')
+                return Range.empty(oid);
+            const m = RANGE_PATTERN.exec(v);
+            if (!m)
+                throw new Error(`"${v}" is not a ${name} literal`);
+            return new Range(parseBound(m[2], element.decodeText, options), parseBound(m[3], element.decodeText, options), (m[1] + m[4]), oid);
+        },
+        encodeText(v, options) {
+            const r = toRange(v);
+            if (r.isEmpty)
+                return 'empty';
+            // Rendered through the element's own encodeText rather than
+            // Range.toString(), which has no element type to ask and falls back
+            // on String() - the difference shows on a Date bound.
+            const render = (x) => x === null
+                ? ''
+                : quote(element.encodeText ? element.encodeText(x, options) : String(x));
+            const bounds = boundsOf(r);
+            return (bounds.charAt(0) +
+                render(r.lower) +
+                ',' +
+                render(r.upper) +
+                bounds.charAt(1));
+        },
+        isType(v) {
+            return v instanceof Range;
+        },
+        // Every one of the six range types answers `instanceof Range` for the
+        // same value, and nothing about a Range says which it is - bounds of
+        // numbers fit int4range, int8range and numrange alike, Dates fit
+        // daterange, tsrange and tstzrange. So determine() would pick
+        // whichever was registered first and send an int4range as a
+        // tstzrange, which is what it did before this line: `new Range(1, 10)`
+        // arrived as `[1970-01-01T00:00:00.001Z,...)`. Ask for the one you
+        // mean with `new BindParam(DataTypeOIDs.int4range, value)`.
+        inferrable: false,
+    };
+}
+function quote(s) {
+    if (s === '' || /["\\()[\],]|\s/.test(s))
+        return '"' + s.replace(/\\/g, '\\\\').replace(/"/g, '""') + '"';
+    return s;
+}
+/**
+ * The multirange counterpart: a count, then each range length-prefixed,
+ * and in text a brace-wrapped comma-separated list. The ranges themselves
+ * are the same format, so this delegates to the range type rather than
+ * repeating it.
+ */
+export function createMultiRangeType(name, oid, range) {
+    return {
+        name,
+        oid,
+        jsType: 'Range[]',
+        decodeBinary(v, offset = 0, _len, options) {
+            const count = v.readInt32BE(offset);
+            let p = offset + 4;
+            const out = new Array(count);
+            let l;
+            let i;
+            for (i = 0; i < count; i++) {
+                l = v.readInt32BE(p);
+                p += 4;
+                out[i] = range.decodeBinary(v, p, l, options);
+                p += l;
+            }
+            // The array carries the multirange's own OID; its elements already
+            // carry the range type's.
+            return setTypeOid(out, oid);
+        },
+        encodeBinary(buf, v, options) {
+            const items = Array.isArray(v) ? v : [v];
+            buf.writeInt32BE(items.length);
+            let pos;
+            let i;
+            for (i = 0; i < items.length; i++) {
+                buf.writeInt32BE(0); // reserved for this range's length
+                pos = buf.position;
+                range.encodeBinary(buf, items[i], options);
+                buf.buffer.writeInt32BE(buf.size - pos, pos - 4);
+            }
+        },
+        decodeText(v, options) {
+            const s = v.trim();
+            if (!s.startsWith('{') || !s.endsWith('}'))
+                throw new Error(`"${v}" is not a ${name} literal`);
+            const body = s.substring(1, s.length - 1).trim();
+            if (!body)
+                return setTypeOid([], oid);
+            // Ranges are split on the comma that follows a closing bracket, so
+            // the comma between a range's own two bounds is left alone.
+            const out = [];
+            let depth = 0;
+            let start = 0;
+            let quoted = false;
+            let i;
+            let c;
+            for (i = 0; i < body.length; i++) {
+                c = body.charAt(i);
+                if (quoted) {
+                    if (c === '\\')
+                        i++;
+                    else if (c === '"')
+                        quoted = false;
+                    continue;
+                }
+                if (c === '"')
+                    quoted = true;
+                else if (c === '[' || c === '(')
+                    depth++;
+                else if (c === ']' || c === ')')
+                    depth--;
+                else if (c === ',' && depth === 0) {
+                    out.push(range.decodeText(body.substring(start, i), options));
+                    start = i + 1;
+                }
+            }
+            out.push(range.decodeText(body.substring(start), options));
+            return setTypeOid(out, oid);
+        },
+        encodeText(v, options) {
+            const items = Array.isArray(v) ? v : [v];
+            return ('{' + items.map(x => range.encodeText(x, options)).join(',') + '}');
+        },
+        isType(v) {
+            return (Array.isArray(v) && v.length > 0 && v.every(x => x instanceof Range));
+        },
+        // An array of Ranges is also what a `Range[]` column decodes to, so
+        // leaving this to inference would make the two indistinguishable for
+        // an untyped parameter. Ask for it with BindParam when you mean it.
+        inferrable: false,
+    };
+}
+/**
+ * The six range types PostgreSQL ships, their multirange counterparts and
+ * the array form of each - twelve scalar types over one format, which is
+ * why they are built here rather than written out one file at a time.
+ */
+const BUILT_IN = [
+    [
+        'int4range',
+        DataTypeOIDs.int4range,
+        DataTypeOIDs._int4range,
+        DataTypeOIDs.int4multirange,
+        DataTypeOIDs._int4multirange,
+        DataTypeOIDs.int4,
+        Int4Type,
+    ],
+    [
+        'int8range',
+        DataTypeOIDs.int8range,
+        DataTypeOIDs._int8range,
+        DataTypeOIDs.int8multirange,
+        DataTypeOIDs._int8multirange,
+        DataTypeOIDs.int8,
+        Int8Type,
+    ],
+    [
+        'numrange',
+        DataTypeOIDs.numrange,
+        DataTypeOIDs._numrange,
+        DataTypeOIDs.nummultirange,
+        DataTypeOIDs._nummultirange,
+        DataTypeOIDs.numeric,
+        NumericType,
+    ],
+    [
+        'daterange',
+        DataTypeOIDs.daterange,
+        DataTypeOIDs._daterange,
+        DataTypeOIDs.datemultirange,
+        DataTypeOIDs._datemultirange,
+        DataTypeOIDs.date,
+        DateType,
+    ],
+    [
+        'tsrange',
+        DataTypeOIDs.tsrange,
+        DataTypeOIDs._tsrange,
+        DataTypeOIDs.tsmultirange,
+        DataTypeOIDs._tsmultirange,
+        DataTypeOIDs.timestamp,
+        TimestampType,
+    ],
+    [
+        'tstzrange',
+        DataTypeOIDs.tstzrange,
+        DataTypeOIDs._tstzrange,
+        DataTypeOIDs.tstzmultirange,
+        DataTypeOIDs._tstzmultirange,
+        DataTypeOIDs.timestamptz,
+        TimestamptzType,
+    ],
+];
+export const RangeTypes = [];
+for (const [name, oid, arrayOid, multiOid, multiArrayOid, , element,] of BUILT_IN) {
+    const rangeType = createRangeType(name, oid, element);
+    const multiName = name.replace('range', 'multirange');
+    const multiType = createMultiRangeType(multiName, multiOid, rangeType);
+    RangeTypes.push(rangeType, { ...rangeType, name: '_' + name, oid: arrayOid, elementsOID: oid }, multiType, {
+        ...multiType,
+        name: '_' + multiName,
+        oid: multiArrayOid,
+        elementsOID: multiOid,
+    });
+}

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

@@ -0,0 +1,5 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const PgSnapshotType: DataType;
+export declare const ArrayPgSnapshotType: DataType;
+export declare const TxidSnapshotType: DataType;
+export declare const ArrayTxidSnapshotType: DataType;

package/data-types/snapshot-type.js

@@ -0,0 +1,96 @@
+import { DataTypeOIDs } from '../constants.js';
+/**
+ * `pg_snapshot` and its older name `txid_snapshot` - what
+ * `pg_current_snapshot()` answers with, and what tells you which
+ * transactions were in flight at a moment.
+ *
+ * Both decode to the `xmin:xmax:xip,xip` string the server prints. The
+ * parts are transaction ids, and there is nothing to do with them but
+ * compare them against another snapshot - which the server's own
+ * operators do far better than JavaScript could, since these are the
+ * 64-bit counters `xid8` carries. The string is the whole value and
+ * casts straight back.
+ */
+const BIG32 = BigInt(32);
+const MASK32 = BigInt(0xffffffff);
+/** The largest high half a JavaScript number still holds exactly. */
+const MAX_SAFE_HIGH = 0x1fffff;
+const SNAPSHOT_PATTERN = /^(\d+):(\d+):(\d+(?:,\d+)*)?$/;
+/** A 64-bit transaction id as its decimal text, whatever its magnitude. */
+function readXid(v, offset) {
+    const hi = v.readUInt32BE(offset);
+    const lo = v.readUInt32BE(offset + 4);
+    if (hi <= MAX_SAFE_HIGH)
+        return '' + (hi * 4294967296 + lo);
+    return ((BigInt(hi) << BIG32) | BigInt(lo)).toString();
+}
+function writeXid(buf, s) {
+    const n = BigInt(s);
+    buf.writeUInt32BE(Number(n >> BIG32));
+    buf.writeUInt32BE(Number(n & MASK32));
+}
+function createType(name, oid) {
+    return {
+        name,
+        oid,
+        jsType: 'string',
+        // See inet-type.ts: a string-shaped type stays out of inference.
+        inferrable: false,
+        encodeText(v) {
+            return '' + v;
+        },
+        /**
+         * An int32 count of in-flight transactions, then xmin and xmax, then
+         * that many ids - each of them 64 bits.
+         */
+        encodeBinary(buf, v) {
+            const m = typeof v === 'string' ? SNAPSHOT_PATTERN.exec(v) : undefined;
+            if (!m)
+                throw new Error(`"${v}" is not a valid ${name} value`);
+            const xip = m[3] ? m[3].split(',') : [];
+            buf.writeInt32BE(xip.length);
+            writeXid(buf, m[1]);
+            writeXid(buf, m[2]);
+            let i;
+            const l = xip.length;
+            for (i = 0; i < l; i++)
+                writeXid(buf, xip[i]);
+        },
+        decodeBinary(v, offset = 0) {
+            const count = v.readInt32BE(offset);
+            let out = readXid(v, offset + 4) + ':' + readXid(v, offset + 12) + ':';
+            let i;
+            let p = offset + 20;
+            for (i = 0; i < count; i++, p += 8) {
+                if (i)
+                    out += ',';
+                out += readXid(v, p);
+            }
+            return out;
+        },
+        decodeText(v) {
+            return v;
+        },
+        // Digits, colons and commas - see inet-type.ts for why 'latin1'.
+        decodeTextBuffer(buf, offset, len) {
+            return buf.toString('latin1', offset, offset + len);
+        },
+        isType(v) {
+            return typeof v === 'string' && SNAPSHOT_PATTERN.test(v);
+        },
+    };
+}
+export const PgSnapshotType = createType('pg_snapshot', DataTypeOIDs.pg_snapshot);
+export const ArrayPgSnapshotType = {
+    ...PgSnapshotType,
+    name: '_pg_snapshot',
+    oid: DataTypeOIDs._pg_snapshot,
+    elementsOID: DataTypeOIDs.pg_snapshot,
+};
+export const TxidSnapshotType = createType('txid_snapshot', DataTypeOIDs.txid_snapshot);
+export const ArrayTxidSnapshotType = {
+    ...TxidSnapshotType,
+    name: '_txid_snapshot',
+    oid: DataTypeOIDs._txid_snapshot,
+    elementsOID: DataTypeOIDs.txid_snapshot,
+};

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

@@ -0,0 +1,3 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const TidType: DataType;
+export declare const ArrayTidType: DataType;

package/data-types/tid-type.js

@@ -0,0 +1,50 @@
+import { DataTypeOIDs } from '../constants.js';
+/**
+ * A `tid` is where a row physically sits - the `ctid` system column,
+ * which applications select to identify a row without a key, to
+ * deduplicate, or to update exactly one of a set of identical rows.
+ *
+ * It decodes to the `(block,offset)` string the server prints. The two
+ * numbers are a physical address that VACUUM is free to change, so there
+ * is nothing to compute with them; what a caller does with a ctid is
+ * compare it or hand it straight back, and the string does both. `pg`
+ * leaves it a string too.
+ */
+const TID_PATTERN = /^\(\s*(\d+)\s*,\s*(\d+)\s*\)$/;
+export const TidType = {
+    name: 'tid',
+    oid: DataTypeOIDs.tid,
+    jsType: 'string',
+    // `(0,1)` is an ordinary-looking string - see inet-type.ts.
+    inferrable: false,
+    encodeText(v) {
+        return '' + v;
+    },
+    /** A uint32 block number and a uint16 offset within it. */
+    encodeBinary(buf, v) {
+        const m = typeof v === 'string' ? TID_PATTERN.exec(v) : undefined;
+        if (!m)
+            throw new Error(`"${v}" is not a valid tid value`);
+        buf.writeUInt32BE(+m[1]);
+        buf.writeUInt16BE(+m[2]);
+    },
+    decodeBinary(v, offset = 0) {
+        return ('(' + v.readUInt32BE(offset) + ',' + v.readUInt16BE(offset + 4) + ')');
+    },
+    decodeText(v) {
+        return v;
+    },
+    // Digits, a comma and two parentheses - see inet-type.ts for 'latin1'.
+    decodeTextBuffer(buf, offset, len) {
+        return buf.toString('latin1', offset, offset + len);
+    },
+    isType(v) {
+        return typeof v === 'string' && TID_PATTERN.test(v);
+    },
+};
+export const ArrayTidType = {
+    ...TidType,
+    name: '_tid',
+    oid: DataTypeOIDs._tid,
+    elementsOID: DataTypeOIDs.tid,
+};

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

@@ -0,0 +1,3 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const TimeTzType: DataType;
+export declare const ArrayTimeTzType: DataType;

package/data-types/timetz-type.js

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