postgrejs 2.12.0

package/cjs/data-types/bytea-type.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayByteaType = exports.ByteaType = void 0;
+const postgres_bytea_1 = __importDefault(require("postgres-bytea"));
+const constants_js_1 = require("../constants.js");
+exports.ByteaType = {
+    name: 'bytea',
+    oid: constants_js_1.DataTypeOIDs.bytea,
+    jsType: 'Buffer',
+    parseBinary(v) {
+        return v;
+    },
+    encodeBinary(buf, v) {
+        buf.writeBuffer(v);
+    },
+    parseText: postgres_bytea_1.default,
+    isType(v) {
+        return v instanceof Buffer;
+    },
+};
+exports.ArrayByteaType = {
+    ...exports.ByteaType,
+    name: '_bytea',
+    oid: constants_js_1.DataTypeOIDs._bytea,
+    elementsOID: constants_js_1.DataTypeOIDs.bytea,
+};

package/cjs/data-types/char-type.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayCharType = exports.CharType = void 0;
+const constants_js_1 = require("../constants.js");
+exports.CharType = {
+    name: 'char',
+    oid: constants_js_1.DataTypeOIDs.char,
+    jsType: 'string',
+    parseBinary(v) {
+        return v.toString('utf8');
+    },
+    encodeBinary(buf, v) {
+        buf.writeString((v ? '' + v : ' ')[0], 'utf8');
+    },
+    parseText(v) {
+        return '' + v;
+    },
+    isType(v) {
+        return typeof v === 'string' && v.length === 1;
+    },
+};
+exports.ArrayCharType = {
+    ...exports.CharType,
+    name: '_char',
+    oid: constants_js_1.DataTypeOIDs._char,
+    elementsOID: constants_js_1.DataTypeOIDs.char,
+};

