neon 3.1.0 → 3.1.1

package/dist/psql/command/cmd_pipeline.js

@@ -1,596 +1,2 @@
-import { writeErr } from "./shared.js";
-import { alignedPrinter } from "../print/aligned.js";
-import { clearPipelineGateErrors, cmdGdesc } from "./cmd_io.js";
-//#region src/psql/command/cmd_pipeline.ts
-/**
-* psql pipeline / extended-query backslash commands (WP-21).
-*
-* Implements the subset of upstream psql's "pipeline mode" backslash commands
-* that drive the extended protocol directly. These are typically used together
-* with the existing `\g` flow: a `\bind` (or `\parse`) command stashes
-* parameter / statement state on the {@link BackslashContext}'s settings via
-* a Symbol-keyed slot; when the mainloop then sees a `;` (or a `\g`), it can
-* notice the stashed state and route the query through
-* `Connection.query(sql, params)` instead of `execSimple`.
-*
-* Because the mainloop integration is owned by other WPs (and was deliberately
-* left untouched here), this module exposes both the command specs AND a
-* small helper, {@link getPipelineState}, that the mainloop will use to
-* consult the stashed state. The commands operate on the buffered query the
-* same way `\g` does — they execute or queue the buffer and reset it.
-*
-* Commands shipped:
-*
-*   \bind [VALUE ...]        stash params for next ; / \g
-*   \bind_named NAME [V ...] stash params + named prepared statement
-*   \parse NAME              prepare current query buffer as NAME
-*   \close_prepared NAME     Close('S', NAME)
-*   \startpipeline           begin a pipeline session (settings.sendMode)
-*   \endpipeline             end the pipeline session, drain results
-*   \syncpipeline            send Sync mid-pipeline
-*   \sendpipeline            submit the current buffered query w/o waiting
-*   \flushrequest            send Flush
-*   \flush                   alias for \flushrequest
-*   \getresults [N]          drain pending pipeline results
-*   \gdesc                   describe-without-execute the buffered query
-*
-* The set is registered in bulk via {@link registerPipelineCommands}.
-*/
-const BIND_STATE_KEY = Symbol.for("neonctl.psql.bindState");
-const PIPELINE_KEY = Symbol.for("neonctl.psql.pipeline");
-const PREPARED_BY_NAME_KEY = Symbol.for("neonctl.psql.preparedByName");
-const stashOf = (settings) => settings;
-/** Read (and clear) the pending bind params, if any. */
-const consumeBindState = (settings) => {
-	const s = stashOf(settings);
-	const cur = s[BIND_STATE_KEY] ?? null;
-	s[BIND_STATE_KEY] = void 0;
-	return cur;
-};
-/**
-* Peek at the bind stash without consuming. Used by `\g` to decide
-* whether to skip the "empty buffer, no prior query" no-op guard:
-* when a `\bind_named NAME` is pending, the prepared statement carries
-* the SQL server-side so no buffer text is needed.
-*/
-const stagedNamedBindPresent = (settings) => {
-	const cur = stashOf(settings)[BIND_STATE_KEY];
-	return !!cur && cur.byName;
-};
-/** Stash a PreparedStatement for later `\bind_named NAME \g` lookup. */
-const stashPrepared = (settings, name, ps) => {
-	const s = stashOf(settings);
-	let map = s[PREPARED_BY_NAME_KEY];
-	if (!map) {
-		map = /* @__PURE__ */ new Map();
-		s[PREPARED_BY_NAME_KEY] = map;
-	}
-	map.set(name, ps);
-};
-/** Look up a previously-stashed PreparedStatement by name. */
-const lookupPrepared = (settings, name) => {
-	return stashOf(settings)[PREPARED_BY_NAME_KEY]?.get(name) ?? null;
-};
-/** Drop a stashed PreparedStatement (after `\close_prepared`). */
-const dropPrepared = (settings, name) => {
-	const map = stashOf(settings)[PREPARED_BY_NAME_KEY];
-	if (map) map.delete(name);
-};
-/** Peek at the current pipeline session (or null). */
-const getPipelineState = (settings) => stashOf(settings)[PIPELINE_KEY] ?? null;
-const readCounter = (settings, name) => {
-	const raw = settings.vars.get(name);
-	if (raw === void 0) return 0;
-	const n = parseInt(raw, 10);
-	return Number.isFinite(n) && n >= 0 ? n : 0;
-};
-const setCounter = (settings, name, value) => {
-	settings.vars.set(name, String(Math.max(0, value)));
-};
-const bumpCounter = (settings, name, delta) => {
-	setCounter(settings, name, readCounter(settings, name) + delta);
-};
-const resetPipelineCounters = (settings) => {
-	setCounter(settings, "PIPELINE_COMMAND_COUNT", 0);
-	setCounter(settings, "PIPELINE_SYNC_COUNT", 0);
-	setCounter(settings, "PIPELINE_RESULT_COUNT", 0);
-};
-/**
-* Wrap `Pipeline.execute` so each enqueued Execute message bumps
-* `PIPELINE_COMMAND_COUNT`. The wrapping covers both call sites:
-*
-*  - `cmdSendPipeline` (this file) — `\sendpipeline`.
-*  - `dispatchSendQuery` (mainloop) — implicit `;`-queries while pipeline
-*    is active. Mainloop calls `ps.session.execute('', 0)` so the wrapper
-*    fires automatically without mainloop knowing about the var store.
-*
-* The wrapper preserves the original function's `this` binding via `apply`.
-*/
-const wrapSessionForCounters = (session, settings) => {
-	const origExecute = session.execute.bind(session);
-	session.execute = (name, maxRows) => {
-		bumpCounter(settings, "PIPELINE_COMMAND_COUNT", 1);
-		return origExecute(name, maxRows);
-	};
-	return session;
-};
-const errResult = (ctx, message) => {
-	ctx.settings.lastErrorResult = { message };
-	writeErr(`\\${ctx.cmdName}: ${message}\n`);
-	return {
-		status: "error",
-		errorWritten: true
-	};
-};
-/**
-* Coerce any thrown / rejected value into a printable string. The
-* extended-protocol driver in `PgConnection` rejects with raw
-* ConnectError records (`{severity, code, message, detail, ...}`) —
-* not `Error` instances — so `String(err)` would produce
-* `[object Object]` in the conformance output. We probe for a
-* `.message` property (covering both `Error` and the ConnectError
-* shape) and fall back to JSON.stringify only when there's no
-* message field at all.
-*/
-const errorToMessage = (err) => {
-	if (err instanceof Error) return err.message;
-	if (err !== null && typeof err === "object" && "message" in err && typeof err.message === "string") return err.message;
-	try {
-		return JSON.stringify(err);
-	} catch {
-		return String(err);
-	}
-};
-/**
-* Render a pipeline-collected ConnectError to stderr in the upstream
-* shape: a `SEVERITY:  message` line, followed by optional `DETAIL:` /
-* `HINT:` / `CONTEXT:` lines (each on its own line). Matches the
-* subset of `formatErrorReport`-style output the conformance corpus
-* expects from `\endpipeline` for non-FATAL pipeline errors. We
-* inline a minimal renderer here rather than importing the full
-* `formatErrorReport` from `cmd_meta` because we always want the
-* "default verbosity, no LINE/caret context" form — pipeline errors
-* arrive after the buffered query has been reset and we don't carry
-* the originating SQL position through `session.lastError`.
-*/
-const renderPipelineError = (err) => {
-	if (err === null || typeof err !== "object") {
-		writeErr(`ERROR:  ${errorToMessage(err)}\n`);
-		return;
-	}
-	const e = err;
-	if (e.pipelineAborted) {
-		writeErr(`${e.message ?? "Pipeline aborted, command did not run"}\n`);
-		return;
-	}
-	const severity = e.severity ?? "ERROR";
-	const message = e.message ?? "";
-	writeErr(`${severity}:  ${message}\n`);
-	if (e.detail) writeErr(`DETAIL:  ${e.detail}\n`);
-	if (e.hint) writeErr(`HINT:  ${e.hint}\n`);
-	if (e.where) writeErr(`CONTEXT:  ${e.where}\n`);
-};
-const readAllArgs = (ctx) => {
-	const out = [];
-	for (;;) {
-		const arg = ctx.nextArg("normal");
-		if (arg === null) break;
-		out.push(arg);
-	}
-	return out;
-};
-const cmdBind = {
-	name: "bind",
-	helpKey: "bind",
-	run(ctx) {
-		const values = readAllArgs(ctx);
-		stashOf(ctx.settings)[BIND_STATE_KEY] = {
-			name: "",
-			values,
-			byName: false
-		};
-		return Promise.resolve({ status: "ok" });
-	}
-};
-const cmdBindNamed = {
-	name: "bind_named",
-	helpKey: "bind_named",
-	run(ctx) {
-		const name = ctx.nextArg("normal");
-		if (name === null) {
-			stashOf(ctx.settings)[BIND_STATE_KEY] = void 0;
-			return Promise.resolve(errResult(ctx, "missing required argument"));
-		}
-		const values = readAllArgs(ctx);
-		stashOf(ctx.settings)[BIND_STATE_KEY] = {
-			name,
-			values,
-			byName: true
-		};
-		return Promise.resolve({ status: "ok" });
-	}
-};
-const cmdParse = {
-	name: "parse",
-	helpKey: "parse",
-	async run(ctx) {
-		const name = ctx.nextArg("normal");
-		if (name === null) return errResult(ctx, "missing required argument");
-		const sql = ctx.queryBuf;
-		if (sql.trim().length === 0) return errResult(ctx, "no query buffer");
-		if (!ctx.settings.db) return errResult(ctx, "no connection to the server");
-		const pipelineActive = getPipelineState(ctx.settings);
-		if (pipelineActive !== null) try {
-			const session = pipelineActive.session;
-			if (typeof session.parseSlot === "function") await session.parseSlot(name, sql, []);
-			else await session.parse(name, sql, []);
-			ctx.settings.lastQuery = sql;
-			bumpCounter(ctx.settings, "PIPELINE_COMMAND_COUNT", 1);
-			return {
-				status: "reset-buf",
-				newBuf: ""
-			};
-		} catch (err) {
-			return errResult(ctx, errorToMessage(err));
-		}
-		try {
-			const ps = await ctx.settings.db.prepare(name, sql);
-			stashPrepared(ctx.settings, name, ps);
-			ctx.settings.lastQuery = sql;
-			return {
-				status: "reset-buf",
-				newBuf: ""
-			};
-		} catch (err) {
-			return errResult(ctx, errorToMessage(err));
-		}
-	}
-};
-const cmdClosePrepared = {
-	name: "close_prepared",
-	helpKey: "close_prepared",
-	async run(ctx) {
-		const name = ctx.nextArg("normal");
-		if (name === null) return errResult(ctx, "missing required argument");
-		const db = ctx.settings.db;
-		if (!db) return errResult(ctx, "no connection to the server");
-		const ps = getPipelineState(ctx.settings);
-		if (ps !== null) try {
-			const session = ps.session;
-			if (typeof session.closeSlot === "function") await session.closeSlot(name);
-			else await session.close(name);
-			bumpCounter(ctx.settings, "PIPELINE_COMMAND_COUNT", 1);
-			dropPrepared(ctx.settings, name);
-			return { status: "ok" };
-		} catch (err) {
-			return errResult(ctx, errorToMessage(err));
-		}
-		try {
-			if (db.closePreparedStatement) await db.closePreparedStatement(name);
-			else await (await db.prepare(name, "SELECT 1")).close();
-			dropPrepared(ctx.settings, name);
-			return { status: "ok" };
-		} catch (err) {
-			return errResult(ctx, errorToMessage(err));
-		}
-	}
-};
-const cmdStartPipeline = {
-	name: "startpipeline",
-	helpKey: "startpipeline",
-	run(ctx) {
-		if (!ctx.settings.db) return Promise.resolve(errResult(ctx, "no connection to the server"));
-		if (getPipelineState(ctx.settings) !== null) return Promise.resolve({ status: "ok" });
-		try {
-			const session = wrapSessionForCounters(ctx.settings.db.pipeline(), ctx.settings);
-			stashOf(ctx.settings)[PIPELINE_KEY] = {
-				session,
-				pending: [],
-				drainedCount: 0
-			};
-			ctx.settings.sendMode = "extended-pipeline";
-			resetPipelineCounters(ctx.settings);
-			return Promise.resolve({ status: "ok" });
-		} catch (err) {
-			return Promise.resolve(errResult(ctx, errorToMessage(err)));
-		}
-	}
-};
-const cmdEndPipeline = {
-	name: "endpipeline",
-	helpKey: "endpipeline",
-	async run(ctx) {
-		const ps = getPipelineState(ctx.settings);
-		if (!ps) {
-			ctx.settings.lastErrorResult = { message: "cannot send pipeline when not in pipeline mode" };
-			writeErr("cannot send pipeline when not in pipeline mode\n");
-			return {
-				status: "error",
-				errorWritten: true
-			};
-		}
-		try {
-			const alreadyDrained = ps.drainedCount;
-			const session = ps.session;
-			const cmdSlotsSnapshot = Array.isArray(session.cmdSlots) ? session.cmdSlots.slice() : [];
-			const fetchCountActive = (ctx.settings.vars.get("FETCH_COUNT") ?? "0") !== "0";
-			const sets = await ps.session.end();
-			stashOf(ctx.settings)[PIPELINE_KEY] = void 0;
-			ctx.settings.sendMode = "extended-query";
-			resetPipelineCounters(ctx.settings);
-			clearPipelineGateErrors(ctx.settings);
-			const settled = await Promise.allSettled(cmdSlotsSnapshot);
-			let errorRendered = false;
-			const entries = settled.length > 0 ? settled : sets.map((rs) => ({
-				status: "fulfilled",
-				value: rs
-			}));
-			const sliceForError = entries.slice(alreadyDrained);
-			const realLastError = (() => {
-				for (const r of sliceForError) {
-					if (r.status !== "rejected") continue;
-					const reason = r.reason;
-					if (!(typeof reason === "object" && reason !== null && reason.pipelineAborted === true)) return reason;
-				}
-				return null;
-			})() ?? (() => {
-				const le = session.lastError;
-				if (le === null || le === void 0) return null;
-				if (typeof le === "object" && le.pipelineAborted) return null;
-				return le;
-			})();
-			for (let i = alreadyDrained; i < entries.length; i++) {
-				const r = entries[i];
-				if (r.status === "fulfilled") {
-					const rs = r.value;
-					for (const n of rs.notices) {
-						let out = `${n.severity}:  ${n.message}\n`;
-						if (n.detail !== void 0) out += `DETAIL:  ${n.detail}\n`;
-						if (n.hint !== void 0) out += `HINT:  ${n.hint}\n`;
-						writeErr(out);
-					}
-					const isSyncOrPlaceholder = rs.fields.length === 0 && rs.command === "" && rs.rows.length === 0;
-					const isCommandOnly = rs.fields.length === 0 && rs.rows.length === 0 && rs.command !== "";
-					if (!isSyncOrPlaceholder && !isCommandOnly) if (rs.fields.length === 0 && rs.rows.length > 0) {
-						if (!ctx.settings.popt.topt.tuplesOnly) {
-							process.stdout.write("--\n");
-							process.stdout.write(`(${rs.rows.length} ${rs.rows.length === 1 ? "row" : "rows"})\n\n`);
-						}
-					} else await alignedPrinter.printQuery(rs, ctx.settings.popt, process.stdout);
-				} else if (!errorRendered) {
-					const reason = r.reason;
-					const isAborted = typeof reason === "object" && reason !== null && reason.pipelineAborted === true;
-					if (fetchCountActive) writeErr("fetching results in chunked mode failed\n");
-					if (isAborted && realLastError !== null) renderPipelineError(realLastError);
-					else if (isAborted) writeErr("Pipeline aborted, command did not run\n");
-					else renderPipelineError(reason);
-					errorRendered = true;
-				}
-			}
-			if (!errorRendered) {
-				const lastErr = session.lastError;
-				if (lastErr !== null && lastErr !== void 0) {
-					if (fetchCountActive) writeErr("fetching results in chunked mode failed\n");
-					renderPipelineError(lastErr);
-				}
-			}
-			return { status: "ok" };
-		} catch (err) {
-			stashOf(ctx.settings)[PIPELINE_KEY] = void 0;
-			ctx.settings.sendMode = "extended-query";
-			resetPipelineCounters(ctx.settings);
-			clearPipelineGateErrors(ctx.settings);
-			return errResult(ctx, errorToMessage(err));
-		}
-	}
-};
-const cmdSyncPipeline = {
-	name: "syncpipeline",
-	helpKey: "syncpipeline",
-	async run(ctx) {
-		const ps = getPipelineState(ctx.settings);
-		if (!ps) return errResult(ctx, "no pipeline active");
-		try {
-			await ps.session.sync();
-			const queued = readCounter(ctx.settings, "PIPELINE_COMMAND_COUNT");
-			setCounter(ctx.settings, "PIPELINE_COMMAND_COUNT", 0);
-			bumpCounter(ctx.settings, "PIPELINE_RESULT_COUNT", queued);
-			bumpCounter(ctx.settings, "PIPELINE_SYNC_COUNT", 1);
-			return { status: "ok" };
-		} catch (err) {
-			return errResult(ctx, errorToMessage(err));
-		}
-	}
-};
-const cmdFlushRequest = {
-	name: "flushrequest",
-	helpKey: "flushrequest",
-	async run(ctx) {
-		const ps = getPipelineState(ctx.settings);
-		if (!ps) return errResult(ctx, "no pipeline active");
-		try {
-			await ps.session.flush();
-			const queued = readCounter(ctx.settings, "PIPELINE_COMMAND_COUNT");
-			setCounter(ctx.settings, "PIPELINE_COMMAND_COUNT", 0);
-			bumpCounter(ctx.settings, "PIPELINE_RESULT_COUNT", queued);
-			return { status: "ok" };
-		} catch (err) {
-			return errResult(ctx, errorToMessage(err));
-		}
-	}
-};
-const cmdFlush = {
-	name: "flush",
-	helpKey: "flush",
-	run(ctx) {
-		return cmdFlushRequest.run(ctx);
-	}
-};
-const cmdSendPipeline = {
-	name: "sendpipeline",
-	helpKey: "sendpipeline",
-	async run(ctx) {
-		const ps = getPipelineState(ctx.settings);
-		if (!ps) {
-			consumeBindState(ctx.settings);
-			ctx.settings.lastErrorResult = { message: "\\sendpipeline not allowed outside of pipeline mode" };
-			writeErr("\\sendpipeline not allowed outside of pipeline mode\n");
-			return {
-				status: "error",
-				errorWritten: true
-			};
-		}
-		const bind = consumeBindState(ctx.settings);
-		if (bind === null) {
-			ctx.settings.lastErrorResult = { message: "\\sendpipeline must be used after \\bind or \\bind_named" };
-			writeErr("\\sendpipeline must be used after \\bind or \\bind_named\n");
-			return {
-				status: "error",
-				errorWritten: true
-			};
-		}
-		const sql = ctx.queryBuf.trim();
-		const stmtName = bind.name;
-		const params = bind.values;
-		if (!bind.byName && sql.length === 0) return errResult(ctx, "no query buffer");
-		try {
-			if (!bind.byName) await ps.session.parse("", sql, []);
-			await ps.session.bind(stmtName, params);
-			const exec = (async () => {
-				await ps.session.execute("", 0);
-				return {
-					command: "",
-					rowCount: null,
-					oid: null,
-					fields: [],
-					rows: [],
-					notices: []
-				};
-			})();
-			ps.pending.push(exec);
-			return {
-				status: "reset-buf",
-				newBuf: ""
-			};
-		} catch (err) {
-			return errResult(ctx, errorToMessage(err));
-		}
-	}
-};
-const cmdGetResults = {
-	name: "getresults",
-	helpKey: "getresults",
-	async run(ctx) {
-		const ps = getPipelineState(ctx.settings);
-		const arg = ctx.nextArg("normal");
-		let requested = null;
-		if (arg !== null && arg.length > 0) {
-			const parsed = parseInt(arg, 10);
-			if (!Number.isFinite(parsed) || parsed < 0) return errResult(ctx, "invalid number of requested results");
-			requested = parsed;
-		}
-		if (!ps) {
-			process.stdout.write("No pending results to get\n");
-			return { status: "ok" };
-		}
-		const syncAvailable = readCounter(ctx.settings, "PIPELINE_SYNC_COUNT");
-		const resultAvailable = readCounter(ctx.settings, "PIPELINE_RESULT_COUNT");
-		const available = syncAvailable + resultAvailable;
-		if (available === 0) {
-			process.stdout.write("No pending results to get\n");
-			return { status: "ok" };
-		}
-		const n = requested === null || requested === 0 ? available : Math.min(requested, available);
-		const session = ps.session;
-		const slots = Array.isArray(session.cmdSlots) ? session.cmdSlots : [];
-		const start = ps.drainedCount;
-		const end = start + n;
-		const slice = slots.slice(start, end);
-		ps.drainedCount = end;
-		ps.pending.splice(0, n);
-		try {
-			const settled = await Promise.allSettled(slice);
-			const sliceErr = (() => {
-				for (const r of settled) {
-					if (r.status !== "rejected") continue;
-					const reason = r.reason;
-					if (!(typeof reason === "object" && reason !== null && reason.pipelineAborted === true)) return reason;
-				}
-				return null;
-			})();
-			const sessPeek = session;
-			const realErr = sliceErr ?? (typeof sessPeek.peekRealError === "function" ? await sessPeek.peekRealError() : null);
-			let errorRenderedHere = false;
-			let walkedItems = 0;
-			let syncsDrained = 0;
-			let resultsDrained = 0;
-			for (const r of settled) {
-				walkedItems++;
-				if (r.status !== "fulfilled") {
-					resultsDrained++;
-					if (!errorRenderedHere) {
-						const reason = r.reason;
-						if (typeof reason === "object" && reason !== null && reason.pipelineAborted === true && realErr !== null) renderPipelineError(realErr);
-						else renderPipelineError(reason);
-						errorRenderedHere = true;
-					}
-					continue;
-				}
-				const rs = r.value;
-				for (const n of rs.notices) {
-					let out = `${n.severity}:  ${n.message}\n`;
-					if (n.detail !== void 0) out += `DETAIL:  ${n.detail}\n`;
-					if (n.hint !== void 0) out += `HINT:  ${n.hint}\n`;
-					writeErr(out);
-				}
-				if (rs.fields.length === 0 && rs.command === "" && rs.rows.length === 0) {
-					syncsDrained++;
-					continue;
-				}
-				resultsDrained++;
-				if (rs.fields.length === 0 && rs.rows.length > 0) {
-					if (!ctx.settings.popt.topt.tuplesOnly) {
-						process.stdout.write("--\n");
-						process.stdout.write(`(${rs.rows.length} ${rs.rows.length === 1 ? "row" : "rows"})\n\n`);
-					}
-				} else if (rs.fields.length > 0) await alignedPrinter.printQuery(rs, ctx.settings.popt, process.stdout);
-			}
-			const sessMark = session;
-			if (typeof sessMark.markDrained === "function") sessMark.markDrained(end);
-			if (errorRenderedHere) {
-				const sessAny = session;
-				if (typeof sessAny.clearLastError === "function") sessAny.clearLastError();
-			}
-			if (walkedItems === 0) {
-				const ddata = Math.min(n, resultAvailable);
-				resultsDrained = ddata;
-				syncsDrained = n - ddata;
-			} else {
-				const actualSyncs = Math.min(syncsDrained, syncAvailable);
-				const extraResults = syncsDrained - actualSyncs;
-				syncsDrained = actualSyncs;
-				resultsDrained += extraResults;
-			}
-			bumpCounter(ctx.settings, "PIPELINE_SYNC_COUNT", -syncsDrained);
-			bumpCounter(ctx.settings, "PIPELINE_RESULT_COUNT", -resultsDrained);
-			return { status: "ok" };
-		} catch (err) {
-			return errResult(ctx, errorToMessage(err));
-		}
-	}
-};
-const registerPipelineCommands = (registry) => {
-	registry.register(cmdBind);
-	registry.register(cmdBindNamed);
-	registry.register(cmdParse);
-	registry.register(cmdClosePrepared);
-	registry.register(cmdStartPipeline);
-	registry.register(cmdEndPipeline);
-	registry.register(cmdSyncPipeline);
-	registry.register(cmdFlushRequest);
-	registry.register(cmdFlush);
-	registry.register(cmdSendPipeline);
-	registry.register(cmdGetResults);
-};
-//#endregion
+import { C as cmdGdesc, _ as stagedNamedBindPresent, a as cmdFlush, c as cmdParse, d as cmdSyncPipeline, f as consumeBindState, g as registerPipelineCommands, h as lookupPrepared, i as cmdEndPipeline, l as cmdSendPipeline, m as getPipelineState, n as cmdBindNamed, o as cmdFlushRequest, p as dropPrepared, r as cmdClosePrepared, s as cmdGetResults, t as cmdBind, u as cmdStartPipeline, v as stashPrepared } from "../../_chunks/cmd_pipeline-CUbBO9U_.js";
 export { cmdBind, cmdBindNamed, cmdClosePrepared, cmdEndPipeline, cmdFlush, cmdFlushRequest, cmdGdesc, cmdGetResults, cmdParse, cmdSendPipeline, cmdStartPipeline, cmdSyncPipeline, consumeBindState, dropPrepared, getPipelineState, lookupPrepared, registerPipelineCommands, stagedNamedBindPresent, stashPrepared };

package/dist/psql/command/dispatch.js

@@ -2,9 +2,8 @@ import { writeErr } from "./shared.js";
 import { scanSlashArgs } from "../scanner/slash.js";
 import { registerConnectCommands } from "./cmd_connect.js";
 import { cmdCd, cmdCopyright, cmdEcho, cmdEdit, cmdErrverbose, cmdGetenv, cmdHelpSQL, cmdPrompt, cmdQecho, cmdQuit, cmdReset, cmdS, cmdSet, cmdSetenv, cmdShell, cmdSlashHelp, cmdTiming, cmdUnset, cmdWarn } from "./cmd_meta.js";
+import { F as registerIoCommands, g as registerPipelineCommands } from "../../_chunks/cmd_pipeline-CUbBO9U_.js";
 import { cmdA, cmdC, cmdEncoding, cmdF, cmdH, cmdPset, cmdT, cmdTitleAttr, cmdX } from "./cmd_format.js";
-import { registerIoCommands } from "./cmd_io.js";
-import { registerPipelineCommands } from "./cmd_pipeline.js";
 import { registerCopyCommands } from "./cmd_copy.js";
 import { registerDescribeCommands } from "./cmd_describe.js";
 import { registerLargeObjectCommands } from "./cmd_lo.js";