@m2k-5f/pgtx 2.7.2 → 2.8.0

package/dist/protocol/connection-response-reader.js

@@ -1,6 +1,6 @@
-import { DataTypeOids } from "./constants";
+import { INT4Length } from "./constants";
 import { PostgresError } from "../error";
-const columnValueCache = new Map();
+import { handlers } from "./types";
 const POSTGRES_EPOCH_MS = 946684800000;
 export class ConnectionResponseBuffer {
     constructor(buffer) {
@@ -10,6 +10,25 @@ export class ConnectionResponseBuffer {
     static from(buffer) {
         return new ConnectionResponseBuffer(buffer);
     }
+    hasMore() {
+        return this.caret < this.buffer.length;
+    }
+    skipBytes(byteCount) {
+        this.caret += byteCount;
+    }
+    hasFullPacket() {
+        const availableBytes = this.buffer.length - this.caret;
+        if (availableBytes < 5)
+            return false;
+        const packetLength = this.buffer.readInt32BE(this.caret + 1);
+        if (availableBytes < 1 + packetLength)
+            return false;
+        return true;
+    }
+    getResidualBuffer() {
+        return this.buffer.subarray(this.caret);
+    }
+    // ------ primitives ------
     readChar() {
         const char = String.fromCharCode(this.buffer[this.caret]);
         this.caret += 1;
@@ -36,111 +55,16 @@ export class ConnectionResponseBuffer {
         this.caret += length;
         return text;
     }
-    hasMore() {
-        return this.caret < this.buffer.length;
-    }
-    readRawBinaryString(length) {
-        const text = this.buffer.toString('latin1', this.caret, this.caret + length);
-        this.caret += length;
-        return text;
-    }
-    readBinaryDate() {
-        const daysSince2000 = this.readInt32();
-        const ms = POSTGRES_EPOCH_MS + (daysSince2000 * 86400000);
-        return new Date(ms);
-    }
-    readBinaryTimestamp() {
-        const microSecondsSince2000 = this.readInt64();
-        const msSince2000 = Number(microSecondsSince2000 / 1000);
-        return new Date(POSTGRES_EPOCH_MS + msSince2000);
-    }
-    readBinaryTime() {
-        const microSecondsSinceMidnight = this.readInt64();
-        const totalMs = Number(microSecondsSinceMidnight / 1000);
-        const seconds = Math.floor(totalMs / 1000);
-        const ms = totalMs % 1000;
-        const minutes = Math.floor(seconds / 60);
-        const hours = Math.floor(minutes / 60);
-        return `${String(hours).padStart(2, '0')}:${String(minutes % 60).padStart(2, '0')}:${String(seconds % 60).padStart(2, '0')}.${String(ms).padStart(3, '0')}`;
-    }
-    skipBytes(byteCount) {
-        this.caret += byteCount;
-    }
-    hasFullPacket() {
-        const availableBytes = this.buffer.length - this.caret;
-        if (availableBytes < 5)
-            return false;
-        const packetLength = this.buffer.readInt32BE(this.caret + 1);
-        if (availableBytes < 1 + packetLength)
-            return false;
-        return true;
-    }
-    getResidualBuffer() {
-        return this.buffer.subarray(this.caret);
-    }
-    readBool() {
-        const value = this.buffer[this.caret] !== 0;
-        this.caret++;
+    readUInt16() {
+        const value = this.buffer.readUInt16BE(this.caret);
+        this.caret += 2;
         return value;
     }
-    readBigInt64() {
-        const value = this.buffer.readBigInt64BE(this.caret);
-        this.caret += 8;
+    readUInt32() {
+        const value = this.buffer.readUInt32BE(this.caret);
+        this.caret += 4;
         return value;
     }
-    readInt64() {
-        const hi = this.buffer.readInt32BE(this.caret);
-        const lo = this.buffer.readUInt32BE(this.caret + 4);
-        this.caret += 8;
-        return (hi * 4294967296) + lo;
-    }
-    readNumeric() {
-        const ndigits = this.readInt16();
-        const weight = this.readInt16();
-        const sign = this.readInt16();
-        const dscale = this.readInt16();
-        if (sign === 0xC000 || sign === -16384)
-            return 'NaN';
-        const digits = new Array(ndigits);
-        for (let i = 0; i < ndigits; i++) {
-            digits[i] = this.readInt16();
-        }
-        const highExp = Math.max(weight, 0);
-        const lowExp = Math.min(weight - ndigits + 1, -1);
-        let intPart = '';
-        for (let exp = highExp; exp >= 0; exp--) {
-            const idx = weight - exp;
-            const digit = (idx >= 0 && idx < ndigits) ? digits[idx] : 0;
-            intPart += exp === highExp ? String(digit) : String(digit).padStart(4, '0');
-        }
-        if (intPart === '')
-            intPart = '0';
-        let fracPart = '';
-        for (let exp = -1; exp >= lowExp; exp--) {
-            const idx = weight - exp;
-            const digit = (idx >= 0 && idx < ndigits) ? digits[idx] : 0;
-            fracPart += String(digit).padStart(4, '0');
-        }
-        if (dscale > 0) {
-            fracPart = fracPart.padEnd(dscale, '0').slice(0, dscale);
-        }
-        else {
-            fracPart = '';
-        }
-        const negative = sign === 0x4000 || sign === 16384;
-        const result = fracPart ? `${intPart}.${fracPart}` : intPart;
-        return negative ? `-${result}` : result;
-    }
-    readBinaryTimetz() {
-        const time = this.readBinaryTime();
-        const zoneOffsetSeconds = this.readInt32();
-        const offsetMinutesTotal = -zoneOffsetSeconds / 60;
-        const sign = offsetMinutesTotal >= 0 ? '+' : '-';
-        const abs = Math.abs(offsetMinutesTotal);
-        const offH = Math.floor(abs / 60);
-        const offM = abs % 60;
-        return `${time}${sign}${String(offH).padStart(2, '0')}:${String(offM).padStart(2, '0')}`;
-    }
     readFloat32() {
         const value = this.buffer.readFloatBE(this.caret);
         this.caret += 4;
@@ -151,13 +75,8 @@ export class ConnectionResponseBuffer {
         this.caret += 8;
         return value;
     }
-    readUuid() {
-        const buf = this.readBytes(16);
-        return buf.toString('hex', 0, 4) + '-' +
-            buf.toString('hex', 4, 6) + '-' +
-            buf.toString('hex', 6, 8) + '-' +
-            buf.toString('hex', 8, 10) + '-' +
-            buf.toString('hex', 10, 16);
+    readByte() {
+        return this.buffer[this.caret++];
     }
     readBytes(length) {
         const result = Buffer.allocUnsafe(length);
@@ -165,42 +84,42 @@ export class ConnectionResponseBuffer {
         this.caret += length;
         return result;
     }
-    getBufferHash(length) {
-        let hash = 2166136261;
-        const end = this.caret + length;
-        for (let i = this.caret; i < end; i++) {
-            hash ^= this.buffer[i];
-            hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
-        }
-        return hash >>> 0;
+    readBool() {
+        const value = this.buffer[this.caret] !== 0;
+        this.caret++;
+        return value;
     }
-}
-export class ConnectionResponseReader {
-    constructor(buffer) {
-        this.buffer = buffer;
+    readBigInt64() {
+        const value = this.buffer.readBigInt64BE(this.caret);
+        this.caret += 8;
+        return value;
     }
-    static from(buffer) {
-        return new ConnectionResponseReader(ConnectionResponseBuffer.from(buffer));
+    readInt64() {
+        const hi = this.buffer.readInt32BE(this.caret);
+        const lo = this.buffer.readUInt32BE(this.caret + 4);
+        this.caret += 8;
+        return (hi * 4294967296) + lo;
     }
+    // ------ commands ------
     readType() {
-        return { type: this.buffer.readChar(), length: this.buffer.readInt32() };
+        return { type: this.readByte(), length: this.readInt32() - INT4Length };
     }
     readAuthentication() {
-        return this.buffer.readInt32();
+        return this.readInt32();
     }
     readMD5Salt() {
-        return this.buffer.readBytes(4);
+        return this.readBytes(4);
     }
     readParameterStatus() {
         return {
-            name: this.buffer.readCString(),
-            value: this.buffer.readCString()
+            name: this.readCString(),
+            value: this.readCString()
         };
     }
     readBackendKeyData() {
         return {
-            PID: this.buffer.readInt32(),
-            secret: this.buffer.readInt32()
+            PID: this.readInt32(),
+            secret: this.readInt32()
         };
     }
     readErrorResponse() {
@@ -214,10 +133,10 @@ export class ConnectionResponseReader {
         let dataType = '';
         let constraint = '';
         while (true) {
-            const marker = this.buffer.readChar();
+            const marker = this.readChar();
             if (marker === '\0')
                 break;
-            const text = this.buffer.readCString();
+            const text = this.readCString();
             switch (marker) {
                 case 'S':
                     severity = text;
@@ -251,12 +170,12 @@ export class ConnectionResponseReader {
         return new PostgresError(message, code, detail, severity, where, hint, position, dataType, constraint);
     }
     readReadyForQuery() {
-        return this.buffer.readChar();
+        return this.readByte();
     }
     readSaslMechanisms() {
         const mechanisms = [];
         while (true) {
-            const mech = this.buffer.readCString();
+            const mech = this.readCString();
             if (mech === "")
                 break;
             mechanisms.push(mech);
@@ -264,181 +183,258 @@ export class ConnectionResponseReader {
         return mechanisms;
     }
     readSaslMessage(length) {
-        return this.buffer.readRawString(length - 4 - 4);
+        return this.readRawString(length - 4);
     }
     readRowDescription() {
-        const columnsCount = this.buffer.readInt16();
+        const columnsCount = this.readInt16();
         const columns = new Array(columnsCount);
         for (let i = 0; i < columnsCount; i++) {
-            const name = this.buffer.readCString();
-            this.buffer.readInt32();
-            this.buffer.readInt16();
+            const name = this.readCString();
+            this.readInt32();
+            this.readInt16();
             columns[i] = {
                 name: name,
-                typeOID: this.buffer.readInt32(),
+                typeOID: this.readInt32(),
             };
-            this.buffer.readInt32();
-            this.buffer.readInt32();
+            this.readInt32();
+            this.readInt32();
         }
         return columns;
     }
+    readNotificationResponse() {
+        this.readInt32();
+        const name = this.readCString();
+        const payload = this.readCString();
+        return { name, payload };
+    }
+    readCommandComplete() {
+        return this.readCString();
+    }
+    readParameterDescription() {
+        const count = this.readInt16();
+        const description = Array(count);
+        for (let i = 0; i < count; i++) {
+            description[i] = this.readInt32();
+        }
+        return description;
+    }
+    // ------ binary types parsers ------
+    readBinaryDate() {
+        const daysSince2000 = this.readInt32();
+        const ms = POSTGRES_EPOCH_MS + (daysSince2000 * 86400000);
+        return new Date(ms);
+    }
+    readBinaryTimestamp() {
+        const microSecondsSince2000 = this.readInt64();
+        const msSince2000 = Number(microSecondsSince2000 / 1000);
+        return new Date(POSTGRES_EPOCH_MS + msSince2000);
+    }
+    readBinaryTime() {
+        const microSecondsSinceMidnight = this.readInt64();
+        const totalMs = Number(microSecondsSinceMidnight / 1000);
+        const seconds = Math.floor(totalMs / 1000);
+        const ms = totalMs % 1000;
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        return `${String(hours).padStart(2, '0')}:${String(minutes % 60).padStart(2, '0')}:${String(seconds % 60).padStart(2, '0')}.${String(ms).padStart(3, '0')}`;
+    }
+    readBinaryTimetz() {
+        const time = this.readBinaryTime();
+        const zoneOffsetSeconds = this.readInt32();
+        const offsetMinutesTotal = -zoneOffsetSeconds / 60;
+        const sign = offsetMinutesTotal >= 0 ? '+' : '-';
+        const abs = Math.abs(offsetMinutesTotal);
+        const offH = Math.floor(abs / 60);
+        const offM = abs % 60;
+        return `${time}${sign}${String(offH).padStart(2, '0')}:${String(offM).padStart(2, '0')}`;
+    }
+    readBinaryNumeric() {
+        const ndigits = this.readInt16();
+        const weight = this.readInt16();
+        const sign = this.readInt16();
+        const dscale = this.readInt16();
+        if (sign === 0xC000 || sign === -16384)
+            return 'NaN';
+        const digits = new Array(ndigits);
+        for (let i = 0; i < ndigits; i++) {
+            digits[i] = this.readInt16();
+        }
+        const highExp = Math.max(weight, 0);
+        const lowExp = Math.min(weight - ndigits + 1, -1);
+        let intPart = '';
+        for (let exp = highExp; exp >= 0; exp--) {
+            const idx = weight - exp;
+            const digit = (idx >= 0 && idx < ndigits) ? digits[idx] : 0;
+            intPart += exp === highExp ? String(digit) : String(digit).padStart(4, '0');
+        }
+        if (intPart === '')
+            intPart = '0';
+        let fracPart = '';
+        for (let exp = -1; exp >= lowExp; exp--) {
+            const idx = weight - exp;
+            const digit = (idx >= 0 && idx < ndigits) ? digits[idx] : 0;
+            fracPart += String(digit).padStart(4, '0');
+        }
+        if (dscale > 0) {
+            fracPart = fracPart.padEnd(dscale, '0').slice(0, dscale);
+        }
+        else {
+            fracPart = '';
+        }
+        const negative = sign === 0x4000 || sign === 16384;
+        const result = fracPart ? `${intPart}.${fracPart}` : intPart;
+        return negative ? `-${result}` : result;
+    }
+    readBinaryInterval() {
+        const microseconds = this.readBigInt64();
+        const days = this.readInt32();
+        const months = this.readInt32();
+        return { months, days, microseconds };
+    }
+    readBinaryJson(fieldLength) {
+        return JSON.parse(this.readRawString(fieldLength));
+    }
+    readBinaryJsonb(fieldLength) {
+        this.skipBytes(1);
+        return JSON.parse(this.readRawString(fieldLength - 1));
+    }
+    readBinaryMacaddr() {
+        const bytes = this.readBytes(6);
+        return Array.from(bytes)
+            .map(b => b.toString(16).padStart(2, '0'))
+            .join(':');
+    }
+    readBinaryOid() {
+        return this.readUInt32();
+    }
+    readBinaryXid() {
+        return this.readUInt32();
+    }
+    readBinaryCid() {
+        return this.readUInt32();
+    }
+    readBinaryRegproc() {
+        return this.readUInt32();
+    }
+    readBinaryLseg() {
+        return {
+            a: this.readBinaryPoint(),
+            b: this.readBinaryPoint(),
+        };
+    }
+    readBinaryPath() {
+        const closed = this.readByte() !== 0;
+        const npoints = this.readInt32();
+        const points = new Array(npoints);
+        for (let i = 0; i < npoints; i++) {
+            points[i] = this.readBinaryPoint();
+        }
+        return { closed, points };
+    }
+    readBinaryBox() {
+        return {
+            high: this.readBinaryPoint(),
+            low: this.readBinaryPoint(),
+        };
+    }
+    readBinaryPolygon() {
+        const npoints = this.readInt32();
+        const points = new Array(npoints);
+        for (let i = 0; i < npoints; i++) {
+            points[i] = this.readBinaryPoint();
+        }
+        return { points };
+    }
+    readBinaryLine() {
+        return {
+            a: this.readFloat64(),
+            b: this.readFloat64(),
+            c: this.readFloat64(),
+        };
+    }
+    readBinaryUuid() {
+        const buf = this.readBytes(16);
+        return buf.toString('hex', 0, 4) + '-' +
+            buf.toString('hex', 4, 6) + '-' +
+            buf.toString('hex', 6, 8) + '-' +
+            buf.toString('hex', 8, 10) + '-' +
+            buf.toString('hex', 10, 16);
+    }
+    readBinaryArray(fieldLength, elementParser) {
+        if (fieldLength === 0)
+            return [];
+        const ndims = this.readInt32();
+        const hasNull = this.readInt32();
+        const elementOid = this.readInt32();
+        if (ndims === 0)
+            return [];
+        if (ndims > 1) {
+            for (let d = 1; d < ndims; d++) {
+                this.readInt32();
+                this.readInt32();
+            }
+        }
+        const dimLength = this.readInt32();
+        const lbound = this.readInt32();
+        const result = new Array(dimLength);
+        for (let i = 0; i < dimLength; i++) {
+            const itemLength = this.readInt32();
+            if (itemLength === -1) {
+                result[i] = null;
+            }
+            else {
+                result[i] = elementParser(itemLength);
+            }
+        }
+        return result;
+    }
+    readBinaryInet(fieldLength) {
+        const family = this.readByte();
+        const bits = this.readByte();
+        const isCidr = this.readByte();
+        const nb = this.readByte();
+        if (nb === 4) {
+            const b1 = this.readByte();
+            const b2 = this.readByte();
+            const b3 = this.readByte();
+            const b4 = this.readByte();
+            return `${b1}.${b2}.${b3}.${b4}`;
+        }
+        else if (nb === 16) {
+            const parts = [];
+            for (let i = 0; i < 8; i++) {
+                parts.push(this.readUInt16().toString(16));
+            }
+            return parts.join(':');
+        }
+        this.skipBytes(fieldLength - 4);
+        return '';
+    }
+    readBinaryPoint() {
+        return {
+            x: this.readFloat64(),
+            y: this.readFloat64()
+        };
+    }
     readDataRow(descriptions, int8toBigint) {
-        const fieldsCount = this.buffer.readInt16();
+        const fieldsCount = this.readInt16();
         const row = {};
         for (let i = 0; i < fieldsCount; i++) {
-            const fieldLength = this.buffer.readInt32();
+            const fieldLength = this.readInt32();
             const desc = descriptions[i];
             const key = desc.name;
             if (fieldLength === -1) {
                 row[key] = null;
                 continue;
             }
-            const oid = desc.typeOID;
-            switch (oid) {
-                case DataTypeOids.Text:
-                case DataTypeOids.Varchar:
-                case DataTypeOids.Char:
-                case DataTypeOids.Bpchar:
-                    {
-                        if (fieldLength <= 32) {
-                            let cacheForColumn = columnValueCache.get(i);
-                            if (!cacheForColumn) {
-                                cacheForColumn = new Map();
-                                columnValueCache.set(i, cacheForColumn);
-                            }
-                            const byteHash = this.buffer.getBufferHash(fieldLength);
-                            let cachedString = cacheForColumn.get(byteHash);
-                            if (cachedString === undefined) {
-                                cachedString = this.buffer.readRawString(fieldLength);
-                                if (cacheForColumn.size < 512) {
-                                    cacheForColumn.set(byteHash, cachedString);
-                                }
-                            }
-                            else {
-                                this.buffer.skipBytes(fieldLength);
-                            }
-                            row[key] = cachedString;
-                        }
-                        else {
-                            row[key] = this.buffer.readRawString(fieldLength);
-                        }
-                    }
-                    break;
-                case DataTypeOids.Int2:
-                    {
-                        row[key] = this.buffer.readInt16();
-                    }
-                    break;
-                case DataTypeOids.Int4:
-                    {
-                        row[key] = this.buffer.readInt32();
-                    }
-                    break;
-                case DataTypeOids.Int8:
-                    {
-                        row[key] = int8toBigint ? this.buffer.readBigInt64() : this.buffer.readInt64();
-                    }
-                    break;
-                case DataTypeOids.Float4:
-                    {
-                        row[key] = this.buffer.readFloat32();
-                    }
-                    break;
-                case DataTypeOids.Float8:
-                    {
-                        row[key] = this.buffer.readFloat64();
-                    }
-                    break;
-                case DataTypeOids.Bool:
-                    {
-                        row[key] = this.buffer.readBool();
-                    }
-                    break;
-                case DataTypeOids.Bytea:
-                    {
-                        row[key] = this.buffer.readBytes(fieldLength);
-                    }
-                    break;
-                case DataTypeOids.Jsonb:
-                    {
-                        this.buffer.skipBytes(1);
-                        row[key] = JSON.parse(this.buffer.readRawString(fieldLength - 1));
-                    }
-                    break;
-                case DataTypeOids.Json:
-                    {
-                        row[key] = JSON.parse(this.buffer.readRawString(fieldLength));
-                    }
-                    break;
-                case DataTypeOids.Date:
-                    {
-                        row[key] = this.buffer.readBinaryDate();
-                    }
-                    break;
-                case DataTypeOids.Timestamp:
-                case DataTypeOids.Timestamptz:
-                    {
-                        row[key] = this.buffer.readBinaryTimestamp();
-                    }
-                    break;
-                case DataTypeOids.Uuid:
-                    {
-                        row[key] = this.buffer.readUuid();
-                    }
-                    break;
-                case DataTypeOids.Time:
-                    {
-                        row[key] = this.buffer.readBinaryTime();
-                    }
-                    break;
-                case DataTypeOids.Timetz:
-                    {
-                        row[key] = this.buffer.readBinaryTimetz();
-                    }
-                    break;
-                case DataTypeOids.Numeric:
-                    {
-                        row[key] = this.buffer.readNumeric();
-                    }
-                    break;
-                default:
-                    {
-                        this.buffer.skipBytes(fieldLength);
-                        row[key] = null;
-                    }
-                    break;
+            const handler = handlers[desc.typeOID];
+            if (!handler) {
+                this.skipBytes(fieldLength);
+                row[key] = undefined;
+                continue;
             }
+            row[key] = handler.read(this, fieldLength, int8toBigint);
         }
         return row;
     }
-    readNotificationResponse() {
-        this.buffer.readInt32();
-        const name = this.buffer.readCString();
-        const payload = this.buffer.readCString();
-        return { name, payload };
-    }
-    readCommandComplete() {
-        return this.buffer.readCString();
-    }
-    hasMore() {
-        return this.buffer.hasMore();
-    }
-    hasFullPacket() {
-        return this.buffer.hasFullPacket();
-    }
-    getResidualBuffer() {
-        return this.buffer.getResidualBuffer();
-    }
-    readParseComplete() { }
-    readBindComplete() { }
-    readParameterDescription() {
-        const count = this.buffer.readInt16();
-        for (let i = 0; i < count; i++) {
-            this.buffer.readInt32();
-        }
-    }
-    readNoData() { }
-    skip(count) {
-        this.buffer.skipBytes(count);
-    }
 }