postgrejs 2.23.0 → 3.0.1

package/connection/prepared-statement.js

@@ -3,9 +3,8 @@ import { DEFAULT_COLUMN_FORMAT } from '../constants.js';
 import { GlobalTypeMap } from '../data-type-map.js';
 import { Protocol } from '../protocol/protocol.js';
 import { SafeEventEmitter } from '../safe-event-emitter.js';
-import { convertRowToObject } from '../util/convert-row-to-object.js';
+import { withAbortSignal } from '../util/abort-signal.js';
 import { getParsers } from '../util/get-parsers.js';
-import { parseRow } from '../util/parse-row.js';
 import { wrapRowDescription } from '../util/wrap-row-description.js';
 import { Cursor } from './cursor.js';
 import { getIntlConnection } from './intl-connection.js';
@@ -17,8 +16,10 @@ export class PreparedStatement extends SafeEventEmitter {
     _sql = '';
     _name = '';
     _paramTypes;
+    _fields;
     _onErrorSavePoint;
     _refCount = 0;
+    _closed = false;
     constructor(connection, sql, paramTypes) {
         super();
         this._connection = connection;
@@ -30,39 +31,9 @@ export class PreparedStatement extends SafeEventEmitter {
     static async prepare(connection, sql, options) {
         const intoCon = getIntlConnection(connection);
         intoCon.assertConnected();
-        const socket = intoCon.socket;
         const statement = new PreparedStatement(connection, sql, options?.paramTypes);
-        await intoCon.statementQueue
-            .enqueue(async () => {
-            intoCon.ref();
-            try {
-                socket.sendParseMessage({
-                    statement: statement.name,
-                    sql: statement.sql,
-                    paramTypes: statement.paramTypes,
-                });
-                socket.sendFlushMessage();
-                try {
-                    await socket.capture(async (code, msg, done) => {
-                        if (code === Protocol.BackendMessageCode.ParseComplete)
-                            done();
-                        // May be Protocol.BackendMessageCode.NoticeResponse
-                    });
-                }
-                finally {
-                    socket.sendSyncMessage();
-                    await socket.capture(async (code, msg, done) => {
-                        if (code === Protocol.BackendMessageCode.ReadyForQuery)
-                            done();
-                        // May be Protocol.BackendMessageCode.NoticeResponse
-                    });
-                }
-            }
-            finally {
-                intoCon.unref();
-            }
-        })
-            .toPromise();
+        const { fields } = await intoCon.prepareOnce(sql, statement.paramTypes, statement.name);
+        statement._fields = fields;
         statement._refCount = 1;
         return statement;
     }
@@ -79,6 +50,12 @@ export class PreparedStatement extends SafeEventEmitter {
         return this._paramTypes;
     }
     async execute(options = {}) {
+        const intlCon = getIntlConnection(this.connection);
+        if (options.signal)
+            return withAbortSignal(options.signal, () => intlCon.cancel(), () => this._executeWithTransaction(options));
+        return this._executeWithTransaction(options);
+    }
+    async _executeWithTransaction(options = {}) {
         const intlCon = getIntlConnection(this.connection);
         const transactionCommand = this.sql.match(/^(\bBEGIN\b|\bCOMMIT\b|\bSTART\b|\bROLLBACK|SAVEPOINT|RELEASE\b)/i);
         let beginFirst = false;
@@ -102,9 +79,7 @@ export class PreparedStatement extends SafeEventEmitter {
         if (intlCon.inTransaction && rollbackOnError)
             await intlCon.execute('SAVEPOINT ' + this._onErrorSavePoint);
         try {
-            const result = await intlCon.statementQueue
-                .enqueue(() => this._execute(options))
-                .toPromise();
+            const result = await this._execute(options);
             if (commitLast)
                 await intlCon.execute('COMMIT');
             else if (intlCon.inTransaction && rollbackOnError) {
@@ -120,99 +95,144 @@ export class PreparedStatement extends SafeEventEmitter {
         }
     }
     async close() {
+        if (this._closed)
+            return;
         --this._refCount;
         if (this._refCount > 0)
             return;
-        const intoCon = getIntlConnection(this.connection);
-        await intoCon.statementQueue.enqueue(() => this._close()).toPromise();
+        this._closed = true;
+        await this._close();
     }
+    /**
+     * Asks the server to cancel whatever this statement's connection is
+     * currently running. See Connection.cancel(); prefer the per-call `signal`
+     * option, which reports the abort to the caller that asked for it.
+     */
     async cancel() {
-        throw new Error('Not implemented yet');
+        return getIntlConnection(this.connection).cancel();
     }
     async _execute(options = {}) {
-        let portal;
         const intlCon = getIntlConnection(this.connection);
-        intlCon.ref();
-        try {
-            const result = { command: undefined };
-            const startTime = Date.now();
-            const t = Date.now();
-            // Create portal
-            const portalName = 'P_' + ++portalCounter;
-            portal = new Portal(this, portalName);
-            await portal.bind(options.params, options);
-            const fields = await portal.retrieveFields();
-            const typeMap = options.typeMap || GlobalTypeMap;
-            let parsers;
-            let resultFields;
-            if (fields) {
-                parsers = getParsers(typeMap, fields);
-                resultFields = wrapRowDescription(typeMap, fields, options.columnFormat || DEFAULT_COLUMN_FORMAT);
-                result.fields = resultFields;
-                result.rowType = options.objectRows ? 'object' : 'array';
-                if (options.cursor) {
-                    result.cursor = new Cursor(this, portal, resultFields, parsers, options);
-                    this._refCount++;
-                    portal = undefined;
-                    return result;
-                }
-            }
-            const executeResult = await portal.execute(options.fetchCount);
-            result.executeTime = Date.now() - t;
-            if (executeResult.command)
-                result.command = executeResult.command;
-            if (resultFields && parsers && executeResult.rows) {
-                if (!result.command)
-                    result.command = 'SELECT';
-                const rows = (result.rows = executeResult.rows);
-                const l = rows.length;
-                let row;
-                for (let i = 0; i < l; i++) {
-                    row = rows[i];
-                    parseRow(parsers, row, options);
-                    if (options.objectRows) {
-                        rows[i] = convertRowToObject(resultFields, row);
-                    }
-                }
+        if (options.cursor && this._fields) {
+            intlCon.ref();
+            let portal = new Portal(this, 'P_' + ++portalCounter);
+            try {
+                const fields = await portal.bindAndRetrieveFields(options.params, options);
+                const typeMap = options.typeMap || GlobalTypeMap;
+                const parsers = getParsers(typeMap, fields);
+                const resultFields = wrapRowDescription(typeMap, fields, options.columnFormat || DEFAULT_COLUMN_FORMAT);
+                const result = {
+                    command: undefined,
+                    fields: resultFields,
+                    rowType: options.objectRows ? 'object' : 'array',
+                    cursor: new Cursor(this, portal, resultFields, parsers, options),
+                };
+                this._refCount++;
+                portal = undefined;
+                return result;
             }
-            if (result.command === 'DELETE' ||
-                result.command === 'INSERT' ||
-                result.command === 'UPDATE') {
-                result.rowsAffected = executeResult.rowCount;
+            finally {
+                intlCon.unref();
+                if (portal)
+                    await portal.close().catch(() => undefined);
             }
-            result.executeTime = Date.now() - startTime;
-            return result;
+        }
+        // Non-cursor path: Bind+Execute+Sync as a single round trip against an
+        // unnamed portal, reusing the RowDescription prepare() already fetched
+        // instead of re-Describing (and re-Close-ing) a fresh named portal on
+        // every call.
+        return intlCon.executeReused(this.name, this._fields, this.paramTypes, options.params, options);
+    }
+    /**
+     * Called by Cursor.close() instead of separately awaiting
+     * Portal.close() then this.close(). Returns false (no wire action taken,
+     * caller must still close just the portal itself) when either this
+     * statement was already fully closed by someone else (mirrors close()'s
+     * own `if (this._closed) return;` idempotency guard - re-sending
+     * Close(statement) for an already-closed name would error) or the
+     * decremented refcount is still > 0 (statement still referenced
+     * elsewhere - e.g. another cursor from the same PreparedStatement, or
+     * the statement's own +1 from prepare()). Returns true only when it
+     * actually performed the combined Close(portal)+Close(statement)+Sync.
+     */
+    async _maybeCloseWithPortal(portalName) {
+        if (this._closed)
+            return false;
+        --this._refCount;
+        if (this._refCount > 0)
+            return false;
+        this._closed = true;
+        const intoCon = getIntlConnection(this.connection);
+        intoCon.ref();
+        try {
+            const socket = intoCon.socket;
+            let error;
+            await socket.sendClosePortalAndStatementMessages({
+                portal: { type: 'P', name: portalName },
+                statement: { type: 'S', name: this.name },
+            }, (code, msg, done) => {
+                switch (code) {
+                    case Protocol.BackendMessageCode.NoticeResponse:
+                        this.emit('notice', msg);
+                        break;
+                    case Protocol.BackendMessageCode.CloseComplete:
+                        // Arrives twice (once per Close) - neither call is terminal.
+                        break;
+                    case Protocol.BackendMessageCode.ErrorResponse:
+                        error = msg;
+                        break;
+                    case Protocol.BackendMessageCode.ReadyForQuery:
+                        intoCon.transactionStatus = msg.status;
+                        done(error);
+                        break;
+                    default:
+                        done(new Error(`Server returned unexpected response message (0x${code.toString(16)})`));
+                }
+            });
         }
         finally {
-            intlCon.unref();
-            if (portal)
-                await portal.close();
+            intoCon.unref();
         }
+        this.emit('close');
+        return true;
     }
     async _close() {
-        if (--this._refCount > 0)
-            return;
         const intoCon = getIntlConnection(this.connection);
         intoCon.ref();
         try {
             const socket = intoCon.socket;
-            socket.sendCloseMessage({ type: 'S', name: this.name });
-            socket.sendSyncMessage();
-            await socket.capture(async (code, msg, done) => {
+            const closePromise = socket.sendCloseMessage({ type: 'S', name: this.name }, (code, msg, done) => {
                 switch (code) {
                     case Protocol.BackendMessageCode.NoticeResponse:
                         this.emit('notice', msg);
                         break;
                     case Protocol.BackendMessageCode.CloseComplete:
+                        done();
+                        break;
+                    case Protocol.BackendMessageCode.ErrorResponse:
+                        done(msg);
+                        break;
+                    default:
+                        done(new Error(`Server returned unexpected response message (0x${code.toString(16)})`));
+                }
+            });
+            const syncPromise = socket.sendSyncMessage((code, msg, done) => {
+                switch (code) {
+                    case Protocol.BackendMessageCode.NoticeResponse:
+                        this.emit('notice', msg);
                         break;
                     case Protocol.BackendMessageCode.ReadyForQuery:
                         intoCon.transactionStatus = msg.status;
                         done();
                         break;
+                    case Protocol.BackendMessageCode.ErrorResponse:
+                        done(msg);
+                        break;
                     default:
                         done(new Error(`Server returned unexpected response message (0x${code.toString(16)})`));
                 }
             });
+            await Promise.all([closePromise, syncPromise]);
         }
         finally {
             intoCon.unref();

package/data-type-map.d.ts

@@ -1,5 +1,5 @@
-import { DataType } from './interfaces/data-type.js';
-import { OID } from './types.js';
+import type { DataType } from './interfaces/data-type.js';
+import type { OID } from './types.js';
 export declare class DataTypeMap {
     private _itemsByOID;
     private _items;

package/data-type-map.js

@@ -15,7 +15,8 @@ import { ArrayJsonType, JsonType } from './data-types/json-type.js';
 import { ArrayJsonbType, JsonbType } from './data-types/jsonb-type.js';
 import { ArrayLsegType, LsegType } from './data-types/lseg-type.js';
 import { ArrayNumericType, NumericType } from './data-types/numeric-type.js';
-import { ArrayOidType, OidType, VectorOidType } from './data-types/oid-type.js';
+import { ArrayOidType, OidType } from './data-types/oid-type.js';
+import { ArrayOidVectorType, OidVectorType, } from './data-types/oid-vector-type.js';
 import { ArrayPointType, PointType } from './data-types/point-type.js';
 import { ArrayTimeType, TimeType } from './data-types/time-type.js';
 import { ArrayTimestampType, TimestampType, } from './data-types/timestamp-type.js';
@@ -62,7 +63,8 @@ export class DataTypeMap {
     }
 }
 export const GlobalTypeMap = new DataTypeMap();
-GlobalTypeMap.register([OidType, VectorOidType, ArrayOidType]);
+GlobalTypeMap.register([OidType, ArrayOidType]);
+GlobalTypeMap.register([OidVectorType, ArrayOidVectorType]);
 GlobalTypeMap.register([JsonbType, ArrayJsonbType]);
 GlobalTypeMap.register([JsonType, ArrayJsonType]);
 GlobalTypeMap.register([BoolType, ArrayBoolType]);

package/data-types/bool-type.js

@@ -3,20 +3,24 @@ export const BoolType = {
     name: 'bool',
     oid: DataTypeOIDs.bool,
     jsType: 'boolean',
-    parseBinary(v) {
-        return !!v.readUInt8();
+    fixedBinarySize: 1,
+    // 't'/'f', the form decodeText above reads and the server itself
+    // emits - encodeText and decodeText are a public pair and have to stay
+    // each other's inverse.
+    encodeText(v) {
+        return v ? 't' : 'f';
     },
     encodeBinary(buf, v) {
         buf.writeInt8(v ? 1 : 0);
     },
-    parseText(v) {
-        return (v === 'TRUE' ||
-            v === 't' ||
-            v === 'true' ||
-            v === 'y' ||
-            v === 'yes' ||
-            v === 'on' ||
-            v === '1');
+    decodeBinary(v, offset = 0) {
+        return !!v.readUInt8(offset);
+    },
+    decodeText(v) {
+        return v === 't';
+    },
+    decodeTextBuffer(buf, offset) {
+        return buf[offset] === 0x74; /* 't' */
     },
     isType(v) {
         return typeof v === 'boolean';

package/data-types/box-type.js

@@ -7,13 +7,9 @@ export const BoxType = {
     oid: DataTypeOIDs.box,
     jsType: 'object',
     arraySeparator: ';',
-    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 BoxType = {
         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(BOX_PATTERN1) || v.match(BOX_PATTERN2) || v.match(BOX_PATTERN3);
         if (!m)
             return undefined;
@@ -32,6 +36,9 @@ export const BoxType = {
             y2: parseFloat(m[4]),
         };
     },
+    decodeTextBuffer(buf, offset, len, options) {
+        return BoxType.decodeText(buf.toString('latin1', offset, offset + len), options);
+    },
     isType(v) {
         return (typeof v === 'object' &&
             Object.keys(v).length === 4 &&

package/data-types/bytea-type.js

@@ -1,17 +1,21 @@
-// @ts-ignore -- no type definitions for decodeBytea
-import decodeBytea from 'postgres-bytea';
 import { DataTypeOIDs } from '../constants.js';
+import { parseBytea, parseByteaBuffer } from '../util/parse-bytea.js';
 export const ByteaType = {
     name: 'bytea',
     oid: DataTypeOIDs.bytea,
     jsType: 'Buffer',
-    parseBinary(v) {
-        return v;
+    // The hex form PostgreSQL has emitted by default since 9.0.
+    encodeText(v) {
+        return '\\x' + v.toString('hex');
     },
     encodeBinary(buf, v) {
         buf.writeBuffer(v);
     },
-    parseText: decodeBytea,
+    decodeBinary(v, offset = 0) {
+        return offset ? v.subarray(offset) : v;
+    },
+    decodeText: parseBytea,
+    decodeTextBuffer: parseByteaBuffer,
     isType(v) {
         return v instanceof Buffer;
     },

package/data-types/char-type.js

@@ -3,17 +3,23 @@ export const CharType = {
     name: 'char',
     oid: DataTypeOIDs.char,
     jsType: 'string',
-    parseBinary(v) {
-        return v.toString('utf8');
+    encodeText(v) {
+        return '' + v;
     },
     encodeBinary(buf, v) {
         buf.writeString((v ? '' + v : ' ')[0], 'utf8');
     },
-    parseText(v) {
-        return '' + v;
+    decodeBinary(v, offset = 0) {
+        return v.toString('utf8', offset);
+    },
+    decodeText(v) {
+        return v;
+    },
+    decodeTextBuffer(buf, offset, len) {
+        return buf.toString('utf8', offset, offset + len);
     },
     isType(v) {
-        return typeof v === 'string' && v.length === 1;
+        return typeof v === 'string' && Buffer.byteLength(v, 'utf8') === 1;
     },
 };
 export const ArrayCharType = {

package/data-types/circle-type.js

@@ -7,19 +7,23 @@ export const CircleType = {
     name: 'circle',
     oid: DataTypeOIDs.circle,
     jsType: 'object',
-    parseBinary(v) {
-        return {
-            x: v.readDoubleBE(0),
-            y: v.readDoubleBE(8),
-            r: v.readDoubleBE(16),
-        };
+    fixedBinarySize: 24,
+    encodeText(v) {
+        return `<(${v.x},${v.y}),${v.r}>`;
     },
     encodeBinary(buf, v) {
         buf.writeDoubleBE(v.x);
         buf.writeDoubleBE(v.y);
         buf.writeDoubleBE(v.r);
     },
-    parseText(v) {
+    decodeBinary(v, offset = 0) {
+        return {
+            x: v.readDoubleBE(offset),
+            y: v.readDoubleBE(offset + 8),
+            r: v.readDoubleBE(offset + 16),
+        };
+    },
+    decodeText(v) {
         const m = v.match(CIRCLE_PATTERN1) ||
             v.match(CIRCLE_PATTERN2) ||
             v.match(CIRCLE_PATTERN3) ||
@@ -32,6 +36,10 @@ export const CircleType = {
             r: parseFloat(m[3]),
         };
     },
+    // See box-type.ts's decodeTextBuffer comment - same rationale.
+    decodeTextBuffer(buf, offset, len, options) {
+        return CircleType.decodeText(buf.toString('latin1', offset, offset + len), options);
+    },
     isType(v) {
         return (typeof v === 'object' &&
             Object.keys(v).length === 3 &&

package/data-types/date-type.js

@@ -1,27 +1,18 @@
 import { DataTypeOIDs } from '../constants.js';
-import { parseDateTime } from '../util/parse-datetime.js';
+import { formatDate } from '../util/format-datetime.js';
+import { parseDate } from '../util/parse-datetime.js';
 const timeShift = 946684800000;
 export const DateType = {
     name: 'date',
     oid: DataTypeOIDs.date,
     jsType: 'Date',
-    parseBinary(v, options) {
-        const fetchAsString = options.fetchAsString &&
-            options.fetchAsString.includes(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;
+    fixedBinarySize: 4,
+    encodeText(v, options) {
+        return formatDate(v, options);
     },
     encodeBinary(buf, v, options) {
         if (typeof v === 'string')
-            v = parseDateTime(v, false, false, options.utcDates);
+            v = parseDate(v, options.utcDates);
         if (v === Infinity) {
             buf.writeInt32BE(0x7fffffff);
             return;
@@ -39,12 +30,27 @@ export const DateType = {
         const t = Math.trunc(n + Number.EPSILON);
         buf.writeInt32BE(t);
     },
-    parseText(v, options) {
-        const fetchAsString = options.fetchAsString &&
-            options.fetchAsString.includes(DataTypeOIDs.date);
+    decodeBinary(v, offset = 0, options) {
+        const fetchAsString = options.fetchAsString?.includes(DataTypeOIDs.date);
+        const t = v.readInt32BE(offset);
+        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;
+    },
+    decodeText(v, options) {
+        const fetchAsString = options.fetchAsString?.includes(DataTypeOIDs.date);
         if (fetchAsString)
             return v;
-        return parseDateTime(v, false, false, options.utcDates);
+        return parseDate(v, options.utcDates);
+    },
+    decodeTextBuffer(buf, offset, len, options) {
+        return DateType.decodeText(buf.toString('latin1', offset, offset + len), options);
     },
     isType(v) {
         return (v instanceof Date &&

package/data-types/float4-type.js

@@ -3,13 +3,20 @@ export const Float4Type = {
     name: 'float4',
     oid: DataTypeOIDs.float4,
     jsType: 'number',
-    parseBinary(v) {
-        return Math.round((v.readFloatBE(0) + Number.EPSILON) * 100) / 100;
+    fixedBinarySize: 4,
+    encodeText(v) {
+        return '' + v;
     },
     encodeBinary(buf, v) {
         buf.writeFloatBE(typeof v === 'number' ? v : parseFloat(v));
     },
-    parseText: parseFloat,
+    decodeBinary(v, offset = 0) {
+        return v.readFloatBE(offset);
+    },
+    decodeText: parseFloat,
+    decodeTextBuffer(buf, offset, len) {
+        return parseFloat(buf.toString('latin1', offset, offset + len));
+    },
     isType(v) {
         return typeof v === 'number';
     },

package/data-types/float8-type.js

@@ -3,13 +3,22 @@ export const Float8Type = {
     name: 'float8',
     oid: DataTypeOIDs.float8,
     jsType: 'number',
-    parseBinary(v) {
-        return v.readDoubleBE(0);
+    fixedBinarySize: 8,
+    // Infinity/NaN stringify to the words PostgreSQL itself uses.
+    encodeText(v) {
+        return '' + v;
     },
     encodeBinary(buf, v) {
         buf.writeDoubleBE(typeof v === 'number' ? v : parseFloat(v));
     },
-    parseText: parseFloat,
+    decodeBinary(v, offset = 0) {
+        return v.readDoubleBE(offset);
+    },
+    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';
     },

package/data-types/int2-type.js

@@ -1,16 +1,21 @@
 import { DataTypeOIDs } from '../constants.js';
-import { fastParseInt } from '../util/fast-parseint.js';
+import { fastParseInt, fastParseIntBuffer } from '../util/fast-parseint.js';
 export const Int2Type = {
     name: 'int2',
     oid: DataTypeOIDs.int2,
     jsType: 'number',
-    parseBinary(v) {
-        return v.readInt16BE(0);
+    fixedBinarySize: 2,
+    encodeText(v) {
+        return '' + v;
     },
     encodeBinary(buf, v) {
         buf.writeInt16BE(fastParseInt(v));
     },
-    parseText: fastParseInt,
+    decodeBinary(v, offset = 0) {
+        return v.readInt16BE(offset);
+    },
+    decodeText: fastParseInt,
+    decodeTextBuffer: fastParseIntBuffer,
     isType(v) {
         return (typeof v === 'number' && Number.isInteger(v) && v >= -32768 && v <= 32767);
     },