postgrejs 2.23.1 → 3.0.2

package/connection/intl-connection.js

@@ -1,24 +1,41 @@
-import { TaskQueue } from 'power-tasks';
-import { coerceToBoolean } from 'putil-varhelpers';
-import { ConnectionState } from '../constants.js';
+import { performance } from 'node:perf_hooks';
+import { ConnectionState, DEFAULT_COLUMN_FORMAT } from '../constants.js';
 import { GlobalTypeMap } from '../data-type-map.js';
 import { PgSocket } from '../protocol/pg-socket.js';
 import { Protocol } from '../protocol/protocol.js';
 import { SafeEventEmitter } from '../safe-event-emitter.js';
 import { getConnectionConfig } from '../util/connection-config.js';
-import { convertRowToObject } from '../util/convert-row-to-object.js';
 import { escapeLiteral } from '../util/escape-literal.js';
 import { getParsers } from '../util/get-parsers.js';
-import { parseRow } from '../util/parse-row.js';
+import { parseObjectRow, parseRow } from '../util/parse-row.js';
 import { wrapRowDescription } from '../util/wrap-row-description.js';
+import { CopyFromStream, CopyToStream } from './copy-stream.js';
 const DataFormat = Protocol.DataFormat;
+function columnFormatsEqual(a, b) {
+    if (a === b)
+        return true;
+    if (!Array.isArray(a) || !Array.isArray(b))
+        return false;
+    if (a.length !== b.length)
+        return false;
+    const l = a.length;
+    let i;
+    for (i = 0; i < l; i++)
+        if (a[i] !== b[i])
+            return false;
+    return true;
+}
 export class IntlConnection extends SafeEventEmitter {
+    _executeReusedParserCache = new WeakMap();
     _refCount = 0;
+    _transactionDepth = 0;
+    _savepointDepths = new Map();
     _config;
     _onErrorSavePoint;
     transactionStatus = 'I';
     socket;
-    statementQueue = new TaskQueue({ concurrency: 1 });
+    owner;
+    runningQueryCount = 0;
     constructor(config) {
         super();
         this._config = Object.freeze(getConnectionConfig(config));
@@ -76,91 +93,190 @@ export class IntlConnection extends SafeEventEmitter {
     async close() {
         if (this.state === ConnectionState.CLOSED)
             return;
-        this.statementQueue.clearQueue();
         return new Promise(resolve => {
             if (this.socket.state === ConnectionState.CLOSED)
                 return;
+            // 'close' is not emitted here - the constructor's own
+            // `this.socket.on('close', () => this.emit('close'))` already
+            // forwards it once the socket's real close event fires. Emitting it
+            // again right here (synchronously, before socket.close()'s
+            // destroy() has actually completed) used to fire 'close' on this
+            // IntlConnection TWICE per close() call - confirmed live: a single
+            // close() left two listeners registered on the far side (e.g. two
+            // NOTIFY deliveries after Pool's reconnect re-subscribed twice).
             this.socket.once('close', resolve);
             this.socket.sendTerminateMessage(() => {
                 this.socket.close();
-                this.emit('close');
             });
         });
     }
-    async execute(sql, options, cb) {
+    async execute(sql, options = {}, cb) {
         this.assertConnected();
-        return this.statementQueue
-            .enqueue(async () => {
-            const transactionCommand = sql.match(/^(\bBEGIN\b|\bCOMMIT\b|\bSTART\b|\bROLLBACK|SAVEPOINT|RELEASE\b)/i);
-            let beginFirst = false;
-            let commitLast = false;
-            if (!transactionCommand) {
-                if (!this.inTransaction &&
-                    (options?.autoCommit != null
-                        ? options?.autoCommit
-                        : this.config.autoCommit) === false) {
-                    beginFirst = true;
-                }
-                if (this.inTransaction && options?.autoCommit)
-                    commitLast = true;
-            }
-            if (beginFirst)
-                await this._execute('BEGIN');
-            const rollbackOnError = !transactionCommand &&
-                (options?.rollbackOnError != null
-                    ? options.rollbackOnError
-                    : coerceToBoolean(this.config.rollbackOnError, true));
-            if (this.inTransaction && rollbackOnError)
-                await this._execute('SAVEPOINT ' + this._onErrorSavePoint);
-            try {
-                const result = await this._execute(sql, options, cb);
-                if (commitLast)
-                    await this._execute('COMMIT');
-                else if (this.inTransaction && rollbackOnError) {
-                    await this._execute('RELEASE ' + this._onErrorSavePoint + ';');
-                }
-                return result;
+        const transactionCommand = sql.match(/^(\bBEGIN\b|\bCOMMIT\b|\bSTART\b|\bROLLBACK|SAVEPOINT|RELEASE\b)/i);
+        let beginFirst = false;
+        let commitLast = false;
+        const { autoCommit } = options;
+        if (!transactionCommand) {
+            if ((autoCommit != null ? autoCommit : this.config.autoCommit) === false &&
+                !this.inTransaction) {
+                beginFirst = true;
             }
-            catch (e) {
-                if (this.inTransaction && rollbackOnError)
-                    await this._execute('ROLLBACK TO ' + this._onErrorSavePoint + ';');
-                throw e;
+            if (autoCommit && this.inTransaction)
+                commitLast = true;
+        }
+        if (beginFirst)
+            await this._execute('BEGIN');
+        // this.inTransaction goes first here, before the config fallback: the
+        // result is only ever consulted below when it's true, so checking it
+        // first short-circuits that read on every call made outside of a
+        // transaction, the common case. Below, `rollbackOnError &&
+        // this.inTransaction` deliberately puts it last instead - re-checking
+        // live state a plain local boolean can't capture (the awaited call in
+        // between may have committed, rolled back, or errored the transaction
+        // out from under it) - but ordered so the cheap local read still
+        // short-circuits the getter whenever rollbackOnError is already
+        // false, which it is outside a transaction.
+        const rollbackOnError = !transactionCommand &&
+            this.inTransaction &&
+            (options.rollbackOnError ?? this.config.rollbackOnError ?? true);
+        if (rollbackOnError && this.inTransaction)
+            await this._execute('SAVEPOINT ' + this._onErrorSavePoint);
+        try {
+            const result = await this._execute(sql, options, cb);
+            if (commitLast)
+                await this._execute('COMMIT');
+            else if (rollbackOnError && this.inTransaction) {
+                await this._execute('RELEASE ' + this._onErrorSavePoint + ';');
             }
-        })
-            .toPromise();
+            return result;
+        }
+        catch (e) {
+            if (rollbackOnError && this.inTransaction)
+                await this._execute('ROLLBACK TO ' + this._onErrorSavePoint + ';');
+            throw e;
+        }
     }
+    /**
+     * Starts a transaction, or - if one is already running - marks a nested
+     * level of it. Each call increments `_transactionDepth`; only the
+     * outermost one actually sends BEGIN (`inTransaction` is already false at
+     * that point). A matching number of commit() calls is then needed to
+     * actually commit - see commit().
+     */
     async startTransaction() {
+        this._transactionDepth++;
         if (!this.inTransaction)
             await this.execute('BEGIN');
     }
+    /**
+     * Starts a savepoint, or - if one under the same `name` is already open -
+     * marks a nested level of it. Mirrors startTransaction(): only the
+     * outermost call for a given name actually sends SAVEPOINT: a savepoint
+     * already exists under that name, re-declaring it would just stack a
+     * second, independent one with the same name on the server rather than
+     * nesting the existing one.
+     */
     async savepoint(name) {
         if (!(name && name.match(/^[a-zA-Z]\w+$/)))
             throw new Error(`Invalid savepoint "${name}"`);
-        await this.execute('BEGIN; SAVEPOINT ' + name);
+        const depth = (this._savepointDepths.get(name) || 0) + 1;
+        this._savepointDepths.set(name, depth);
+        if (depth === 1)
+            await this.execute('BEGIN; SAVEPOINT ' + name);
     }
-    async commit() {
+    /**
+     * Commits the transaction started by startTransaction() - or, when nested,
+     * just unwinds one level of `_transactionDepth`. The actual COMMIT is only
+     * sent once the depth reaches zero, i.e. once every startTransaction()
+     * call has a matching commit().
+     * @param immediate - Ignores `_transactionDepth` and commits right away,
+     *   regardless of how many nested levels are still open.
+     */
+    async commit(immediate) {
+        if (!immediate && this._transactionDepth > 1) {
+            this._transactionDepth--;
+            return;
+        }
+        this._transactionDepth = 0;
         if (this.inTransaction)
             await this.execute('COMMIT');
     }
+    /**
+     * Releases the savepoint created by savepoint() - or, when nested, just
+     * unwinds one level of that name's depth. The actual RELEASE SAVEPOINT is
+     * only sent once that depth reaches zero.
+     * @param name - Name of the savepoint.
+     * @param immediate - Ignores the tracked depth and releases right away.
+     */
+    async releaseSavepoint(name, immediate) {
+        if (!(name && name.match(/^[a-zA-Z]\w+$/)))
+            throw new Error(`Invalid savepoint "${name}"`);
+        const depth = this._savepointDepths.get(name) || 0;
+        if (!immediate && depth > 1) {
+            this._savepointDepths.set(name, depth - 1);
+            return;
+        }
+        this._savepointDepths.delete(name);
+        await this.execute('RELEASE SAVEPOINT ' + name, { autoCommit: false });
+    }
+    /**
+     * Rolls back the whole transaction, regardless of `_transactionDepth` -
+     * a rollback ends the transaction outright, so there is nothing left for
+     * any pending, still-nested commit() call to unwind.
+     */
     async rollback() {
+        this._transactionDepth = 0;
         if (this.inTransaction)
             await this.execute('ROLLBACK');
     }
+    /**
+     * Ends the current transaction as a prepared one: it stops being tied to
+     * this session and waits under `name` until some connection - not
+     * necessarily this one, and not necessarily this process - finishes it
+     * with commitPrepared() or rollbackPrepared().
+     *
+     * Goes through _execute() rather than execute(): PREPARE TRANSACTION is
+     * not in the latter's list of transaction commands, so it would be
+     * wrapped in a savepoint whose RELEASE then fails, the session no longer
+     * being in a transaction by that point.
+     *
+     * Requires `max_prepared_transactions` above zero on the server, which is
+     * not the default; the server's own error says so if it is not.
+     */
+    async prepareTransaction(name) {
+        await this._execute('PREPARE TRANSACTION ' + escapeLiteral(name));
+    }
+    /** Commits a transaction left waiting by prepareTransaction(). */
+    async commitPrepared(name) {
+        await this._execute('COMMIT PREPARED ' + escapeLiteral(name));
+    }
+    /** Discards a transaction left waiting by prepareTransaction(). */
+    async rollbackPrepared(name) {
+        await this._execute('ROLLBACK PREPARED ' + escapeLiteral(name));
+    }
+    /**
+     * Rolls back to the given savepoint, regardless of its tracked depth - a
+     * rollback discards it (and everything after it) outright, so there is
+     * nothing left for any pending, still-nested releaseSavepoint() call to
+     * unwind.
+     */
     async rollbackToSavepoint(name) {
         if (!(name && name.match(/^[a-zA-Z]\w+$/)))
             throw new Error(`Invalid savepoint "${name}"`);
+        this._savepointDepths.delete(name);
         await this.execute('ROLLBACK TO SAVEPOINT ' + name, { autoCommit: false });
     }
-    async releaseSavepoint(name) {
-        if (!(name && name.match(/^[a-zA-Z]\w+$/)))
-            throw new Error(`Invalid savepoint "${name}"`);
-        await this.execute('RELEASE SAVEPOINT ' + name, { autoCommit: false });
+    /** Asks the server to cancel whatever this session is running. */
+    cancel() {
+        return this.socket.cancel();
     }
     ref() {
         this._refCount++;
     }
     unref() {
         this._refCount--;
+        if (!this._refCount)
+            this.emit('idle');
         return !this._refCount;
     }
     assertConnected() {
@@ -169,27 +285,78 @@ export class IntlConnection extends SafeEventEmitter {
         if (this.state === ConnectionState.CLOSED)
             throw new Error('Connection closed');
     }
-    async _execute(sql, options, cb) {
+    /**
+     * Runs a COPY ... TO STDOUT and hands back its bytes as they arrive.
+     * Resolves once the server has accepted the copy, not once it has
+     * finished - the whole point is not to hold the export in memory.
+     */
+    async copyTo(sql) {
+        this.assertConnected();
+        this.ref();
+        this.runningQueryCount++;
+        const stream = new CopyToStream(this.socket);
+        this.socket
+            .sendQueryMessage(sql, stream.capture)
+            .catch(err => stream.fail(err))
+            .finally(() => {
+            this.runningQueryCount--;
+            this.unref();
+        });
+        await stream.waitStarted();
+        return stream;
+    }
+    /**
+     * Runs a COPY ... FROM STDIN and hands back a stream to feed it.
+     * Resolves once the server is ready for data.
+     */
+    async copyFrom(sql) {
+        this.assertConnected();
+        this.ref();
+        this.runningQueryCount++;
+        const stream = new CopyFromStream(this.socket);
+        this.socket
+            .sendQueryMessage(sql, stream.capture)
+            .catch(err => stream.fail(err))
+            .finally(() => {
+            this.runningQueryCount--;
+            this.unref();
+        });
+        await stream.waitStarted();
+        return stream;
+    }
+    async _execute(sql, options = {}, cb) {
         this.ref();
         try {
-            const startTime = Date.now();
+            const timingEnabled = options.timing ?? this.config.timing ?? false;
+            const startTime = timingEnabled ? performance.now() : 0;
             const result = {
                 totalCommands: 0,
-                totalTime: 0,
                 results: [],
             };
-            const opts = options || {};
-            this.socket.sendQueryMessage(sql);
-            let currentStart = Date.now();
+            let currentStart = startTime;
             let parsers;
             let current = { command: undefined };
             let fields;
-            const typeMap = opts.typeMap || GlobalTypeMap;
-            return await this.socket.capture(async (code, msg, done) => {
+            let error;
+            const typeMap = options.typeMap || GlobalTypeMap;
+            this.runningQueryCount++;
+            return await this.socket.sendQueryMessage(sql, (code, msg, done) => {
                 switch (code) {
-                    case Protocol.BackendMessageCode.NoticeResponse:
+                    case Protocol.BackendMessageCode.ErrorResponse:
+                        error = msg;
+                        break;
                     case Protocol.BackendMessageCode.CopyInResponse:
+                        error =
+                            error ||
+                                new Error('COPY FROM STDIN is not supported by execute() - use copyFrom() instead');
+                        this.socket.sendCopyFail(error.message);
+                        break;
                     case Protocol.BackendMessageCode.CopyOutResponse:
+                        error =
+                            error ||
+                                new Error('COPY TO STDOUT is not supported by execute() - use copyTo() instead');
+                        break;
+                    case Protocol.BackendMessageCode.NoticeResponse:
                     case Protocol.BackendMessageCode.EmptyQueryResponse:
                         break;
                     case Protocol.BackendMessageCode.RowDescription:
@@ -200,11 +367,9 @@ export class IntlConnection extends SafeEventEmitter {
                         break;
                     case Protocol.BackendMessageCode.DataRow:
                         {
-                            let row = msg.columns.map((x) => x.toString('utf8'));
-                            // The null override assumes we can trust PG to always send the RowDescription first
-                            parseRow(parsers, row, opts);
-                            if (opts.objectRows && current.fields)
-                                row = convertRowToObject(current.fields, row);
+                            const row = options.objectRows && current.fields
+                                ? parseObjectRow(parsers, msg.data, msg.columnCount, options, current.fields)
+                                : parseRow(parsers, msg.data, msg.columnCount, options);
                             if (cb)
                                 cb('row', row);
                             current.rows = current.rows || [];
@@ -219,19 +384,26 @@ export class IntlConnection extends SafeEventEmitter {
                             current.command === 'UPDATE') {
                             current.rowsAffected = msg.rowCount;
                         }
-                        current.executeTime = Date.now() - currentStart;
+                        if (timingEnabled)
+                            current.executeTime = performance.now() - currentStart;
                         if (current.rows)
                             current.rowType =
-                                opts.objectRows && current.fields ? 'object' : 'array';
+                                options.objectRows && current.fields ? 'object' : 'array';
                         result.results.push(current);
                         if (cb)
                             cb('command-complete', current);
                         current = { command: undefined };
-                        currentStart = Date.now();
+                        if (timingEnabled)
+                            currentStart = performance.now();
                         break;
                     case Protocol.BackendMessageCode.ReadyForQuery:
                         this.transactionStatus = msg.status;
-                        result.totalTime = Date.now() - startTime;
+                        if (error) {
+                            done(error);
+                            break;
+                        }
+                        if (timingEnabled)
+                            result.totalTime = performance.now() - startTime;
                         // Ignore COMMIT command that we added to sql
                         result.totalCommands = result.results.length;
                         done(undefined, result);
@@ -241,10 +413,268 @@ export class IntlConnection extends SafeEventEmitter {
                 }
             });
         }
+        finally {
+            this.runningQueryCount--;
+            this.unref();
+        }
+    }
+    /**
+     * One-shot Extended Query fast path: Parse+Bind+Describe+Execute+Sync as
+     * a single round trip (unnamed statement/portal, no Close needed), used
+     * by Connection.query() instead of prepare()+PreparedStatement.execute()
+     * +close()'s 7 round trips whenever there's no cursor and no explicit/
+     * active transaction to wrap (see Connection.query() for that gating).
+     */
+    async queryOnce(sql, paramTypes, params, options) {
+        this.assertConnected();
+        this.ref();
+        try {
+            const typeMap = options.typeMap || GlobalTypeMap;
+            const timingEnabled = options.timing ?? this.config.timing ?? false;
+            const startTime = timingEnabled ? performance.now() : 0;
+            const result = { command: undefined };
+            const rows = [];
+            let parsers;
+            let resultFields;
+            let commandTag;
+            let error;
+            this.runningQueryCount++;
+            await this.socket
+                .sendExtendedQueryMessages({
+                parse: { sql, paramTypes },
+                bind: { typeMap, paramTypes, params, queryOptions: options },
+                describe: { type: 'P' },
+                execute: { fetchCount: options.fetchCount || 100 },
+            }, (code, msg, done) => {
+                switch (code) {
+                    case Protocol.BackendMessageCode.ParseComplete:
+                    case Protocol.BackendMessageCode.BindComplete:
+                    case Protocol.BackendMessageCode.NoData:
+                    case Protocol.BackendMessageCode.NoticeResponse:
+                    case Protocol.BackendMessageCode.PortalSuspended:
+                        break;
+                    case Protocol.BackendMessageCode.RowDescription:
+                        parsers = getParsers(typeMap, msg.fields);
+                        resultFields = wrapRowDescription(typeMap, msg.fields, options.columnFormat || DEFAULT_COLUMN_FORMAT);
+                        result.fields = resultFields;
+                        result.rowType = options.objectRows ? 'object' : 'array';
+                        break;
+                    case Protocol.BackendMessageCode.DataRow:
+                        rows.push(msg);
+                        break;
+                    case Protocol.BackendMessageCode.CommandComplete:
+                        commandTag = msg;
+                        break;
+                    case Protocol.BackendMessageCode.ErrorResponse:
+                        error = msg;
+                        break;
+                    case Protocol.BackendMessageCode.ReadyForQuery:
+                        this.transactionStatus = msg.status;
+                        done(error);
+                        break;
+                    default:
+                        done(new Error(`Server returned unexpected response message (${String.fromCharCode(code)})`));
+                }
+            })
+                .finally(() => {
+                this.runningQueryCount--;
+            });
+            if (commandTag?.command)
+                result.command = commandTag.command;
+            if (resultFields && parsers) {
+                if (!result.command)
+                    result.command = 'SELECT';
+                result.rows = rows;
+                const l = rows.length;
+                let i;
+                for (i = 0; i < l; i++) {
+                    rows[i] = options.objectRows
+                        ? parseObjectRow(parsers, rows[i].data, rows[i].columnCount, options, resultFields)
+                        : parseRow(parsers, rows[i].data, rows[i].columnCount, options);
+                }
+            }
+            if (result.command === 'DELETE' ||
+                result.command === 'INSERT' ||
+                result.command === 'UPDATE') {
+                result.rowsAffected = commandTag?.rowCount;
+            }
+            if (timingEnabled)
+                result.executeTime = performance.now() - startTime;
+            return result;
+        }
+        finally {
+            this.unref();
+        }
+    }
+    /**
+     * Parse+Describe(statement)+Sync as a single round trip - used by
+     * PreparedStatement.prepare() instead of a separately-awaited Parse then
+     * a separately-awaited Sync, and fetches the RowDescription/NoData in the
+     * same round trip so the caller can cache it (see executeReused()) rather
+     * than every later execute() re-Describing its own portal.
+     */
+    async prepareOnce(sql, paramTypes, statementName) {
+        this.assertConnected();
+        this.ref();
+        try {
+            let fields;
+            let error;
+            this.runningQueryCount++;
+            await this.socket
+                .sendPrepareMessages({
+                parse: { statement: statementName, sql, paramTypes },
+                describe: { type: 'S', name: statementName },
+            }, (code, msg, done) => {
+                switch (code) {
+                    case Protocol.BackendMessageCode.ParseComplete:
+                    case Protocol.BackendMessageCode.ParameterDescription:
+                    case Protocol.BackendMessageCode.NoData:
+                    case Protocol.BackendMessageCode.NoticeResponse:
+                        break;
+                    case Protocol.BackendMessageCode.RowDescription:
+                        fields = msg.fields;
+                        break;
+                    case Protocol.BackendMessageCode.ErrorResponse:
+                        // See queryOnce()'s ErrorResponse case for why done() must
+                        // not be called here.
+                        error = msg;
+                        break;
+                    case Protocol.BackendMessageCode.ReadyForQuery:
+                        this.transactionStatus = msg.status;
+                        done(error);
+                        break;
+                    default:
+                        done(new Error(`Server returned unexpected response message (${String.fromCharCode(code)})`));
+                }
+            })
+                .finally(() => {
+                this.runningQueryCount--;
+            });
+            return { fields };
+        }
         finally {
             this.unref();
         }
     }
+    /**
+     * Bind+Execute+Sync as a single round trip against an unnamed portal, for
+     * an already-prepared (named) statement - used by
+     * PreparedStatement._execute()'s non-cursor path instead of the 4-round-
+     * trip Portal.bind()/retrieveFields()/execute()/close() sequence. Takes
+     * the RowDescription fields prepareOnce() already fetched instead of
+     * re-Describing a fresh portal on every call.
+     */
+    async executeReused(statementName, cachedFields, paramTypes, params, options) {
+        this.assertConnected();
+        this.ref();
+        try {
+            const typeMap = options.typeMap || GlobalTypeMap;
+            const timingEnabled = options.timing ?? this.config.timing ?? false;
+            const startTime = timingEnabled ? performance.now() : 0;
+            const result = { command: undefined };
+            const rows = [];
+            let parsers;
+            let resultFields;
+            let commandTag;
+            let error;
+            if (cachedFields) {
+                const columnFormat = options.columnFormat != null
+                    ? options.columnFormat
+                    : DEFAULT_COLUMN_FORMAT;
+                const cached = this._executeReusedParserCache.get(cachedFields);
+                if (cached &&
+                    cached.typeMap === typeMap &&
+                    columnFormatsEqual(cached.columnFormat, columnFormat)) {
+                    parsers = cached.parsers;
+                    resultFields = cached.resultFields;
+                }
+                else {
+                    const fields = cachedFields.map((f, i) => ({
+                        ...f,
+                        format: Array.isArray(columnFormat)
+                            ? columnFormat[i]
+                            : columnFormat,
+                    }));
+                    parsers = getParsers(typeMap, fields);
+                    resultFields = wrapRowDescription(typeMap, fields, columnFormat);
+                    this._executeReusedParserCache.set(cachedFields, {
+                        typeMap,
+                        columnFormat,
+                        parsers,
+                        resultFields,
+                    });
+                }
+                result.fields = resultFields;
+                result.rowType = options.objectRows ? 'object' : 'array';
+            }
+            this.runningQueryCount++;
+            await this.socket
+                .sendBindExecuteMessages({
+                bind: {
+                    typeMap,
+                    statement: statementName,
+                    paramTypes,
+                    params,
+                    queryOptions: options,
+                },
+                execute: { fetchCount: options.fetchCount || 100 },
+            }, (code, msg, done) => {
+                switch (code) {
+                    case Protocol.BackendMessageCode.BindComplete:
+                    case Protocol.BackendMessageCode.NoticeResponse:
+                    case Protocol.BackendMessageCode.PortalSuspended:
+                        break;
+                    case Protocol.BackendMessageCode.DataRow:
+                        rows.push(msg);
+                        break;
+                    case Protocol.BackendMessageCode.CommandComplete:
+                        commandTag = msg;
+                        break;
+                    case Protocol.BackendMessageCode.ErrorResponse:
+                        error = msg;
+                        break;
+                    case Protocol.BackendMessageCode.ReadyForQuery:
+                        this.transactionStatus = msg.status;
+                        done(error);
+                        break;
+                    default:
+                        done(new Error(`Server returned unexpected response message (${String.fromCharCode(code)})`));
+                }
+            })
+                .finally(() => {
+                this.runningQueryCount--;
+            });
+            if (commandTag?.command)
+                result.command = commandTag.command;
+            if (resultFields && parsers) {
+                if (!result.command)
+                    result.command = 'SELECT';
+                result.rows = rows;
+                const l = rows.length;
+                let i;
+                for (i = 0; i < l; i++) {
+                    rows[i] = options.objectRows
+                        ? parseObjectRow(parsers, rows[i].data, rows[i].columnCount, options, resultFields)
+                        : parseRow(parsers, rows[i].data, rows[i].columnCount, options);
+                }
+            }
+            if (result.command === 'DELETE' ||
+                result.command === 'INSERT' ||
+                result.command === 'UPDATE') {
+                result.rowsAffected = commandTag?.rowCount;
+            }
+            if (timingEnabled)
+                result.executeTime = performance.now() - startTime;
+            return result;
+        }
+        finally {
+            this.unref();
+        }
+    }
+    emit(event, ...args) {
+        const handled = super.emit(event, ...args);
+        return this.owner ? this.owner.emit(event, ...args) || handled : handled;
+    }
     _onError(err) {
         if (this.socket.state !== ConnectionState.READY)
             return;