postgrejs 2.23.0 → 3.0.1

package/connection/large-object.js

@@ -0,0 +1,151 @@
+import { Readable, Writable } from 'node:stream';
+import { DataTypeOIDs } from '../constants.js';
+import { BindParam } from './bind-param.js';
+/** Open modes, as PostgreSQL's own INV_READ / INV_WRITE constants. */
+export const LargeObjectMode = {
+    read: 0x00040000,
+    write: 0x00020000,
+    readWrite: 0x00060000,
+};
+/**
+ * A PostgreSQL large object: binary data stored outside the row it belongs
+ * to and reached through a file-like interface, so it can be seeked into
+ * and read a piece at a time rather than loaded whole the way a `bytea`
+ * column must be. Up to 4TB, against roughly 1GB for `bytea`.
+ *
+ * ```ts
+ * const lo = await connection.createLargeObject();
+ * await pipeline(fs.createReadStream('video.mp4'), lo.writable());
+ * await lo.close();
+ * // keep lo.oid somewhere - a large object belongs to no row
+ * ```
+ *
+ * The descriptor a large object is opened with only lives as long as the
+ * transaction that opened it, so one is started if the connection is not
+ * already in one, and close() commits that one - but never a transaction
+ * the caller started, which stays theirs to finish.
+ */
+export class LargeObject {
+    oid;
+    _connection;
+    _fd;
+    /** True when this object opened the transaction and so should commit it. */
+    _ownsTransaction;
+    _closed = false;
+    constructor(connection, oid, fd, ownsTransaction) {
+        this._connection = connection;
+        this.oid = oid;
+        this._fd = fd;
+        this._ownsTransaction = ownsTransaction;
+    }
+    /** Reads at most `length` bytes from the current position. */
+    async read(length) {
+        this._assertOpen();
+        const r = await this._connection.query('select loread($1, $2) as data', {
+            params: [
+                new BindParam(DataTypeOIDs.int4, this._fd),
+                new BindParam(DataTypeOIDs.int4, length),
+            ],
+        });
+        // loread() always returns a (possibly zero-length) bytea, never SQL
+        // NULL, so this fallback is a defensive backstop rather than a path
+        // real server behavior takes.
+        return r.rows?.[0][0] ?? Buffer.alloc(0);
+    }
+    /** Writes at the current position and returns how many bytes went in. */
+    async write(data) {
+        this._assertOpen();
+        const r = await this._connection.query('select lowrite($1, $2) as n', {
+            params: [
+                new BindParam(DataTypeOIDs.int4, this._fd),
+                new BindParam(DataTypeOIDs.bytea, data),
+            ],
+        });
+        return Number(r.rows?.[0][0]);
+    }
+    /** Moves the read/write position. `whence`: 0 start, 1 current, 2 end. */
+    async seek(offset, whence = 0) {
+        this._assertOpen();
+        const r = await this._connection.query('select lo_lseek64($1, $2, $3) as pos', {
+            params: [
+                new BindParam(DataTypeOIDs.int4, this._fd),
+                new BindParam(DataTypeOIDs.int8, BigInt(offset)),
+                new BindParam(DataTypeOIDs.int4, whence),
+            ],
+        });
+        return BigInt(r.rows?.[0][0]);
+    }
+    /** The current read/write position. */
+    async tell() {
+        this._assertOpen();
+        const r = await this._connection.query('select lo_tell64($1) as pos', {
+            params: [new BindParam(DataTypeOIDs.int4, this._fd)],
+        });
+        return BigInt(r.rows?.[0][0]);
+    }
+    /** Total size in bytes; leaves the position where it found it. */
+    async size() {
+        const here = await this.tell();
+        const end = await this.seek(0, 2);
+        await this.seek(here, 0);
+        return end;
+    }
+    /** Cuts the object down to `length` bytes. */
+    async truncate(length) {
+        this._assertOpen();
+        await this._connection.query('select lo_truncate64($1, $2)', {
+            params: [
+                new BindParam(DataTypeOIDs.int4, this._fd),
+                new BindParam(DataTypeOIDs.int8, BigInt(length)),
+            ],
+        });
+    }
+    /** Reads from the current position to the end. */
+    readable(options) {
+        const chunkSize = options?.chunkSize || 65536;
+        const self = this;
+        return new Readable({
+            async read() {
+                try {
+                    const chunk = await self.read(chunkSize);
+                    // A short read is not the end; an empty one is.
+                    this.push(chunk.length ? chunk : null);
+                }
+                catch (e) {
+                    this.destroy(e);
+                }
+            },
+        });
+    }
+    /** Writes from the current position onwards. */
+    writable(options) {
+        const self = this;
+        return new Writable({
+            highWaterMark: options?.chunkSize || 65536,
+            write(chunk, _encoding, callback) {
+                self
+                    .write(chunk)
+                    .then(() => callback())
+                    .catch(callback);
+            },
+        });
+    }
+    /**
+     * Closes the descriptor, and commits the transaction if this object
+     * started it. Safe to call twice.
+     */
+    async close() {
+        if (this._closed)
+            return;
+        this._closed = true;
+        await this._connection.query('select lo_close($1)', {
+            params: [new BindParam(DataTypeOIDs.int4, this._fd)],
+        });
+        if (this._ownsTransaction)
+            await this._connection.commit();
+    }
+    _assertOpen() {
+        if (this._closed)
+            throw new Error(`Large object ${this.oid} is already closed`);
+    }
+}

