postgrejs 3.6.1 → 3.8.0

package/data-types/pg-lsn-type.js

@@ -0,0 +1,58 @@
+import { DataTypeOIDs } from '../constants.js';
+/**
+ * A `pg_lsn` is a position in the write-ahead log - what
+ * `pg_current_wal_lsn()` and every column of `pg_stat_replication`
+ * answer with, so replication and monitoring tools read these routinely.
+ *
+ * It decodes to the `16/B374D848` string the server prints: the two
+ * 32-bit halves in upper-case hex, separated by a slash and neither of
+ * them padded - `0/0` and `A/B` are what the server writes for those,
+ * not `0/00000000`. That spelling is how an LSN is written everywhere -
+ * in logs, in
+ * `recovery_target_lsn`, in the documentation - and it casts straight
+ * back. A number would lose that and gain nothing, since the value is
+ * compared rather than arithmetic.
+ */
+const LSN_PATTERN = /^([0-9a-fA-F]{1,8})\/([0-9a-fA-F]{1,8})$/;
+export const PgLsnType = {
+    name: 'pg_lsn',
+    oid: DataTypeOIDs.pg_lsn,
+    jsType: 'string',
+    // See inet-type.ts: a string-shaped type stays out of inference.
+    inferrable: false,
+    encodeText(v) {
+        return '' + v;
+    },
+    /** One unsigned 64-bit value, written as its two halves. */
+    encodeBinary(buf, v) {
+        const m = typeof v === 'string' ? LSN_PATTERN.exec(v) : undefined;
+        if (!m)
+            throw new Error(`"${v}" is not a valid pg_lsn value`);
+        buf.writeUInt32BE(parseInt(m[1], 16));
+        buf.writeUInt32BE(parseInt(m[2], 16));
+    },
+    decodeBinary(v, offset = 0) {
+        return (v.readUInt32BE(offset).toString(16).toUpperCase() +
+            '/' +
+            v
+                .readUInt32BE(offset + 4)
+                .toString(16)
+                .toUpperCase());
+    },
+    decodeText(v) {
+        return v;
+    },
+    // Hex and a slash - see inet-type.ts for why 'latin1'.
+    decodeTextBuffer(buf, offset, len) {
+        return buf.toString('latin1', offset, offset + len);
+    },
+    isType(v) {
+        return typeof v === 'string' && LSN_PATTERN.test(v);
+    },
+};
+export const ArrayPgLsnType = {
+    ...PgLsnType,
+    name: '_pg_lsn',
+    oid: DataTypeOIDs._pg_lsn,
+    elementsOID: DataTypeOIDs.pg_lsn,
+};

package/data-types/point-type.js

@@ -1,10 +1,11 @@
 import { DataTypeOIDs } from '../constants.js';
+import { Point } from './classes/geometric.js';
 const POINT_PATTERN1 = /^\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\)$/;
 const POINT_PATTERN2 = /^(-?\d+\.?\d*) *, *(-?\d+\.?\d*)$/;
 export const PointType = {
     name: 'point',
     oid: DataTypeOIDs.point,
-    jsType: 'object',
+    jsType: 'Point',
     encodeText(v) {
         return `(${v.x},${v.y})`;
     },
@@ -13,29 +14,23 @@ export const PointType = {
         buf.writeDoubleBE(v.y);
     },
     decodeBinary(v, offset = 0) {
-        return {
-            x: v.readDoubleBE(offset),
-            y: v.readDoubleBE(offset + 8),
-        };
+        return new Point(v.readDoubleBE(offset), v.readDoubleBE(offset + 8));
     },
     decodeText(v) {
         const m = v.match(POINT_PATTERN1) || v.match(POINT_PATTERN2);
         if (!m)
             return undefined;
-        return {
-            x: parseFloat(m[1]),
-            y: parseFloat(m[2]),
-        };
+        return new Point(parseFloat(m[1]), parseFloat(m[2]));
     },
     // See box-type.ts's decodeTextBuffer comment - same rationale.
     decodeTextBuffer(buf, offset, len, options) {
         return PointType.decodeText(buf.toString('latin1', offset, offset + len), options);
     },
+    // A plain `{x, y}` is still accepted: it is what this type returned
+    // before Point existed, and code that builds one by hand should keep
+    // working.
     isType(v) {
-        return (typeof v === 'object' &&
-            Object.keys(v).length === 2 &&
-            typeof v.x === 'number' &&
-            typeof v.y === 'number');
+        return v instanceof Point || Point.isPointLike(v);
     },
 };
 export const ArrayPointType = {

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

@@ -0,0 +1,23 @@
+import type { DataType } from '../interfaces/data-type.js';
+import type { OID } from '../types.js';
+/**
+ * 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 declare function createRangeType(name: string, oid: OID, element: DataType): DataType;
+/**
+ * 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 declare function createMultiRangeType(name: string, oid: OID, range: DataType): DataType;
+export declare const RangeTypes: DataType[];

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/timestamptz-type.js

@@ -67,6 +67,15 @@ export const TimestamptzType = {
             return d;
         return TimestamptzType.decodeText(buf.toString('latin1', offset, offset + len), options);
     },
+    /**
+     * Unreachable through `determine()`: TimestampType, TimeType and
+     * DateType are all consulted before this one and every Date is claimed
+     * by one of them. Nothing depends on it - a Date parameter goes out
+     * unspecified and the column decides what it means (see
+     * format-datetime.ts's formatDateParam) - so this stays as the
+     * truthful answer to a direct call rather than being narrowed to
+     * describe a walk it never wins.
+     */
     isType(v) {
         return v instanceof Date;
     },

package/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;