package/cjs/data-types/circle-type.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayCircleType = exports.CircleType = void 0;
+const constants_js_1 = require("../constants.js");
+const CIRCLE_PATTERN1 = /^< *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *(-?\d+\.?\d*) *>$/;
+const CIRCLE_PATTERN2 = /^\( *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *(-?\d+\.?\d*) *\)$/;
+const CIRCLE_PATTERN3 = /^\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *(-?\d+\.?\d*)$/;
+const CIRCLE_PATTERN4 = /^(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *, *(-?\d+\.?\d*)$/;
+exports.CircleType = {
+    name: 'circle',
+    oid: constants_js_1.DataTypeOIDs.circle,
+    jsType: 'object',
+    parseBinary(v) {
+        return {
+            x: v.readDoubleBE(0),
+            y: v.readDoubleBE(8),
+            r: v.readDoubleBE(16),
+        };
+    },
+    encodeBinary(buf, v) {
+        buf.writeDoubleBE(v.x);
+        buf.writeDoubleBE(v.y);
+        buf.writeDoubleBE(v.r);
+    },
+    parseText(v) {
+        const m = v.match(CIRCLE_PATTERN1) || v.match(CIRCLE_PATTERN2) || v.match(CIRCLE_PATTERN3) || v.match(CIRCLE_PATTERN4);
+        if (!m)
+            return undefined;
+        return {
+            x: parseFloat(m[1]),
+            y: parseFloat(m[2]),
+            r: parseFloat(m[3]),
+        };
+    },
+    isType(v) {
+        return (typeof v === 'object' &&
+            Object.keys(v).length === 3 &&
+            typeof v.x === 'number' &&
+            typeof v.y === 'number' &&
+            typeof v.r === 'number');
+    },
+};
+exports.ArrayCircleType = {
+    ...exports.CircleType,
+    name: '_circle',
+    oid: constants_js_1.DataTypeOIDs._circle,
+    elementsOID: constants_js_1.DataTypeOIDs.circle,
+};

package/cjs/data-types/date-type.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayDateType = exports.DateType = void 0;
+const constants_js_1 = require("../constants.js");
+const parse_datetime_js_1 = require("../util/parse-datetime.js");
+const timeShift = 946684800000;
+exports.DateType = {
+    name: 'date',
+    oid: constants_js_1.DataTypeOIDs.date,
+    jsType: 'Date',
+    parseBinary(v, options) {
+        const fetchAsString = options.fetchAsString && options.fetchAsString.includes(constants_js_1.DataTypeOIDs.date);
+        const t = v.readInt32BE();
+        if (t === 0x7fffffff)
+            return fetchAsString ? 'infinity' : Infinity;
+        if (t === -0x80000000)
+            return fetchAsString ? '-infinity' : -Infinity;
+        // Shift from 2000 to 1970
+        let d = new Date(t * 1000 * 86400 + timeShift);
+        if (fetchAsString || !options.utcDates)
+            d = new Date(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate());
+        return fetchAsString ? dateToDateString(d) : d;
+    },
+    encodeBinary(buf, v, options) {
+        if (typeof v === 'string')
+            v = (0, parse_datetime_js_1.parseDateTime)(v, false, false, options.utcDates);
+        if (v === Infinity) {
+            buf.writeInt32BE(0x7fffffff);
+            return;
+        }
+        if (v === -Infinity) {
+            buf.writeInt32BE(-0x80000000);
+            return;
+        }
+        if (!(v instanceof Date))
+            v = new Date(v);
+        let n = options.utcDates ? v.getTime() : v.getTime() - v.getTimezoneOffset() * 60 * 1000;
+        n = (n - timeShift) / 1000 / 86400;
+        const t = Math.trunc(n + Number.EPSILON);
+        buf.writeInt32BE(t);
+    },
+    parseText(v, options) {
+        const fetchAsString = options.fetchAsString && options.fetchAsString.includes(constants_js_1.DataTypeOIDs.date);
+        if (fetchAsString)
+            return v;
+        return (0, parse_datetime_js_1.parseDateTime)(v, false, false, options.utcDates);
+    },
+    isType(v) {
+        return (v instanceof Date &&
+            v.getHours() === 0 &&
+            v.getMinutes() === 0 &&
+            v.getSeconds() === 0 &&
+            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());
+}
+exports.ArrayDateType = {
+    ...exports.DateType,
+    name: '_date',
+    oid: constants_js_1.DataTypeOIDs._date,
+    elementsOID: constants_js_1.DataTypeOIDs.date,
+};

package/cjs/data-types/float4-type.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayFloat4Type = exports.Float4Type = void 0;
+const constants_js_1 = require("../constants.js");
+exports.Float4Type = {
+    name: 'float4',
+    oid: constants_js_1.DataTypeOIDs.float4,
+    jsType: 'number',
+    parseBinary(v) {
+        return Math.round((v.readFloatBE(0) + Number.EPSILON) * 100) / 100;
+    },
+    encodeBinary(buf, v) {
+        buf.writeFloatBE(typeof v === 'number' ? v : parseFloat(v));
+    },
+    parseText: parseFloat,
+    isType(v) {
+        return typeof v === 'number';
+    },
+};
+exports.ArrayFloat4Type = {
+    ...exports.Float4Type,
+    name: '_float4',
+    oid: constants_js_1.DataTypeOIDs._float4,
+    elementsOID: constants_js_1.DataTypeOIDs.float4,
+};

package/cjs/data-types/float8-type.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayFloat8Type = exports.Float8Type = void 0;
+const constants_js_1 = require("../constants.js");
+exports.Float8Type = {
+    name: 'float8',
+    oid: constants_js_1.DataTypeOIDs.float8,
+    jsType: 'number',
+    parseBinary(v) {
+        return v.readDoubleBE(0);
+    },
+    encodeBinary(buf, v) {
+        buf.writeDoubleBE(typeof v === 'number' ? v : parseFloat(v));
+    },
+    parseText: parseFloat,
+    isType(v) {
+        return typeof v === 'number';
+    },
+};
+exports.ArrayFloat8Type = {
+    ...exports.Float8Type,
+    name: '_float8',
+    oid: constants_js_1.DataTypeOIDs._float8,
+    elementsOID: constants_js_1.DataTypeOIDs.float8,
+};

package/cjs/data-types/int2-type.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayInt2Type = exports.Int2Type = void 0;
+const constants_js_1 = require("../constants.js");
+const fast_parseint_js_1 = require("../util/fast-parseint.js");
+exports.Int2Type = {
+    name: 'int2',
+    oid: constants_js_1.DataTypeOIDs.int2,
+    jsType: 'number',
+    parseBinary(v) {
+        return v.readInt16BE(0);
+    },
+    encodeBinary(buf, v) {
+        buf.writeInt16BE((0, fast_parseint_js_1.fastParseInt)(v));
+    },
+    parseText: fast_parseint_js_1.fastParseInt,
+    isType(v) {
+        return typeof v === 'number' && Number.isInteger(v) && v >= -32768 && v <= 32767;
+    },
+};
+exports.ArrayInt2Type = {
+    ...exports.Int2Type,
+    name: '_int2',
+    oid: constants_js_1.DataTypeOIDs._int2,
+    elementsOID: constants_js_1.DataTypeOIDs.int2,
+};

package/cjs/data-types/int2-vector-type.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayInt2VectorType = exports.Int2VectorType = void 0;
+const constants_js_1 = require("../constants.js");
+const decode_binaryarray_js_1 = require("../util/decode-binaryarray.js");
+const encode_binaryarray_js_1 = require("../util/encode-binaryarray.js");
+const fast_parseint_js_1 = require("../util/fast-parseint.js");
+exports.Int2VectorType = {
+    name: 'int2vector',
+    oid: constants_js_1.DataTypeOIDs.int2vector,
+    jsType: 'array',
+    parseBinary(v) {
+        return (0, decode_binaryarray_js_1.decodeBinaryArray)(v, b => b.readInt16BE()) || undefined;
+    },
+    encodeBinary(buf, v) {
+        (0, encode_binaryarray_js_1.encodeBinaryArray)(buf, v, constants_js_1.DataTypeOIDs.int2, {}, (io, x) => {
+            io.writeInt16BE(x);
+        });
+    },
+    encodeCalculateDim(v) {
+        return [v.length];
+    },
+    parseText(str) {
+        return str.split(' ').map(fast_parseint_js_1.fastParseInt);
+    },
+    encodeText(v) {
+        return v.join(' ');
+    },
+    isType(v) {
+        return (Array.isArray(v) && !v.find(x => !(typeof x === 'number' && Number.isInteger(x) && x >= -32768 && x <= 32767)));
+    },
+};
+exports.ArrayInt2VectorType = {
+    ...exports.Int2VectorType,
+    name: '_int2vector',
+    oid: constants_js_1.DataTypeOIDs._int2vector,
+    elementsOID: constants_js_1.DataTypeOIDs.int2vector,
+};

package/cjs/data-types/int4-type.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayInt4Type = exports.Int4Type = void 0;
+const constants_js_1 = require("../constants.js");
+const fast_parseint_js_1 = require("../util/fast-parseint.js");
+exports.Int4Type = {
+    name: 'int4',
+    oid: constants_js_1.DataTypeOIDs.int4,
+    jsType: 'number',
+    parseBinary(v) {
+        return v.readInt32BE(0);
+    },
+    encodeBinary(buf, v) {
+        buf.writeInt32BE((0, fast_parseint_js_1.fastParseInt)(v));
+    },
+    parseText: fast_parseint_js_1.fastParseInt,
+    isType(v) {
+        return typeof v === 'number' && Number.isInteger(v) && v <= Number.MAX_SAFE_INTEGER;
+    },
+};
+exports.ArrayInt4Type = {
+    ...exports.Int4Type,
+    name: '_int4',
+    oid: constants_js_1.DataTypeOIDs._int4,
+    elementsOID: constants_js_1.DataTypeOIDs.int4,
+};

package/cjs/data-types/int8-type.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayInt8Type = exports.Int8Type = void 0;
+const constants_js_1 = require("../constants.js");
+const bigint_methods_js_1 = require("../util/bigint-methods.js");
+const maxSafeInteger = BigInt(Number.MAX_SAFE_INTEGER);
+exports.Int8Type = {
+    name: 'int8',
+    oid: constants_js_1.DataTypeOIDs.int8,
+    jsType: 'BigInt',
+    parseBinary(buf) {
+        const v = typeof buf.readBigInt64BE === 'function' ? buf.readBigInt64BE(0) : (0, bigint_methods_js_1.readBigInt64BE)(buf);
+        return v >= -maxSafeInteger && v <= maxSafeInteger ? Number(v) : v;
+    },
+    encodeBinary(buf, v) {
+        buf.writeBigInt64BE(v);
+    },
+    parseText(s) {
+        const v = BigInt(s);
+        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);
+    },
+};
+exports.ArrayInt8Type = {
+    ...exports.Int8Type,
+    name: '_int8',
+    oid: constants_js_1.DataTypeOIDs._int8,
+    elementsOID: constants_js_1.DataTypeOIDs.int8,
+};

package/cjs/data-types/json-type.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayJsonType = exports.JsonType = void 0;
+const constants_js_1 = require("../constants.js");
+exports.JsonType = {
+    name: 'json',
+    oid: constants_js_1.DataTypeOIDs.json,
+    jsType: 'string',
+    parseBinary(v, options) {
+        const content = v.toString('utf8');
+        const fetchAsString = options.fetchAsString && options.fetchAsString.includes(constants_js_1.DataTypeOIDs.jsonb);
+        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 '' + v;
+    },
+    parseText(v, options) {
+        const fetchAsString = options.fetchAsString && options.fetchAsString.includes(constants_js_1.DataTypeOIDs.jsonb);
+        if (fetchAsString)
+            return v;
+        return v ? JSON.parse(v) : null;
+    },
+    isType(v) {
+        return v && typeof v === 'object';
+    },
+};
+exports.ArrayJsonType = {
+    ...exports.JsonType,
+    name: '_json',
+    oid: constants_js_1.DataTypeOIDs._json,
+    elementsOID: constants_js_1.DataTypeOIDs.json,
+};

package/cjs/data-types/jsonb-type.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayJsonbType = exports.JsonbType = void 0;
+const constants_js_1 = require("../constants.js");
+const buffer_reader_js_1 = require("../protocol/buffer-reader.js");
+exports.JsonbType = {
+    name: 'jsonb',
+    oid: constants_js_1.DataTypeOIDs.jsonb,
+    jsType: 'string',
+    parseBinary(v, options) {
+        const buf = new buffer_reader_js_1.BufferReader(v);
+        if (buf.readUInt8() !== 1)
+            throw new Error('Unexpected Jsonb version value in header');
+        const fetchAsString = options.fetchAsString && options.fetchAsString.includes(constants_js_1.DataTypeOIDs.json);
+        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(constants_js_1.DataTypeOIDs.json);
+        if (fetchAsString)
+            return v;
+        return v ? JSON.parse(v) : null;
+    },
+    isType(v) {
+        return v && typeof v === 'object';
+    },
+};
+exports.ArrayJsonbType = {
+    ...exports.JsonbType,
+    name: '_jsonb',
+    oid: constants_js_1.DataTypeOIDs._jsonb,
+    elementsOID: constants_js_1.DataTypeOIDs.jsonb,
+};

package/cjs/data-types/lseg-type.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayLsegType = exports.LsegType = void 0;
+const constants_js_1 = require("../constants.js");
+const LSEG_PATTERN1 = /^\[ *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *]$/;
+const LSEG_PATTERN2 = /^\( *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *\)$/;
+const LSEG_PATTERN3 = /^\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\)$/;
+const LSEG_PATTERN4 = /^(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *, *(-?\d+\.?\d*)$/;
+exports.LsegType = {
+    name: 'lseg',
+    oid: constants_js_1.DataTypeOIDs.lseg,
+    jsType: 'object',
+    parseBinary(v) {
+        return {
+            x1: v.readDoubleBE(0),
+            y1: v.readDoubleBE(8),
+            x2: v.readDoubleBE(16),
+            y2: v.readDoubleBE(24),
+        };
+    },
+    encodeBinary(buf, v) {
+        buf.writeDoubleBE(v.x1);
+        buf.writeDoubleBE(v.y1);
+        buf.writeDoubleBE(v.x2);
+        buf.writeDoubleBE(v.y2);
+    },
+    parseText(v) {
+        const m = v.match(LSEG_PATTERN1) || v.match(LSEG_PATTERN2) || v.match(LSEG_PATTERN3) || v.match(LSEG_PATTERN4);
+        if (!m)
+            return undefined;
+        return {
+            x1: parseFloat(m[1]),
+            y1: parseFloat(m[2]),
+            x2: parseFloat(m[3]),
+            y2: parseFloat(m[4]),
+        };
+    },
+    isType(v) {
+        return (typeof v === 'object' &&
+            Object.keys(v).length === 4 &&
+            typeof v.x1 === 'number' &&
+            typeof v.y1 === 'number' &&
+            typeof v.x2 === 'number' &&
+            typeof v.y2 === 'number');
+    },
+};
+exports.ArrayLsegType = {
+    ...exports.LsegType,
+    name: '_lseg',
+    oid: constants_js_1.DataTypeOIDs._lseg,
+    elementsOID: constants_js_1.DataTypeOIDs.lseg,
+};

package/cjs/data-types/numeric-type.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberBytesToString = exports.ArrayNumericType = exports.NumericType = void 0;
+const constants_js_1 = require("../constants.js");
+const NUMERIC_NEG = 0x4000;
+const NUMERIC_NAN = 0xc000;
+const DEC_DIGITS = 4;
+const ROUND_POWERS = [0, 1000, 100, 10];
+exports.NumericType = {
+    name: 'numeric',
+    oid: constants_js_1.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);
+        if (sign === NUMERIC_NAN)
+            return NaN;
+        const digits = [];
+        for (let i = 0; i < len; i++) {
+            digits[i] = v.readInt16BE(8 + i * 2);
+        }
+        const numString = numberBytesToString(digits, scale, weight, sign);
+        return parseFloat(numString);
+    },
+    encodeText(v) {
+        const n = typeof v === 'number' ? v : parseFloat(v);
+        return '' + n;
+    },
+    parseText: parseFloat,
+    isType(v) {
+        return typeof v === 'number';
+    },
+};
+exports.ArrayNumericType = {
+    ...exports.NumericType,
+    name: '_numeric',
+    oid: constants_js_1.DataTypeOIDs._numeric,
+    elementsOID: constants_js_1.DataTypeOIDs.numeric,
+};
+/* 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.
+ * @param digits array of shorts that can be decoded as the number String
+ * @param scale the scale of the number binary representation
+ * @param weight the weight of the number binary representation
+ * @param sign the sign of the number
+ * @return String the number as String
+ */
+function numberBytesToString(digits, scale, weight, sign) {
+    let i;
+    let d;
+    /*
+     * Allocate space for the result.
+     *
+     * i is set to the # of decimal digits before decimal point.
+     * dscale is the # of decimal digits we will print after decimal point.
+     * We may generate as many as DEC_DIGITS-1 excess digits at the end, and in addition we
+     * need room for sign, decimal point, null terminator.
+     */
+    i = (weight + 1) * DEC_DIGITS;
+    if (i <= 0)
+        i = 1;
+    /*
+     * Output a dash for negative values
+     */
+    let out = sign === NUMERIC_NEG ? '-' : '';
+    /*
+     * Output all digits before the decimal point
+     */
+    if (weight < 0) {
+        d = weight + 1;
+        out += '0';
+    }
+    else {
+        for (d = 0; d <= weight; d++) {
+            /* In the first digit, suppress extra leading decimal zeroes */
+            out += digitToString(d, digits, d !== 0);
+        }
+    }
+    /*
+     * If requested, output a decimal point and all the digits that follow it.
+     * We initially put out a multiple of DEC_DIGITS digits, then truncate if
+     * needed.
+     */
+    if (scale > 0) {
+        out += '.';
+        for (i = 0; i < scale; d++, i += DEC_DIGITS) {
+            out += digitToString(d, digits, true);
+        }
+    }
+    const extra = (i - scale) % DEC_DIGITS;
+    return out.substr(0, out.length - extra);
+}
+exports.numberBytesToString = numberBytesToString;
+/* 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.
+ * @param idx index of the digit to be converted in the digits array
+ * @param digits array of shorts that can be decoded as the number String
+ * @param alwaysPutIt a flag that indicate whether or not to put the digit char even if it is zero
+ * @return String the number as String
+ */
+function digitToString(idx, digits, alwaysPutIt) {
+    let out = '';
+    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 pow = ROUND_POWERS[p];
+        const d1 = Math.trunc(dig / pow);
+        dig -= d1 * pow;
+        const putit = d1 > 0;
+        if (putit || alwaysPutIt) {
+            out += d1;
+            // We printed a character, so we need to print the rest of the current digits in dig
+            // For instance, we need to keep printing 000 from 1000 even if idx==0 (== it is the very
+            // beginning)
+            alwaysPutIt = true;
+        }
+    }
+    out += dig;
+    return out;
+}

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VectorOidType = exports.ArrayOidType = exports.OidType = void 0;
+const constants_js_1 = require("../constants.js");
+const fast_parseint_js_1 = require("../util/fast-parseint.js");
+exports.OidType = {
+    name: 'oid',
+    oid: constants_js_1.DataTypeOIDs.oid,
+    jsType: 'number',
+    parseBinary(v) {
+        return v.readUInt32BE(0);
+    },
+    encodeBinary(buf, v) {
+        buf.writeUInt32BE((0, fast_parseint_js_1.fastParseInt)(v));
+    },
+    parseText: fast_parseint_js_1.fastParseInt,
+    isType(v) {
+        return typeof v === 'number' && Number.isInteger(v) && !!constants_js_1.DataTypeNames[v];
+    },
+};
+exports.ArrayOidType = {
+    ...exports.OidType,
+    name: '_oid',
+    oid: constants_js_1.DataTypeOIDs._oid,
+    elementsOID: constants_js_1.DataTypeOIDs.oid,
+};
+exports.VectorOidType = {
+    ...exports.OidType,
+    name: '_oidvector',
+    oid: constants_js_1.DataTypeOIDs.oidvector,
+    elementsOID: constants_js_1.DataTypeOIDs.oid,
+};