package/connection/logical-replication.d.ts

@@ -0,0 +1,121 @@
+import type { ConnectionConfiguration } from '../interfaces/database-connection-params.js';
+import type { CaptureCallback } from '../protocol/pg-socket.js';
+import { PgOutputDecoder, type PgOutputMessage, type PgOutputRelation, type TupleValues } from '../protocol/pgoutput.js';
+import { SafeEventEmitter } from '../safe-event-emitter.js';
+import { IntlConnection } from './intl-connection.js';
+export type ChangeCommand = 'insert' | 'update' | 'delete' | 'truncate';
+export interface Change {
+    command: ChangeCommand;
+    /** Schema-qualified, e.g. `public.users`. */
+    table: string;
+    schema: string;
+    relation: PgOutputRelation;
+    /** The row after the change; absent for delete and truncate. */
+    row?: TupleValues;
+    /**
+     * The row before the change, for update and delete. How much of it is
+     * present depends on the table's REPLICA IDENTITY - by default only the
+     * primary key.
+     */
+    oldRow?: TupleValues;
+    /** Where this change sits in the write-ahead log. */
+    lsn: bigint;
+    /** Commit time of the transaction it belongs to. */
+    timestamp?: Date;
+}
+export interface LogicalReplicationOptions extends ConnectionConfiguration {
+    /** Publication(s) to subscribe to; they must already exist on the server. */
+    publication: string | string[];
+    /**
+     * Replication slot name. A slot is what makes the server keep WAL until it
+     * is confirmed, so the default is a temporary one, dropped when the
+     * connection ends. A permanent slot outlives the process and keeps WAL
+     * piling up until it is either read or dropped - which is how a disk fills.
+     */
+    slot?: string;
+    /** Keep the slot after disconnecting. Off by default, deliberately. */
+    permanent?: boolean;
+    /** Only these commands are yielded. */
+    commands?: ChangeCommand[];
+    /** Only these tables, as `users` or `public.users`. */
+    tables?: string[];
+    /** Anything the two above cannot express. */
+    filter?: (change: Change) => boolean;
+    /** How often to tell the server where we are, in ms (default 10000). */
+    keepAliveIntervalMs?: number;
+}
+/**
+ * Streams row-level changes out of PostgreSQL as they are committed.
+ *
+ * It owns its own connection rather than borrowing one: a connection that
+ * has run START_REPLICATION is in a streaming mode it never leaves, so none
+ * of Connection's own API would work on it afterwards.
+ *
+ * ```ts
+ * const sub = new LogicalReplication({ ...config, publication: 'my_pub' });
+ * for await (const change of sub) {
+ *   if (change.command === 'insert') await index.add(change.row);
+ * }
+ * ```
+ *
+ * The loop is the backpressure: nothing is read from the socket while the
+ * body is running, so a slow consumer slows the stream instead of filling
+ * memory. Leaving the loop - by `break`, by throwing, or by closing the
+ * subscription - ends it cleanly.
+ *
+ * Each change is confirmed to the server when the *next* one is pulled, not
+ * when it is handed over. A consumer that crashes half way through therefore
+ * sees that change again on the next run rather than losing it, and no
+ * caller has to remember to acknowledge anything.
+ */
+export declare class LogicalReplication extends SafeEventEmitter {
+    readonly options: LogicalReplicationOptions;
+    protected _intlCon?: IntlConnection;
+    protected readonly _decoder: PgOutputDecoder;
+    protected readonly _queue: Change[];
+    protected _waiting?: (value: void) => void;
+    protected _finished: boolean;
+    protected _error?: Error;
+    protected _slotName: string;
+    protected _slotCreated: boolean;
+    protected _keepAliveTimer?: NodeJS.Timeout;
+    protected _receivedLsn: bigint;
+    protected _confirmedLsn: bigint;
+    protected _pendingLsn: bigint;
+    protected _commitTime?: Date;
+    protected _streamDone?: Promise<any>;
+    constructor(options: LogicalReplicationOptions);
+    /** The slot this subscription is reading from. */
+    get slot(): string;
+    /** The last position confirmed to the server. */
+    get confirmedLsn(): string;
+    /**
+     * Opens the connection, creates the slot if needed and starts streaming.
+     * Iterating calls this on its own, so it is only needed to start early.
+     */
+    start(): Promise<void>;
+    /** Ends the subscription and closes its connection. */
+    close(): Promise<void>;
+    /**
+     * Confirms everything up to the last change handed out. Called for you
+     * when the next change is pulled; use it directly only to confirm sooner.
+     */
+    ack(): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<Change>;
+    protected readonly _capture: CaptureCallback;
+    protected _handleCopyData(data: Buffer): void;
+    /**
+     * Turns one decoded message into the changes it represents - none for
+     * bookkeeping messages, one for a row change, and one per table for a
+     * truncate, so that a `tables` filter behaves the same way there.
+     */
+    protected _toChanges(message: PgOutputMessage, lsn: bigint): Change[];
+    protected _build(command: ChangeCommand, relation: PgOutputRelation, lsn: bigint, row?: TupleValues, oldRow?: TupleValues): Change;
+    /** Client-side filtering, on top of whatever the publication already limits. */
+    protected _accepts(change: Change): boolean;
+    /** Standby status update: where we have written, flushed and applied. */
+    protected _sendStatus(replyRequested: boolean): void;
+    protected _resume(): void;
+    protected _wake(): void;
+    protected _fail(err: Error): void;
+}

