@m2k-5f/pgtx 2.7.3 → 2.8.0

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

@@ -1,6 +1,6 @@
-import { DataTypeOids, INT4Length } 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,109 +55,16 @@ export class ConnectionResponseBuffer {
         this.caret += length;
         return text;
     }
-    hasMore() {
-        return this.caret < this.buffer.length;
-    }
-    readBinaryDate() {
-        const daysSince2000 = this.readInt32();
-        const ms = POSTGRES_EPOCH_MS + (daysSince2000 * 86400000);
-        return new Date(ms);
-    }
-    readByte() {
-        return this.buffer[this.caret++];
-    }
-    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;
@@ -149,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);
@@ -163,15 +84,23 @@ 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;
     }
+    readBigInt64() {
+        const value = this.buffer.readBigInt64BE(this.caret);
+        this.caret += 8;
+        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;
+    }
+    // ------ commands ------
     readType() {
         return { type: this.readByte(), length: this.readInt32() - INT4Length };
     }
@@ -272,136 +201,6 @@ export class ConnectionResponseBuffer {
         }
         return columns;
     }
-    readDataRow(descriptions, int8toBigint) {
-        const fieldsCount = this.readInt16();
-        const row = {};
-        for (let i = 0; i < fieldsCount; i++) {
-            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.getBufferHash(fieldLength);
-                            let cachedString = cacheForColumn.get(byteHash);
-                            if (cachedString === undefined) {
-                                cachedString = this.readRawString(fieldLength);
-                                if (cacheForColumn.size > 512) {
-                                    cacheForColumn.clear();
-                                }
-                                cacheForColumn.set(byteHash, cachedString);
-                            }
-                            else {
-                                this.skipBytes(fieldLength);
-                            }
-                            row[key] = cachedString;
-                        }
-                        else {
-                            row[key] = this.readRawString(fieldLength);
-                        }
-                    }
-                    break;
-                case DataTypeOids.Int2:
-                    {
-                        row[key] = this.readInt16();
-                    }
-                    break;
-                case DataTypeOids.Int4:
-                    {
-                        row[key] = this.readInt32();
-                    }
-                    break;
-                case DataTypeOids.Int8:
-                    {
-                        row[key] = int8toBigint ? this.readBigInt64() : this.readInt64();
-                    }
-                    break;
-                case DataTypeOids.Float4:
-                    {
-                        row[key] = this.readFloat32();
-                    }
-                    break;
-                case DataTypeOids.Float8:
-                    {
-                        row[key] = this.readFloat64();
-                    }
-                    break;
-                case DataTypeOids.Bool:
-                    {
-                        row[key] = this.readBool();
-                    }
-                    break;
-                case DataTypeOids.Bytea:
-                    {
-                        row[key] = this.readBytes(fieldLength);
-                    }
-                    break;
-                case DataTypeOids.Jsonb:
-                    {
-                        this.skipBytes(1);
-                        row[key] = JSON.parse(this.readRawString(fieldLength - 1));
-                    }
-                    break;
-                case DataTypeOids.Json:
-                    {
-                        row[key] = JSON.parse(this.readRawString(fieldLength));
-                    }
-                    break;
-                case DataTypeOids.Date:
-                    {
-                        row[key] = this.readBinaryDate();
-                    }
-                    break;
-                case DataTypeOids.Timestamp:
-                case DataTypeOids.Timestamptz:
-                    {
-                        row[key] = this.readBinaryTimestamp();
-                    }
-                    break;
-                case DataTypeOids.Uuid:
-                    {
-                        row[key] = this.readUuid();
-                    }
-                    break;
-                case DataTypeOids.Time:
-                    {
-                        row[key] = this.readBinaryTime();
-                    }
-                    break;
-                case DataTypeOids.Timetz:
-                    {
-                        row[key] = this.readBinaryTimetz();
-                    }
-                    break;
-                case DataTypeOids.Numeric:
-                    {
-                        row[key] = this.readNumeric();
-                    }
-                    break;
-                default:
-                    {
-                        this.skipBytes(fieldLength);
-                        row[key] = null;
-                    }
-                    break;
-            }
-        }
-        return row;
-    }
     readNotificationResponse() {
         this.readInt32();
         const name = this.readCString();
@@ -419,4 +218,223 @@ export class ConnectionResponseBuffer {
         }
         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.readInt16();
+        const row = {};
+        for (let i = 0; i < fieldsCount; i++) {
+            const fieldLength = this.readInt32();
+            const desc = descriptions[i];
+            const key = desc.name;
+            if (fieldLength === -1) {
+                row[key] = null;
+                continue;
+            }
+            const handler = handlers[desc.typeOID];
+            if (!handler) {
+                this.skipBytes(fieldLength);
+                row[key] = undefined;
+                continue;
+            }
+            row[key] = handler.read(this, fieldLength, int8toBigint);
+        }
+        return row;
+    }
 }

package/dist/protocol/constants.js

@@ -29,16 +29,16 @@ export const ResponseTypes = {
     SSLDenied: 78 // "N"
 };
 export const DataTypeOids = {
-    Bool: 16,
+    Bool: 16, // parameter
     Bytea: 17,
-    Char: 18,
+    Char: 18, // parameter
     Name: 19,
-    Text: 25,
-    Varchar: 1043,
-    Bpchar: 1042,
-    Int2: 21,
-    Int4: 23,
-    Int8: 20,
+    Text: 25, // parameter
+    Varchar: 1043, // parameter
+    Bpchar: 1042, // parameter
+    Int2: 21, // parameter
+    Int4: 23, // parameter
+    Int8: 20, // parameter
     Float4: 700,
     Float8: 701,
     Numeric: 1700,

package/dist/protocol/types.d.ts

@@ -0,0 +1,14 @@
+import { ConnectionRequestBuffer } from "./connection-request-writer";
+import { ConnectionResponseBuffer } from "./connection-response-reader";
+import { DataTypeOid } from "./constants";
+type BindValidator = (value: unknown) => boolean;
+type BindWriter = (request: ConnectionRequestBuffer, value: any) => void;
+type FieldReader = (response: ConnectionResponseBuffer, fieldLength: number, int8toBigint: boolean) => unknown;
+interface BindHandler {
+    validate: BindValidator;
+    write: BindWriter;
+    read: FieldReader;
+}
+export declare const handlers: Partial<Record<DataTypeOid, BindHandler>>;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/protocol/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/protocol/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AACrE,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAA;AACvE,OAAO,EAAE,WAAW,EAAgB,MAAM,aAAa,CAAA;AAEvD,KAAK,aAAa,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAA;AAChD,KAAK,UAAU,GAAG,CAAC,OAAO,EAAE,uBAAuB,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI,CAAA;AACxE,KAAK,WAAW,GAAG,CACf,QAAQ,EAAE,wBAAwB,EAClC,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,OAAO,KACpB,OAAO,CAAA;AAEZ,UAAU,WAAW;IACjB,QAAQ,EAAE,aAAa,CAAA;IACvB,KAAK,EAAE,UAAU,CAAA;IACjB,IAAI,EAAE,WAAW,CAAA;CACpB;AASD,eAAO,MAAM,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,WAAW,CAAC,CAsY9D,CAAA"}