postgrejs 3.5.0 → 3.6.1

package/connection/pool.js

@@ -2,6 +2,7 @@ import { Pool as LightningPool, } from 'lightning-pool';
 import { coerceToBoolean, coerceToInt } from 'putil-varhelpers';
 import { ConnectionState } from '../constants.js';
 import { SafeEventEmitter } from '../safe-event-emitter.js';
+import { normalizeChannelName } from '../util/channel-name.js';
 import { getConnectionConfig } from '../util/connection-config.js';
 import { QueryRequest } from '../util/sql-tag.js';
 import { startsCopy, startsTransaction } from '../util/starts-transaction.js';
@@ -12,6 +13,14 @@ export class Pool extends SafeEventEmitter {
     _notificationListeners = new SafeEventEmitter();
     _notificationConnection;
     _pipelineSlots = [];
+    /**
+     * Why a connection is about to be destroyed, for the ones that were not
+     * destroyed on purpose. lightning-pool's own 'destroy' carries the
+     * resource and nothing else, so the reason is recorded on the way in -
+     * when the connection reports its close - and read back out when the
+     * pool reports the removal.
+     */
+    _destroyReasons = new WeakMap();
     _pipelineMaxQueries;
     _pipelineMaxConnections;
     config;
@@ -45,7 +54,7 @@ export class Pool extends SafeEventEmitter {
                 /* c8 ignore stop */
                 const intlCon = new IntlConnection(cfg);
                 await intlCon.connect();
-                intlCon.on('close', () => this._pool.destroy(intlCon));
+                intlCon.on('close', (reason) => this._onConnectionClosed(intlCon, reason));
                 /* c8 ignore start */
                 if (this.listenerCount('debug')) {
                     this.emit('debug', {
@@ -81,7 +90,7 @@ export class Pool extends SafeEventEmitter {
                 /* c8 ignore stop */
                 intlCon.owner = undefined;
                 intlCon.removeAllListeners();
-                intlCon.once('close', () => this._pool.destroy(intlCon));
+                intlCon.once('close', (reason) => this._onConnectionClosed(intlCon, reason));
                 intlCon._refCount = 0;
             },
             validate: async (intlCon) => {
@@ -103,7 +112,7 @@ export class Pool extends SafeEventEmitter {
         this._pool.on('return', (...args) => this.emit('release', ...args));
         this._pool.on('error', (...args) => this.emit('error', ...args));
         this._pool.on('acquire', (...args) => this.emit('acquire', ...args));
-        this._pool.on('destroy', (...args) => this.emit('destroy', ...args));
+        this._pool.on('destroy', (intlCon) => this._onConnectionDestroyed(intlCon));
     }
     /**
      * Returns the number of connections that are currently acquired
@@ -205,12 +214,32 @@ export class Pool extends SafeEventEmitter {
             : undefined;
         if (!slot) {
             const connection = await this.acquire();
+            let result;
             try {
-                return await connection.query(sql, options);
+                result = await connection.query(sql, options);
             }
-            finally {
+            catch (e) {
                 await this.release(connection);
+                throw e;
+            }
+            // A portal lives only as long as the transaction it was created in,
+            // and outside an explicit one that is the implicit transaction any
+            // other statement's Sync ends. So a connection carrying an open
+            // cursor cannot go back in the pool when this call returns - handing
+            // it to the next caller would destroy the cursor's portal, and did
+            // ("portal ... does not exist", nondeterministically, depending on
+            // which connection that caller happened to get). It goes back when
+            // the cursor closes instead, which for-await and `await using` both
+            // do on their own; a cursor that is never closed holds its
+            // connection until the pool itself is closed.
+            if (result.cursor) {
+                result.cursor.once('close', () => {
+                    this.release(connection).catch(e => this.emit('error', e));
+                });
+                return result;
             }
+            await this.release(connection);
+            return result;
         }
         try {
             const shared = slot.connection || (await slot.promise);
@@ -256,8 +285,10 @@ export class Pool extends SafeEventEmitter {
         return this._pool.releaseAsync(getIntlConnection(connection));
     }
     async listen(channel, callback) {
-        if (!/^[A-Z]\w+$/i.test(channel))
-            throw new TypeError(`Invalid channel name`);
+        // Folded here as well as in Connection.listen(): this emitter's keys
+        // have to be the same strings the inner connection registers, or
+        // unListen() would miss them.
+        channel = normalizeChannelName(channel);
         // Bug: _initNotificationConnection() only ever bootstraps the shared
         // connection and registers every channel known at that moment - it
         // returns immediately once that connection already exists, so a second,
@@ -274,8 +305,7 @@ export class Pool extends SafeEventEmitter {
         }
     }
     async unListen(channel) {
-        if (!/^[A-Z]\w+$/i.test(channel))
-            throw new TypeError(`Invalid channel name`);
+        channel = normalizeChannelName(channel);
         this._notificationListeners.removeAllListeners(channel);
         if (!this._notificationListeners.eventNames().length) {
             await this.unListenAll();
@@ -291,6 +321,40 @@ export class Pool extends SafeEventEmitter {
             await conn.close();
         }
     }
+    /**
+     * A pooled connection reported that its socket closed. `reason` is set
+     * only when that was not asked for - see PgSocket._handleClose().
+     */
+    _onConnectionClosed(intlCon, reason) {
+        if (reason)
+            this._destroyReasons.set(intlCon, reason);
+        this._pool.destroy(intlCon);
+    }
+    /**
+     * The pool has removed a connection. `destroy` fires the same way for an
+     * ordinary eviction (idle timeout, close(), a failed validate) as for a
+     * connection that died, so the reason is what tells them apart - an
+     * admin kill, a failover and a network fault were otherwise
+     * indistinguishable from a timeout, with nothing at all reported when
+     * the connection had no query in flight to reject.
+     */
+    _onConnectionDestroyed(intlCon) {
+        const reason = this._destroyReasons.get(intlCon);
+        if (reason)
+            this._destroyReasons.delete(intlCon);
+        this.emit('destroy', intlCon, reason);
+        if (!reason)
+            return;
+        // Reported on 'error' as well, which is where pg puts a pooled
+        // connection dying and where code ported from it listens. Safe to do
+        // unconditionally here: SafeEventEmitter drops an 'error' that has no
+        // listener instead of throwing, so this cannot turn a recovery the
+        // pool already made into a crashed process. The error names the pid
+        // and carries the socket error as its cause; no second argument, so
+        // the existing `(err, meta)` shape lightning-pool emits for a
+        // connection that could not be created stays unambiguous.
+        this.emit('error', reason);
+    }
     _canPipeline(pipeline, sql, autoCommit, signal) {
         return (pipeline === true &&
             !signal &&

package/connection/portal.d.ts

@@ -23,7 +23,7 @@ export declare class Portal {
      * no explicit BEGIN left transactionStatus 'I' and a later Execute on the
      * same named portal failed with "portal ... does not exist").
      */
-    bindAndRetrieveFields(params: Maybe<any[]>, queryOptions: QueryOptions): Promise<Protocol.RowDescription[]>;
+    bindAndRetrieveFields(params: Maybe<any[]>, queryOptions: QueryOptions, columnFormat?: Protocol.DataFormat | Protocol.DataFormat[]): Promise<Protocol.RowDescription[]>;
     execute(fetchCount?: number): Promise<PortalExecuteResult>;
     /**
      * Close + Sync as one request (see PgSocket.sendCloseAndSyncMessages()

package/connection/portal.js

@@ -22,7 +22,7 @@ export class Portal {
      * no explicit BEGIN left transactionStatus 'I' and a later Execute on the
      * same named portal failed with "portal ... does not exist").
      */
-    async bindAndRetrieveFields(params, queryOptions) {
+    async bindAndRetrieveFields(params, queryOptions, columnFormat) {
         const intoCon = getIntlConnection(this.connection);
         intoCon.ref();
         try {
@@ -35,6 +35,7 @@ export class Portal {
                     paramTypes: this._statement.paramTypes,
                     params,
                     queryOptions,
+                    columnFormat,
                 },
                 describe: { type: 'P', name: this.name },
             }, (code, msg, done) => {
@@ -68,7 +69,7 @@ export class Portal {
             const rows = [];
             const executePromise = socket.sendExecuteMessage({
                 portal: this.name,
-                fetchCount: fetchCount || 100,
+                fetchCount: fetchCount ?? 100,
             }, (code, msg, done) => {
                 switch (code) {
                     case Protocol.BackendMessageCode.NoticeResponse:

package/connection/prepared-statement.js

@@ -1,9 +1,9 @@
-import { DEFAULT_COLUMN_FORMAT } from '../constants.js';
 import { GlobalTypeMap } from '../data-type-map.js';
 import { Protocol } from '../protocol/protocol.js';
 import { SafeEventEmitter } from '../safe-event-emitter.js';
 import { withAbortSignal } from '../util/abort-signal.js';
 import { getParsers } from '../util/get-parsers.js';
+import { resolveColumnFormats } from '../util/resolve-column-formats.js';
 import { resolveRowType } from '../util/row-decoder.js';
 import { wrapRowDescription } from '../util/wrap-row-description.js';
 import { Cursor } from './cursor.js';
@@ -208,10 +208,14 @@ export class PreparedStatement extends SafeEventEmitter {
             intlCon.ref();
             let portal = new Portal(this, 'P_' + ++portalCounter);
             try {
-                const fields = await portal.bindAndRetrieveFields(options.params, options);
+                // prepare() already fetched this statement's RowDescription, so
+                // fetchAsString's OID list can become per-column result format
+                // codes on the Bind below with no round trip of its own.
+                const columnFormat = resolveColumnFormats(this._fields, options);
+                const fields = await portal.bindAndRetrieveFields(options.params, options, columnFormat);
                 const typeMap = options.typeMap || GlobalTypeMap;
-                const parsers = getParsers(typeMap, fields);
-                const resultFields = wrapRowDescription(typeMap, fields, options.columnFormat || DEFAULT_COLUMN_FORMAT);
+                const parsers = getParsers(typeMap, fields, options);
+                const resultFields = wrapRowDescription(typeMap, fields, columnFormat, options);
                 const result = {
                     command: undefined,
                     fields: resultFields,

package/data-type-map.d.ts

@@ -3,6 +3,17 @@ import type { OID } from './types.js';
 export declare class DataTypeMap {
     private _itemsByOID;
     private _items;
+    /**
+     * Copies another map, so a connection can start from GlobalTypeMap and
+     * override a type or two without touching the global one.
+     *
+     * Both indexes have to be copied. `_items` alone is what `determine()`
+     * walks, but every decode goes through `get()`, which reads
+     * `_itemsByOID` - a copy carrying only the first one answers `undefined`
+     * for every OID, and get-parsers.ts then falls back to its default
+     * parser, handing the caller raw Buffers instead of decoded values with
+     * nothing reported.
+     */
     constructor(other?: DataTypeMap);
     get(oid: OID): DataType;
     register(dataTypes: DataType | DataType[]): void;

package/data-type-map.js

@@ -26,9 +26,22 @@ import { ArrayVarcharType, VarcharType } from './data-types/varchar-type.js';
 export class DataTypeMap {
     _itemsByOID = {};
     _items = [];
+    /**
+     * Copies another map, so a connection can start from GlobalTypeMap and
+     * override a type or two without touching the global one.
+     *
+     * Both indexes have to be copied. `_items` alone is what `determine()`
+     * walks, but every decode goes through `get()`, which reads
+     * `_itemsByOID` - a copy carrying only the first one answers `undefined`
+     * for every OID, and get-parsers.ts then falls back to its default
+     * parser, handing the caller raw Buffers instead of decoded values with
+     * nothing reported.
+     */
     constructor(other) {
-        if (other instanceof DataTypeMap)
-            Object.assign(this._items, other._items);
+        if (other instanceof DataTypeMap) {
+            this._items = [...other._items];
+            this._itemsByOID = { ...other._itemsByOID };
+        }
     }
     get(oid) {
         return this._itemsByOID[oid];
@@ -52,6 +65,11 @@ export class DataTypeMap {
         let t;
         for (i = this._items.length - 1; i >= 0; i--) {
             t = this._items[i];
+            // Walked newest-registered first, so a later registration of the
+            // same OID wins - and a type marked `inferrable: false` is never
+            // picked here at all, however well `isType` matches.
+            if (t.inferrable === false)
+                continue;
             if (valueIsArray) {
                 if (t.elementsOID && t.isType(value[0]))
                     return t.oid;

package/data-types/char-type.js

@@ -21,6 +21,21 @@ export const CharType = {
     isType(v) {
         return typeof v === 'string' && Buffer.byteLength(v, 'utf8') === 1;
     },
+    /**
+     * 18 is PostgreSQL's internal single-byte `"char"`, not `char(n)` and
+     * not `varchar`. A one-character JavaScript string fits it, which is why
+     * `isType` says so, but nobody passing `'A'` to a query means that type:
+     * inference used to answer 18 for every such value and declare the
+     * parameter `"char"` to the server.
+     *
+     * Comparisons and inserts survived on an implicit cast, but concatenation
+     * had no single obvious one - `select code || $1` answered `operator is
+     * not unique: character varying || "char"` - and an array was worse
+     * still. determine() types an array from its first element alone, so
+     * `['A', 'BB', 'CCC']` became `_char` and came back `['A', 'B', 'C']`,
+     * every later element cut to one byte with nothing reported.
+     */
+    inferrable: false,
 };
 export const ArrayCharType = {
     ...CharType,

package/data-types/date-type.js

@@ -30,22 +30,18 @@ export const DateType = {
         buf.writeInt32BE(t);
     },
     decodeBinary(v, offset = 0, _len, options) {
-        const fetchAsString = options.fetchAsString?.includes(DataTypeOIDs.date);
         const t = v.readInt32BE(offset);
         if (t === 0x7fffffff)
-            return fetchAsString ? 'infinity' : Infinity;
+            return Infinity;
         if (t === -0x80000000)
-            return fetchAsString ? '-infinity' : -Infinity;
+            return -Infinity;
         // Shift from 2000 to 1970
         let d = new Date(t * 1000 * 86400 + timeShift);
-        if (fetchAsString || !options.utcDates)
+        if (!options.utcDates)
             d = new Date(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate());
-        return fetchAsString ? dateToDateString(d) : d;
+        return d;
     },
     decodeText(v, options) {
-        const fetchAsString = options.fetchAsString?.includes(DataTypeOIDs.date);
-        if (fetchAsString)
-            return v;
         return parseDate(v, options.utcDates);
     },
     decodeTextBuffer(buf, offset, len, options) {
@@ -59,16 +55,6 @@ export const DateType = {
             v.getMilliseconds() === 0);
     },
 };
-function padZero(v) {
-    return v < 9 ? '0' + v : '' + v;
-}
-function dateToDateString(d) {
-    return (d.getFullYear() +
-        '-' +
-        padZero(d.getMonth() + 1) +
-        '-' +
-        padZero(d.getDate()));
-}
 export const ArrayDateType = {
     ...DateType,
     name: '_date',

package/data-types/float4-type.js

@@ -12,7 +12,7 @@ export const Float4Type = {
         buf.writeFloatBE(typeof v === 'number' ? v : assertCoercedNumber(parseFloat(v), 'float4'));
     },
     decodeBinary(v, offset = 0) {
-        return v.readFloatBE(offset);
+        return shortestFloat4(v.readFloatBE(offset));
     },
     decodeText: parseFloat,
     decodeTextBuffer: fastParseFloatBuffer,
@@ -26,3 +26,81 @@ export const ArrayFloat4Type = {
     oid: DataTypeOIDs._float4,
     elementsOID: DataTypeOIDs.float4,
 };
+/**
+ * Powers of ten that a double holds exactly. Past 1e22 the literal is
+ * already rounded, and scaling by it stops being a faithful operation.
+ */
+const POW10 = [
+    1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14,
+    1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22,
+];
+/**
+ * The shortest decimal that reads back as this same float4.
+ *
+ * A float4 arrives as four bytes and widens into a double that spells out
+ * the binary approximation in full: the column PostgreSQL prints as `1.1`
+ * read back as `1.100000023841858`. The text path never had the problem,
+ * since the server does this itself before sending - so the same column
+ * answered differently depending on a wire format the caller may not know
+ * is there, and the binary default was the wrong-looking one.
+ *
+ * Nine significant digits always round-trip a binary32 and most values
+ * need far fewer, so this tries successively longer forms and takes the
+ * first that reads back unchanged. Integers inside +-2^24 are already
+ * exact in float4 and skip the search; past that they are not (1e20
+ * widens to 100000002004087730000) so the bound matters. Infinities and
+ * NaN have no decimal to shorten.
+ *
+ * Rounding by hand, rather than through toPrecision(), is what makes it
+ * affordable - 24ns a value against 115ns, measured, because toPrecision()
+ * costs four times what the engine's own shortest-form toString does and
+ * there is no cheaper built-in. Scaling by a power of ten is only faithful
+ * while both the digits and the power are exact in a double: the digits
+ * always are at nine or fewer, and the magnitude check keeps the power
+ * inside its own exact range. A value sitting exactly halfway is left to
+ * the string path as well - Math.round() breaks those ties away from zero
+ * and dtoa breaks them to even, and the disagreement would show. Checked
+ * against the string path over 299,007 values, structured and random:
+ * same answer every time.
+ */
+function shortestFloat4(n) {
+    if (!Number.isFinite(n))
+        return n;
+    if (Number.isInteger(n) && n >= -16777216 && n <= 16777216)
+        return n;
+    const abs = n < 0 ? -n : n;
+    // Two comparisons keep log10 and the loop off the path entirely for
+    // magnitudes whose power of ten could not be exact anyway.
+    if (abs >= 1e-14 && abs < 1e28) {
+        const e = Math.floor(Math.log10(abs));
+        let digits;
+        let k;
+        let pow;
+        let scaled;
+        let rounded;
+        let candidate;
+        for (digits = 7; digits <= 9; digits++) {
+            k = digits - 1 - e;
+            // Unreachable for the magnitudes let through above unless log10()
+            // lands a step out at a boundary, which it is entitled to do.
+            if (k < -22 || k > 22)
+                break;
+            pow = POW10[k < 0 ? -k : k];
+            scaled = k >= 0 ? n * pow : n / pow;
+            rounded = Math.round(scaled);
+            if (scaled - rounded === 0.5 || rounded - scaled === 0.5)
+                break;
+            candidate = k >= 0 ? rounded / pow : rounded * pow;
+            if (Math.fround(candidate) === n)
+                return candidate;
+        }
+    }
+    let p;
+    let s;
+    for (p = 7; p <= 9; p++) {
+        s = Number(n.toPrecision(p));
+        if (Math.fround(s) === n)
+            return s;
+    }
+    return n;
+}

package/data-types/json-type.js

@@ -3,11 +3,8 @@ export const JsonType = {
     name: 'json',
     oid: DataTypeOIDs.json,
     jsType: 'string',
-    decodeBinary(v, offset = 0, len, options) {
+    decodeBinary(v, offset = 0, len) {
         const content = v.toString('utf8', offset, offset + len);
-        const fetchAsString = options.fetchAsString?.includes(DataTypeOIDs.json);
-        if (fetchAsString)
-            return content;
         return content ? JSON.parse(content) : undefined;
     },
     // json is stored as the text itself, so its binary form is those bytes.
@@ -25,19 +22,17 @@ export const JsonType = {
             return v ? 'true' : 'false';
         return '' + v;
     },
-    decodeText(v, options) {
-        const fetchAsString = options.fetchAsString?.includes(DataTypeOIDs.json);
-        if (fetchAsString)
-            return v;
-        return v ? JSON.parse(v) : null;
-    },
-    decodeTextBuffer(buf, offset, len, options) {
-        return JsonType.decodeText(buf.toString('utf8', offset, offset + len), options);
+    decodeText: decodeJsonText,
+    decodeTextBuffer(buf, offset, len) {
+        return decodeJsonText(buf.toString('utf8', offset, offset + len));
     },
     isType(v) {
         return v && typeof v === 'object';
     },
 };
+function decodeJsonText(v) {
+    return v ? JSON.parse(v) : null;
+}
 export const ArrayJsonType = {
     ...JsonType,
     name: '_json',

package/data-types/jsonb-type.js

@@ -14,32 +14,27 @@ export const JsonbType = {
         buf.writeUInt8(1);
         buf.writeString(JsonbType.encodeText(v, {}), 'utf8');
     },
-    decodeBinary(v, offset = 0, len, options) {
+    decodeBinary(v, offset = 0, len) {
         // jsonb's binary form is a one-byte version followed by the JSON text,
         // which carries no terminator of its own - so its end is whatever
         // `len` says, not the end of the buffer it happens to sit in.
         if (v[offset] !== 1)
             throw new Error('Unexpected Jsonb version value in header');
         const content = v.toString('utf8', offset + 1, offset + len);
-        const fetchAsString = options.fetchAsString?.includes(DataTypeOIDs.jsonb);
-        if (fetchAsString)
-            return content;
         return content ? JSON.parse(content) : undefined;
     },
-    decodeText(v, options) {
-        const fetchAsString = options.fetchAsString?.includes(DataTypeOIDs.jsonb);
-        if (fetchAsString)
-            return v;
-        return v ? JSON.parse(v) : null;
-    },
+    decodeText: decodeJsonbText,
     // See json-type.ts's decodeTextBuffer comment - same rationale.
-    decodeTextBuffer(buf, offset, len, options) {
-        return JsonbType.decodeText(buf.toString('utf8', offset, offset + len), options);
+    decodeTextBuffer(buf, offset, len) {
+        return decodeJsonbText(buf.toString('utf8', offset, offset + len));
     },
     isType(v) {
         return v && typeof v === 'object';
     },
 };
+function decodeJsonbText(v) {
+    return v ? JSON.parse(v) : null;
+}
 export const ArrayJsonbType = {
     ...JsonbType,
     name: '_jsonb',

package/data-types/time-type.js

@@ -25,18 +25,15 @@ export const TimeType = {
         buf.writeUInt32BE(lo);
     },
     decodeBinary(v, offset = 0, _len, options) {
-        const fetchAsString = options.fetchAsString?.includes(DataTypeOIDs.time);
         const hi = v.readInt32BE(offset);
         const lo = v.readUInt32BE(offset + 4);
         let d = new Date((lo + hi * timeMul) / 1000);
-        if (fetchAsString || !options.utcDates) {
+        if (!options.utcDates) {
             d = new Date(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds());
         }
-        return fetchAsString ? dateToTimeString(d) : d;
+        return d;
     },
     decodeText(v, options) {
-        if (options.fetchAsString?.includes(DataTypeOIDs.time))
-            return v;
         return parseTime(v, false, options.utcDates);
     },
     // See date-type.ts's decodeTextBuffer comment - same rationale.
@@ -51,16 +48,6 @@ export const TimeType = {
             (typeof v === 'string' && STRICT_TIME_PATTERN.test(v)));
     },
 };
-function padZero(v) {
-    return v < 9 ? '0' + v : '' + v;
-}
-function dateToTimeString(d) {
-    return (padZero(d.getHours()) +
-        ':' +
-        padZero(d.getMinutes()) +
-        ':' +
-        padZero(d.getSeconds()));
-}
 export const ArrayTimeType = {
     ...TimeType,
     name: '_time',

package/data-types/timestamp-type.js

@@ -37,33 +37,28 @@ export const TimestampType = {
         buf.writeUInt32BE(lo);
     },
     decodeBinary(v, offset = 0, _len, options) {
-        const fetchAsString = options.fetchAsString?.includes(DataTypeOIDs.timestamp);
         const hi = v.readInt32BE(offset);
         const lo = v.readUInt32BE(offset + 4);
         if (lo === 0xffffffff && hi === 0x7fffffff)
-            return fetchAsString ? 'infinity' : Infinity;
+            return Infinity;
         if (lo === 0x00000000 && hi === -0x80000000)
-            return fetchAsString ? '-infinity' : -Infinity;
+            return -Infinity;
         // Shift from 2000 to 1970
         let d = new Date((lo + hi * timeMul) / 1000 + timeShift);
-        if (fetchAsString || !options.utcDates) {
+        if (!options.utcDates) {
             d = new Date(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds());
         }
-        return fetchAsString ? dateToTimestampString(d) : d;
+        return d;
     },
     decodeText(v, options) {
-        if (options.fetchAsString?.includes(DataTypeOIDs.timestamp))
-            return v;
         return parseDateTime(v, options.utcDates);
     },
     // Reads PostgreSQL's own timestamp shape straight from the wire bytes -
-    // see timestamptz-type.ts's decodeTextBuffer for why. The two guards are
-    // what decodeText()/parseDateTime() would have applied anyway: with
-    // fetchAsString the raw string is the answer, and with utcDates the
-    // string has to go through the regex path that reads it as UTC.
+    // see timestamptz-type.ts's decodeTextBuffer for why. The guard is what
+    // decodeText()/parseDateTime() would have applied anyway: with utcDates
+    // the string has to go through the regex path that reads it as UTC.
     decodeTextBuffer(buf, offset, len, options) {
-        if (!options.utcDates &&
-            !options.fetchAsString?.includes(DataTypeOIDs.timestamp)) {
+        if (!options.utcDates) {
             const d = parsePgTimestampBuffer(buf, offset, offset + len);
             if (d !== undefined)
                 return d;
@@ -79,22 +74,6 @@ export const TimestampType = {
             !(v.getFullYear() === 1970 && v.getMonth() === 0 && v.getDate() === 1));
     },
 };
-function padZero(v) {
-    return v < 9 ? '0' + v : '' + v;
-}
-function dateToTimestampString(d) {
-    return (d.getFullYear() +
-        '-' +
-        padZero(d.getMonth() + 1) +
-        '-' +
-        padZero(d.getDate()) +
-        ' ' +
-        padZero(d.getHours()) +
-        ':' +
-        padZero(d.getMinutes()) +
-        ':' +
-        padZero(d.getSeconds()));
-}
 export const ArrayTimestampType = {
     ...TimestampType,
     name: '_timestamp',