package/connection/logical-replication.js

@@ -0,0 +1,279 @@
+import { ConnectionState } from '../constants.js';
+import { formatLsn, PgOutputDecoder, } from '../protocol/pgoutput.js';
+import { Protocol } from '../protocol/protocol.js';
+import { SafeEventEmitter } from '../safe-event-emitter.js';
+import { escapeLiteral } from '../util/escape-literal.js';
+import { IntlConnection } from './intl-connection.js';
+const PG_EPOCH_MS = Date.UTC(2000, 0, 1);
+const DEFAULT_KEEPALIVE_MS = 10000;
+/**
+ * Streams row-level changes out of PostgreSQL as they are committed.
+ *
+ * It owns its own connection rather than borrowing one: a connection that
+ * has run START_REPLICATION is in a streaming mode it never leaves, so none
+ * of Connection's own API would work on it afterwards.
+ *
+ * ```ts
+ * const sub = new LogicalReplication({ ...config, publication: 'my_pub' });
+ * for await (const change of sub) {
+ *   if (change.command === 'insert') await index.add(change.row);
+ * }
+ * ```
+ *
+ * The loop is the backpressure: nothing is read from the socket while the
+ * body is running, so a slow consumer slows the stream instead of filling
+ * memory. Leaving the loop - by `break`, by throwing, or by closing the
+ * subscription - ends it cleanly.
+ *
+ * Each change is confirmed to the server when the *next* one is pulled, not
+ * when it is handed over. A consumer that crashes half way through therefore
+ * sees that change again on the next run rather than losing it, and no
+ * caller has to remember to acknowledge anything.
+ */
+export class LogicalReplication extends SafeEventEmitter {
+    options;
+    _intlCon;
+    _decoder = new PgOutputDecoder();
+    _queue = [];
+    _waiting;
+    _finished = false;
+    _error;
+    _slotName;
+    _slotCreated = false;
+    _keepAliveTimer;
+    _receivedLsn = 0n;
+    _confirmedLsn = 0n;
+    _pendingLsn = 0n;
+    _commitTime;
+    _streamDone;
+    constructor(options) {
+        super();
+        if (!options.publication)
+            throw new TypeError('LogicalReplication requires a publication');
+        this.options = options;
+        this._slotName =
+            options.slot ||
+                'postgrejs_' + Math.random().toString(36).substring(2, 10);
+    }
+    /** The slot this subscription is reading from. */
+    get slot() {
+        return this._slotName;
+    }
+    /** The last position confirmed to the server. */
+    get confirmedLsn() {
+        return formatLsn(this._confirmedLsn);
+    }
+    /**
+     * Opens the connection, creates the slot if needed and starts streaming.
+     * Iterating calls this on its own, so it is only needed to start early.
+     */
+    async start() {
+        if (this._intlCon)
+            return;
+        const intlCon = (this._intlCon = new IntlConnection({
+            ...this.options,
+            replication: 'database',
+        }));
+        await intlCon.connect();
+        if (!this.options.slot || this.options.permanent === false) {
+            await intlCon.execute(`CREATE_REPLICATION_SLOT ${this._slotName}` +
+                (this.options.permanent ? '' : ' TEMPORARY') +
+                ' LOGICAL pgoutput');
+            this._slotCreated = true;
+        }
+        const publications = (Array.isArray(this.options.publication)
+            ? this.options.publication
+            : [this.options.publication]).join(',');
+        const sql = `START_REPLICATION SLOT ${this._slotName} LOGICAL 0/0 ` +
+            `(proto_version '1', publication_names ${escapeLiteral(publications)})`;
+        // Deliberately not awaited here: this resolves only when streaming
+        // ends. Stored so close() can wait for it after asking the server to
+        // stop, rather than sending a new query while COPY BOTH is still active.
+        this._streamDone = intlCon.socket
+            .sendQueryMessage(sql, this._capture)
+            .catch(err => this._fail(err));
+        this._keepAliveTimer = setInterval(() => this._sendStatus(false), this.options.keepAliveIntervalMs || DEFAULT_KEEPALIVE_MS);
+        this._keepAliveTimer.unref();
+    }
+    /** Ends the subscription and closes its connection. */
+    async close() {
+        const wasStreaming = !this._finished;
+        this._finished = true;
+        this._wake();
+        if (this._keepAliveTimer)
+            clearInterval(this._keepAliveTimer);
+        this._keepAliveTimer = undefined;
+        const intlCon = this._intlCon;
+        this._intlCon = undefined;
+        if (!intlCon)
+            return;
+        if (wasStreaming && intlCon.state === ConnectionState.READY) {
+            // Still mid-COPY-BOTH: a new Query message (like the DROP below) is
+            // invalid until the server has acknowledged the end of streaming and
+            // returned to normal command processing. A paused socket (from
+            // backpressure) would never see that acknowledgment at all.
+            intlCon.socket.resume();
+            intlCon.socket.sendCopyDone();
+            await this._streamDone?.catch(() => undefined);
+        }
+        if (this._slotCreated &&
+            this.options.permanent &&
+            intlCon.state === ConnectionState.READY) {
+            await intlCon
+                .execute(`DROP_REPLICATION_SLOT ${this._slotName}`)
+                .catch(() => undefined);
+        }
+        await intlCon.close().catch(() => undefined);
+    }
+    /**
+     * Confirms everything up to the last change handed out. Called for you
+     * when the next change is pulled; use it directly only to confirm sooner.
+     */
+    async ack() {
+        this._confirmedLsn = this._pendingLsn;
+        this._sendStatus(false);
+    }
+    async *[Symbol.asyncIterator]() {
+        await this.start();
+        try {
+            while (true) {
+                if (this._error)
+                    throw this._error;
+                const change = this._queue.shift();
+                if (change) {
+                    this._confirmedLsn = this._pendingLsn;
+                    this._pendingLsn = change.lsn;
+                    yield change;
+                    continue;
+                }
+                if (this._finished)
+                    return;
+                this._resume();
+                await new Promise(resolve => (this._waiting = resolve));
+            }
+        }
+        finally {
+            await this.close();
+        }
+    }
+    _capture = (code, msg, done) => {
+        switch (code) {
+            case Protocol.BackendMessageCode.CopyBothResponse:
+                break;
+            case Protocol.BackendMessageCode.CopyData:
+                this._handleCopyData(msg.data);
+                break;
+            case Protocol.BackendMessageCode.ErrorResponse:
+                this._error = msg;
+                break;
+            case Protocol.BackendMessageCode.ReadyForQuery:
+                this._finished = true;
+                done(undefined);
+                this._wake();
+                break;
+            default:
+                break;
+        }
+    };
+    _handleCopyData(data) {
+        const kind = String.fromCharCode(data[0]);
+        if (kind === 'k') {
+            this._receivedLsn = data.readBigUInt64BE(1);
+            if (data[17] === 1)
+                this._sendStatus(false);
+            return;
+        }
+        if (kind !== 'w')
+            return; // XLogData is the only other thing sent here
+        const walStart = data.readBigUInt64BE(1);
+        this._receivedLsn = data.readBigUInt64BE(9);
+        const message = this._decoder.decode(data.subarray(25));
+        const changes = this._toChanges(message, walStart);
+        if (!changes.length)
+            return;
+        this._queue.push(...changes);
+        if (this._queue.length > 1)
+            this._intlCon?.socket.pause();
+        this._wake();
+    }
+    /**
+     * Turns one decoded message into the changes it represents - none for
+     * bookkeeping messages, one for a row change, and one per table for a
+     * truncate, so that a `tables` filter behaves the same way there.
+     */
+    _toChanges(message, lsn) {
+        let change;
+        switch (message.kind) {
+            case 'commit':
+                this._commitTime = message.commitTime;
+                return [];
+            case 'insert':
+                change = this._build('insert', message.relation, lsn, message.row);
+                break;
+            case 'update':
+                change = this._build('update', message.relation, lsn, message.row, message.oldRow);
+                break;
+            case 'delete':
+                change = this._build('delete', message.relation, lsn, undefined, message.oldRow);
+                break;
+            case 'truncate':
+                return message.relations
+                    .map(relation => this._build('truncate', relation, lsn))
+                    .filter(c => this._accepts(c));
+            default:
+                return [];
+        }
+        return this._accepts(change) ? [change] : [];
+    }
+    _build(command, relation, lsn, row, oldRow) {
+        return {
+            command,
+            relation,
+            schema: relation.schema,
+            table: `${relation.schema}.${relation.name}`,
+            row,
+            oldRow,
+            lsn,
+            timestamp: this._commitTime,
+        };
+    }
+    /** Client-side filtering, on top of whatever the publication already limits. */
+    _accepts(change) {
+        const { commands, tables, filter } = this.options;
+        if (commands && !commands.includes(change.command))
+            return false;
+        if (tables &&
+            !tables.some(t => t === change.table || t === change.relation.name))
+            return false;
+        if (filter && !filter(change))
+            return false;
+        return true;
+    }
+    /** Standby status update: where we have written, flushed and applied. */
+    _sendStatus(replyRequested) {
+        const socket = this._intlCon?.socket;
+        if (!socket)
+            return;
+        const buf = Buffer.allocUnsafe(34);
+        buf[0] = 0x72; // 'r'
+        buf.writeBigUInt64BE(this._receivedLsn, 1);
+        buf.writeBigUInt64BE(this._confirmedLsn, 9);
+        buf.writeBigUInt64BE(this._confirmedLsn, 17);
+        buf.writeBigInt64BE(BigInt(Date.now() - PG_EPOCH_MS) * 1000n, 25);
+        buf[33] = replyRequested ? 1 : 0;
+        socket.sendCopyData(buf);
+    }
+    _resume() {
+        this._intlCon?.socket.resume();
+    }
+    _wake() {
+        const waiting = this._waiting;
+        this._waiting = undefined;
+        waiting?.();
+    }
+    _fail(err) {
+        this._error = this._error || err;
+        this._finished = true;
+        this._wake();
+    }
+}

