postgrejs 2.23.1 → 3.0.1

package/data-types/int4-type.js

@@ -1,20 +1,26 @@
 import { DataTypeOIDs } from '../constants.js';
-import { fastParseInt } from '../util/fast-parseint.js';
+import { fastParseInt, fastParseIntBuffer } from '../util/fast-parseint.js';
 export const Int4Type = {
     name: 'int4',
     oid: DataTypeOIDs.int4,
     jsType: 'number',
-    parseBinary(v) {
-        return v.readInt32BE(0);
+    fixedBinarySize: 4,
+    encodeText(v) {
+        return '' + v;
     },
     encodeBinary(buf, v) {
         buf.writeInt32BE(fastParseInt(v));
     },
-    parseText: fastParseInt,
+    decodeBinary(v, offset = 0) {
+        return v.readInt32BE(offset);
+    },
+    decodeText: fastParseInt,
+    decodeTextBuffer: fastParseIntBuffer,
     isType(v) {
         return (typeof v === 'number' &&
             Number.isInteger(v) &&
-            v <= Number.MAX_SAFE_INTEGER);
+            v >= -2147483648 &&
+            v <= 2147483647);
     },
 };
 export const ArrayInt4Type = {

package/data-types/int8-type.js

@@ -1,28 +1,43 @@
 import { DataTypeOIDs } from '../constants.js';
 import { readBigInt64BE } from '../util/bigint-methods.js';
+import { fastParseIntBuffer } from '../util/fast-parseint.js';
 const maxSafeInteger = BigInt(Number.MAX_SAFE_INTEGER);
 export const Int8Type = {
     name: 'int8',
     oid: DataTypeOIDs.int8,
     jsType: 'BigInt',
-    parseBinary(buf) {
-        const v = typeof buf.readBigInt64BE === 'function'
-            ? buf.readBigInt64BE(0)
-            : readBigInt64BE(buf);
-        return v >= -maxSafeInteger && v <= maxSafeInteger ? Number(v) : v;
+    fixedBinarySize: 8,
+    encodeText(v) {
+        return '' + v;
     },
     encodeBinary(buf, v) {
         buf.writeBigInt64BE(v);
     },
-    parseText(s) {
+    decodeBinary(buf, offset = 0) {
+        const v = typeof buf.readBigInt64BE === 'function'
+            ? buf.readBigInt64BE(offset)
+            : readBigInt64BE(buf, offset);
+        return v >= -maxSafeInteger && v <= maxSafeInteger ? Number(v) : v;
+    },
+    decodeText(s) {
+        const digits = s.charCodeAt(0) === 45 /* '-' */ ? s.length - 1 : s.length;
+        if (digits <= 15)
+            return Number(s);
         const v = BigInt(s);
         return v >= -maxSafeInteger && v <= maxSafeInteger ? Number(v) : v;
     },
+    decodeTextBuffer(buf, offset, len) {
+        const digits = buf[offset] === 45 /* '-' */ ? len - 1 : len;
+        if (digits <= 15)
+            return fastParseIntBuffer(buf, offset, len);
+        const v = BigInt(buf.toString('utf8', offset, offset + len));
+        return v >= -maxSafeInteger && v <= maxSafeInteger ? Number(v) : v;
+    },
     isType(v) {
         return (typeof v === 'bigint' ||
             (typeof v === 'number' &&
                 Number.isInteger(v) &&
-                v > Number.MAX_SAFE_INTEGER));
+                (v > 2147483647 || v < -2147483648)));
     },
 };
 export const ArrayInt8Type = {

package/data-types/json-type.js

@@ -3,28 +3,37 @@ export const JsonType = {
     name: 'json',
     oid: DataTypeOIDs.json,
     jsType: 'string',
-    parseBinary(v, options) {
-        const content = v.toString('utf8');
-        const fetchAsString = options.fetchAsString &&
-            options.fetchAsString.includes(DataTypeOIDs.jsonb);
+    decodeBinary(v, offset = 0, options) {
+        const content = v.toString('utf8', offset);
+        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.
+    encodeBinary(buf, v) {
+        buf.writeString(JsonType.encodeText(v, {}), 'utf8');
+    },
     encodeText(v) {
-        if (typeof v === 'object' || typeof v === 'bigint')
+        // JSON.stringify() cannot serialize a BigInt itself (it throws), so a
+        // bigint is written directly as a bare numeric literal instead.
+        if (typeof v === 'bigint')
+            return v.toString();
+        if (typeof v === 'object')
             return JSON.stringify(v);
         if (typeof v === 'boolean')
             return v ? 'true' : 'false';
         return '' + v;
     },
-    parseText(v, options) {
-        const fetchAsString = options.fetchAsString &&
-            options.fetchAsString.includes(DataTypeOIDs.jsonb);
+    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);
+    },
     isType(v) {
         return v && typeof v === 'object';
     },

package/data-types/jsonb-type.js

@@ -4,31 +4,37 @@ export const JsonbType = {
     name: 'jsonb',
     oid: DataTypeOIDs.jsonb,
     jsType: 'string',
-    parseBinary(v, options) {
-        const buf = new BufferReader(v);
+    encodeText(v) {
+        if (typeof v === 'object' || typeof v === 'bigint')
+            return JSON.stringify(v);
+        if (typeof v === 'boolean')
+            return v ? 'true' : 'false';
+        return '' + v;
+    },
+    encodeBinary(buf, v) {
+        buf.writeUInt8(1);
+        buf.writeString(JsonbType.encodeText(v, {}), 'utf8');
+    },
+    decodeBinary(v, offset = 0, options) {
+        const buf = new BufferReader(offset ? v.subarray(offset) : v);
         if (buf.readUInt8() !== 1)
             throw new Error('Unexpected Jsonb version value in header');
-        const fetchAsString = options.fetchAsString &&
-            options.fetchAsString.includes(DataTypeOIDs.json);
+        const fetchAsString = options.fetchAsString?.includes(DataTypeOIDs.jsonb);
         const content = buf.readLString(buf.length - buf.offset);
         if (fetchAsString)
             return content;
         return content ? JSON.parse(content) : undefined;
     },
-    encodeText(v) {
-        if (typeof v === 'object' || typeof v === 'bigint')
-            return JSON.stringify(v);
-        if (typeof v === 'boolean')
-            return v ? 'true' : 'false';
-        return '\x0001' + v;
-    },
-    parseText(v, options) {
-        const fetchAsString = options.fetchAsString &&
-            options.fetchAsString.includes(DataTypeOIDs.json);
+    decodeText(v, options) {
+        const fetchAsString = options.fetchAsString?.includes(DataTypeOIDs.jsonb);
         if (fetchAsString)
             return v;
         return v ? JSON.parse(v) : null;
     },
+    // See json-type.ts's decodeTextBuffer comment - same rationale.
+    decodeTextBuffer(buf, offset, len, options) {
+        return JsonbType.decodeText(buf.toString('utf8', offset, offset + len), options);
+    },
     isType(v) {
         return v && typeof v === 'object';
     },

package/data-types/lseg-type.js

@@ -7,13 +7,9 @@ export const LsegType = {
     name: 'lseg',
     oid: DataTypeOIDs.lseg,
     jsType: 'object',
-    parseBinary(v) {
-        return {
-            x1: v.readDoubleBE(0),
-            y1: v.readDoubleBE(8),
-            x2: v.readDoubleBE(16),
-            y2: v.readDoubleBE(24),
-        };
+    fixedBinarySize: 32,
+    encodeText(v) {
+        return `[(${v.x1},${v.y1}),(${v.x2},${v.y2})]`;
     },
     encodeBinary(buf, v) {
         buf.writeDoubleBE(v.x1);
@@ -21,7 +17,15 @@ export const LsegType = {
         buf.writeDoubleBE(v.x2);
         buf.writeDoubleBE(v.y2);
     },
-    parseText(v) {
+    decodeBinary(v, offset = 0) {
+        return {
+            x1: v.readDoubleBE(offset),
+            y1: v.readDoubleBE(offset + 8),
+            x2: v.readDoubleBE(offset + 16),
+            y2: v.readDoubleBE(offset + 24),
+        };
+    },
+    decodeText(v) {
         const m = v.match(LSEG_PATTERN1) ||
             v.match(LSEG_PATTERN2) ||
             v.match(LSEG_PATTERN3) ||
@@ -35,6 +39,10 @@ export const LsegType = {
             y2: parseFloat(m[4]),
         };
     },
+    // See box-type.ts's decodeTextBuffer comment - same rationale.
+    decodeTextBuffer(buf, offset, len, options) {
+        return LsegType.decodeText(buf.toString('latin1', offset, offset + len), options);
+    },
     isType(v) {
         return (typeof v === 'object' &&
             Object.keys(v).length === 4 &&

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

@@ -1,6 +1,14 @@
 import type { DataType } from '../interfaces/data-type.js';
 export declare const NumericType: DataType;
 export declare const ArrayNumericType: DataType;
+/**
+ * Turns a JS exponential-notation number string (e.g. "1e+21", "-1.5e-7")
+ * into plain decimal notation by shifting the decimal point across the
+ * mantissa's own digits - no floating-point math involved, so it stays
+ * exact for magnitudes past what toFixed() can express (it reverts to
+ * exponential notation itself once |x| reaches 1e21).
+ */
+export declare function expandExponential(str: string): string;
 /**
  * Convert a number from binary representation to text representation.
  * @param digits array of shorts that can be decoded as the number String

package/data-types/numeric-type.js

@@ -1,22 +1,100 @@
 import { DataTypeOIDs } from '../constants.js';
 const NUMERIC_NEG = 0x4000;
 const NUMERIC_NAN = 0xc000;
+const NUMERIC_PINF = 0xd000;
+const NUMERIC_NINF = 0xf000;
 const DEC_DIGITS = 4;
 const ROUND_POWERS = [0, 1000, 100, 10];
 export const NumericType = {
     name: 'numeric',
     oid: DataTypeOIDs.numeric,
     jsType: 'number',
-    parseBinary(v) {
-        const len = v.readInt16BE();
-        const weight = v.readInt16BE(2);
-        const sign = v.readInt16BE(4);
-        const scale = v.readInt16BE(6);
+    /**
+     * numeric on the wire is a base-10000 number: a digit count, the weight
+     * of the first group (in groups of four decimal digits, not digits), a
+     * sign mask, the display scale, then the groups themselves.
+     *
+     * Encoded from the decimal text rather than from the float, so a value
+     * that JavaScript cannot hold exactly - which is most of what numeric
+     * exists for - survives when it was given as a string.
+     */
+    encodeBinary(buf, v) {
+        const writeHeader = (ndigits, weight, sign, dscale) => {
+            buf.writeInt16BE(ndigits);
+            buf.writeInt16BE(weight);
+            buf.writeUInt16BE(sign);
+            buf.writeInt16BE(dscale);
+        };
+        if (typeof v === 'number' && !Number.isFinite(v)) {
+            writeHeader(0, 0, Number.isNaN(v) ? NUMERIC_NAN : v > 0 ? NUMERIC_PINF : NUMERIC_NINF, 0);
+            return;
+        }
+        let str = typeof v === 'string' ? v.trim() : String(v);
+        if (str === 'NaN')
+            return writeHeader(0, 0, NUMERIC_NAN, 0);
+        if (str === 'Infinity')
+            return writeHeader(0, 0, NUMERIC_PINF, 0);
+        if (str === '-Infinity')
+            return writeHeader(0, 0, NUMERIC_NINF, 0);
+        // Exponent form has no place in the wire format; go through Number to
+        // get it back into plain notation. toFixed() cannot do this itself -
+        // per spec it falls back to exponential notation once the magnitude
+        // reaches 1e21, so this shifts the decimal point manually instead.
+        if (/e/i.test(str))
+            str = expandExponential(Number(str).toString());
+        let sign = 0;
+        if (str.startsWith('-')) {
+            sign = NUMERIC_NEG;
+            str = str.substring(1);
+        }
+        else if (str.startsWith('+'))
+            str = str.substring(1);
+        const dot = str.indexOf('.');
+        let intPart = dot < 0 ? str : str.substring(0, dot);
+        let fracPart = dot < 0 ? '' : str.substring(dot + 1);
+        const dscale = fracPart.length;
+        // Group into fours, aligned on the decimal point from both sides.
+        const intPad = (DEC_DIGITS - (intPart.length % DEC_DIGITS)) % DEC_DIGITS;
+        intPart = '0'.repeat(intPad) + intPart;
+        const fracPad = (DEC_DIGITS - (fracPart.length % DEC_DIGITS)) % DEC_DIGITS;
+        fracPart = fracPart + '0'.repeat(fracPad);
+        const digits = [];
+        for (let i = 0; i < intPart.length; i += DEC_DIGITS)
+            digits.push(+intPart.substring(i, i + DEC_DIGITS));
+        for (let i = 0; i < fracPart.length; i += DEC_DIGITS)
+            digits.push(+fracPart.substring(i, i + DEC_DIGITS));
+        // weight counts groups before the point, less one; leading zero groups
+        // are dropped and lower it, trailing ones are simply dropped.
+        let weight = intPart.length / DEC_DIGITS - 1;
+        while (digits.length && digits[0] === 0) {
+            digits.shift();
+            weight--;
+        }
+        while (digits.length && digits[digits.length - 1] === 0)
+            digits.pop();
+        if (!digits.length)
+            weight = 0;
+        writeHeader(digits.length, weight, sign, dscale);
+        for (const d of digits)
+            buf.writeInt16BE(d);
+    },
+    decodeBinary(v, offset = 0) {
+        const len = v.readInt16BE(offset);
+        const weight = v.readInt16BE(offset + 2);
+        // sign is a bitmask (0x0000/0x4000/0xC000/0xD000/0xF000), not a two's
+        // complement quantity - must be read unsigned or NaN/Infinity sign
+        // values (which set the top bit) never compare equal to the constants.
+        const sign = v.readUInt16BE(offset + 4);
+        const scale = v.readInt16BE(offset + 6);
         if (sign === NUMERIC_NAN)
             return NaN;
+        if (sign === NUMERIC_PINF)
+            return Infinity;
+        if (sign === NUMERIC_NINF)
+            return -Infinity;
         const digits = [];
         for (let i = 0; i < len; i++) {
-            digits[i] = v.readInt16BE(8 + i * 2);
+            digits[i] = v.readInt16BE(offset + 8 + i * 2);
         }
         const numString = numberBytesToString(digits, scale, weight, sign);
         return parseFloat(numString);
@@ -25,7 +103,11 @@ export const NumericType = {
         const n = typeof v === 'number' ? v : parseFloat(v);
         return '' + n;
     },
-    parseText: parseFloat,
+    decodeText: parseFloat,
+    // See float4-type.ts's decodeTextBuffer comment - same rationale.
+    decodeTextBuffer(buf, offset, len) {
+        return parseFloat(buf.toString('latin1', offset, offset + len));
+    },
     isType(v) {
         return typeof v === 'number';
     },
@@ -36,6 +118,26 @@ export const ArrayNumericType = {
     oid: DataTypeOIDs._numeric,
     elementsOID: DataTypeOIDs.numeric,
 };
+/**
+ * Turns a JS exponential-notation number string (e.g. "1e+21", "-1.5e-7")
+ * into plain decimal notation by shifting the decimal point across the
+ * mantissa's own digits - no floating-point math involved, so it stays
+ * exact for magnitudes past what toFixed() can express (it reverts to
+ * exponential notation itself once |x| reaches 1e21).
+ */
+export function expandExponential(str) {
+    const m = str.match(/^(-)?(\d+)(?:\.(\d+))?e([+-]?\d+)$/i);
+    if (!m)
+        return str;
+    const sign = m[1] || '';
+    const digits = m[2] + (m[3] || '');
+    const pointPos = m[2].length + parseInt(m[4], 10);
+    if (pointPos <= 0)
+        return sign + '0.' + '0'.repeat(-pointPos) + digits;
+    if (pointPos >= digits.length)
+        return sign + digits + '0'.repeat(pointPos - digits.length);
+    return sign + digits.slice(0, pointPos) + '.' + digits.slice(pointPos);
+}
 /* https://github.com/pgjdbc/pgjdbc/blob/3eca3a76aa4a04cb28cb960ed674cb67db30b5e3/pgjdbc/src/main/java/org/postgresql/util/ByteConverter.java */
 /**
  * Convert a number from binary representation to text representation.
@@ -103,7 +205,9 @@ function digitToString(idx, digits, alwaysPutIt) {
     let dig = idx >= 0 && idx < digits.length ? digits[idx] : 0;
     // Each dig represents 4 decimal digits (e.g. 9999)
     // If we continue the number, then we need to print 0 as 0000 (alwaysPutIt parameter is true)
-    for (let p = 1; p < ROUND_POWERS.length; p++) {
+    const l = ROUND_POWERS.length;
+    let p;
+    for (p = 1; p < l; p++) {
         const pow = ROUND_POWERS[p];
         const d1 = Math.trunc(dig / pow);
         dig -= d1 * pow;

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

@@ -1,4 +1,3 @@
 import type { DataType } from '../interfaces/data-type.js';
 export declare const OidType: DataType;
 export declare const ArrayOidType: DataType;
-export declare const VectorOidType: DataType;

package/data-types/oid-type.js

@@ -1,16 +1,21 @@
 import { DataTypeNames, DataTypeOIDs } from '../constants.js';
-import { fastParseInt } from '../util/fast-parseint.js';
+import { fastParseInt, fastParseIntBuffer } from '../util/fast-parseint.js';
 export const OidType = {
     name: 'oid',
     oid: DataTypeOIDs.oid,
     jsType: 'number',
-    parseBinary(v) {
-        return v.readUInt32BE(0);
+    fixedBinarySize: 4,
+    encodeText(v) {
+        return '' + v;
     },
     encodeBinary(buf, v) {
         buf.writeUInt32BE(fastParseInt(v));
     },
-    parseText: fastParseInt,
+    decodeBinary(v, offset = 0) {
+        return v.readUInt32BE(offset);
+    },
+    decodeText: fastParseInt,
+    decodeTextBuffer: fastParseIntBuffer,
     isType(v) {
         return typeof v === 'number' && Number.isInteger(v) && !!DataTypeNames[v];
     },
@@ -21,9 +26,3 @@ export const ArrayOidType = {
     oid: DataTypeOIDs._oid,
     elementsOID: DataTypeOIDs.oid,
 };
-export const VectorOidType = {
-    ...OidType,
-    name: '_oidvector',
-    oid: DataTypeOIDs.oidvector,
-    elementsOID: DataTypeOIDs.oid,
-};

package/data-types/oid-vector-type.d.ts

@@ -0,0 +1,9 @@
+import type { DataType } from '../interfaces/data-type.js';
+/**
+ * `oidvector` (OID 30) is a list of OIDs, not the array type of `oid` -
+ * that is `_oid` (1028). It has its own array type, `_oidvector` (1013),
+ * exactly as `int2vector` has `_int2vector`, and its text form is
+ * space-separated rather than braced.
+ */
+export declare const OidVectorType: DataType;
+export declare const ArrayOidVectorType: DataType;

package/data-types/oid-vector-type.js

@@ -0,0 +1,51 @@
+import { DataTypeOIDs } from '../constants.js';
+import { SmartBuffer } from '../protocol/smart-buffer.js';
+import { decodeBinaryArray } from '../util/decode-binaryarray.js';
+import { encodeBinaryArray } from '../util/encode-binaryarray.js';
+import { fastParseInt } from '../util/fast-parseint.js';
+/**
+ * `oidvector` (OID 30) is a list of OIDs, not the array type of `oid` -
+ * that is `_oid` (1028). It has its own array type, `_oidvector` (1013),
+ * exactly as `int2vector` has `_int2vector`, and its text form is
+ * space-separated rather than braced.
+ */
+export const OidVectorType = {
+    name: 'oidvector',
+    oid: DataTypeOIDs.oidvector,
+    jsType: 'array',
+    encodeBinary(buf, v) {
+        encodeBinaryArray(buf, v, DataTypeOIDs.oid, {}, (io, x) => {
+            io.writeUInt32BE(x);
+        });
+    },
+    encodeCalculateDim(v) {
+        return [v.length];
+    },
+    decodeBinary(v) {
+        return decodeBinaryArray(v, 0, b => b.readUInt32BE()) || undefined;
+    },
+    decodeText(str) {
+        return str.split(' ').map(fastParseInt);
+    },
+    // See box-type.ts's decodeTextBuffer comment - same rationale (this text
+    // grammar is pure ASCII digits and spaces).
+    decodeTextBuffer(buf, offset, len, options) {
+        return OidVectorType.decodeText(buf.toString('latin1', offset, offset + len), options);
+    },
+    encodeText(v) {
+        return v.join(' ');
+    },
+    isType(v) {
+        return (Array.isArray(v) &&
+            !v.find(x => !(typeof x === 'number' &&
+                Number.isInteger(x) &&
+                x >= 0 &&
+                x <= 4294967295)));
+    },
+};
+export const ArrayOidVectorType = {
+    ...OidVectorType,
+    name: '_oidvector',
+    oid: DataTypeOIDs._oidvector,
+    elementsOID: DataTypeOIDs.oidvector,
+};

package/data-types/point-type.js

@@ -5,17 +5,21 @@ export const PointType = {
     name: 'point',
     oid: DataTypeOIDs.point,
     jsType: 'object',
-    parseBinary(v) {
-        return {
-            x: v.readDoubleBE(0),
-            y: v.readDoubleBE(8),
-        };
+    fixedBinarySize: 16,
+    encodeText(v) {
+        return `(${v.x},${v.y})`;
     },
     encodeBinary(buf, v) {
         buf.writeDoubleBE(v.x);
         buf.writeDoubleBE(v.y);
     },
-    parseText(v) {
+    decodeBinary(v, offset = 0) {
+        return {
+            x: v.readDoubleBE(offset),
+            y: v.readDoubleBE(offset + 8),
+        };
+    },
+    decodeText(v) {
         const m = v.match(POINT_PATTERN1) || v.match(POINT_PATTERN2);
         if (!m)
             return undefined;
@@ -24,6 +28,10 @@ export const PointType = {
             y: 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);
+    },
     isType(v) {
         return (typeof v === 'object' &&
             Object.keys(v).length === 2 &&

package/data-types/time-type.js

@@ -1,20 +1,14 @@
 import { DataTypeOIDs } from '../constants.js';
+import { formatTime } from '../util/format-datetime.js';
 import { parseTime, STRICT_TIME_PATTERN } from '../util/parse-time.js';
 const timeMul = 4294967296;
 export const TimeType = {
     name: 'time',
     oid: DataTypeOIDs.time,
     jsType: 'string',
-    parseBinary(v, options) {
-        const fetchAsString = options.fetchAsString &&
-            options.fetchAsString.includes(DataTypeOIDs.time);
-        const hi = v.readInt32BE();
-        const lo = v.readUInt32BE(4);
-        let d = new Date((lo + hi * timeMul) / 1000);
-        if (fetchAsString || !options.utcDates) {
-            d = new Date(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds());
-        }
-        return fetchAsString ? dateToTimeString(d) : d;
+    fixedBinarySize: 8,
+    encodeText(v, options) {
+        return formatTime(v, options);
     },
     encodeBinary(buf, v, options) {
         if (typeof v === 'string')
@@ -31,12 +25,25 @@ export const TimeType = {
         buf.writeInt32BE(hi);
         buf.writeUInt32BE(lo);
     },
-    parseText(v, options) {
-        if (options.fetchAsString &&
-            options.fetchAsString.includes(DataTypeOIDs.time))
+    decodeBinary(v, offset = 0, 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) {
+            d = new Date(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds());
+        }
+        return fetchAsString ? dateToTimeString(d) : 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.
+    decodeTextBuffer(buf, offset, len, options) {
+        return TimeType.decodeText(buf.toString('latin1', offset, offset + len), options);
+    },
     isType(v) {
         return ((v instanceof Date &&
             v.getFullYear() === 1970 &&