package/connection/pool.d.ts

@@ -6,27 +6,54 @@ import type { ScriptExecuteOptions } from '../interfaces/script-execute-options.
 import type { ScriptResult } from '../interfaces/script-result.js';
 import type { StatementPrepareOptions } from '../interfaces/statement-prepare-options.js';
 import { SafeEventEmitter } from '../safe-event-emitter.js';
+import { QueryRequest } from '../util/sql-tag.js';
 import { Connection, type NotificationCallback } from './connection.js';
 import { IntlConnection } from './intl-connection.js';
 import type { PreparedStatement } from './prepared-statement.js';
+export interface PoolPipelineOptions {
+    pipeline?: boolean;
+}
+export type PoolQueryOptions = QueryOptions & PoolPipelineOptions;
+export type PoolScriptExecuteOptions = ScriptExecuteOptions & PoolPipelineOptions;
+/**
+ * One pooled connection the pipelined path is currently borrowing.
+ *
+ * A slot joins the list the moment its acquire starts rather than when it
+ * finishes, so callers arriving while a connection is still being opened
+ * queue onto `promise` instead of starting a second acquire of their own.
+ * `load` counts queries handed to this slot that have not settled yet - it
+ * is incremented synchronously, at selection time, which `runningQueryCount`
+ * cannot be: everything in a Promise.all() burst picks its connection before
+ * any of them reaches execute(), so at that point every connection still
+ * reports zero running queries.
+ */
+interface PipelineSlot {
+    connection?: Connection;
+    promise: Promise<Connection>;
+    load: number;
+}
 export declare class Pool extends SafeEventEmitter {
     protected readonly _pool: LightningPool<IntlConnection>;
     protected readonly _notificationListeners: SafeEventEmitter;
     protected _notificationConnection?: Connection;
+    protected readonly _pipelineSlots: PipelineSlot[];
+    protected _pipelineMaxQueries: number;
+    protected _pipelineMaxConnections: number;
     readonly config: PoolConfiguration;
     constructor(config?: PoolConfiguration | string);
     /**
-     * Returns number of connections that are currently acquired
+     * Returns the number of connections that are currently acquired
      */
     get acquiredConnections(): number;
     /**
-     * Returns number of unused connections in the pool
+     * Returns the number of unused connections in the pool
      */
     get idleConnections(): number;
     /**
      * Returns total number of connections in the pool regardless of whether they are idle or in use
      */
     get totalConnections(): number;
+    start(): void;
     /**
      * Obtains a connection from the connection pool
      */
@@ -38,15 +65,45 @@ export declare class Pool extends SafeEventEmitter {
     /**
      * Executes a script
      */
-    execute(sql: string, options?: ScriptExecuteOptions): Promise<ScriptResult>;
+    execute(sql: string | QueryRequest, options?: PoolScriptExecuteOptions): Promise<ScriptResult>;
     /**
      * Executes a query
      */
-    query(sql: string, options?: QueryOptions): Promise<QueryResult>;
+    query(sql: string | QueryRequest, options?: PoolQueryOptions): Promise<QueryResult>;
     prepare(sql: string, options?: StatementPrepareOptions): Promise<PreparedStatement>;
     release(connection: Connection): Promise<void>;
     listen(channel: string, callback: NotificationCallback): Promise<void>;
     unListen(channel: string): Promise<void>;
     unListenAll(): Promise<void>;
+    protected _canPipeline(pipeline: boolean | undefined, sql: string, autoCommit: boolean | undefined, signal: AbortSignal | undefined): boolean;
+    /**
+     * Picks the pooled connection a pipelined query should ride on, or
+     * undefined when the caller should take a connection of its own.
+     *
+     * Deliberately synchronous: it must never await, because everything in a
+     * Promise.all() burst has to pick its connection and reach execute()
+     * within a single event loop tick for PgSocket to coalesce the whole
+     * burst into one write per connection. Opening another connection is
+     * started here but never awaited by the caller that triggered it.
+     */
+    protected _acquireShared(): PipelineSlot | undefined;
+    /**
+     * Starts borrowing one more connection and returns its slot right away,
+     * already carrying the caller that triggered the growth.
+     */
+    protected _growPipeline(): PipelineSlot;
+    /**
+     * Stops new queries joining a slot. Queries already on it are unaffected.
+     */
+    protected _dropPipelineSlot(slot: PipelineSlot): void;
+    /**
+     * Backstop for a transaction startsTransaction() could not see coming -
+     * one opened inside a stored procedure, for instance. The connection is
+     * still sound, but nothing else may join it while it is in a
+     * transaction, so the slot goes away and the connection returns to the
+     * pool once its own queries finish.
+     */
+    protected _checkSharedTransaction(slot: PipelineSlot, connection: Connection): void;
     protected _initNotificationConnection(): Promise<void>;
 }
+export {};