neon 3.1.0 → 3.2.0

package/dist/psql/core/common.js

@@ -1,835 +1,2 @@
-import { formatDurationMs } from "../print/units.js";
-import { alignedPrinter } from "../print/aligned.js";
-import { asciidocPrinter } from "../print/asciidoc.js";
-import { csvPrinter } from "../print/csv.js";
-import { htmlPrinter } from "../print/html.js";
-import { jsonPrinter } from "../print/json.js";
-import { latexLongtablePrinter, latexPrinter } from "../print/latex.js";
-import { troffMsPrinter } from "../print/troff.js";
-import { unalignedPrinter } from "../print/unaligned.js";
-import { openPager, shouldPage } from "../print/pager.js";
-import { formatErrorReport, psqlErrorPrefix } from "../command/cmd_meta.js";
-import { getQueryFout } from "../command/cmd_io.js";
-//#region src/psql/core/common.ts
-/**
-* psql common — the unified send-query / process-result pipeline.
-*
-* TypeScript port of selected functions in `src/bin/psql/common.c`:
-*
-*   - {@link sendQuery}        ← `SendQuery`
-*   - {@link executeAndPrint}  ← `ExecQueryAndProcessResults` (the inner
-*                                 result-processing slice, without the
-*                                 AUTOCOMMIT / savepoint scaffolding)
-*   - {@link psqlExec}         ← `PSQLexec`
-*
-* The minimal version of this logic was inlined in `mainloop.ts` after WP-12;
-* this WP extracts and polishes it. The pieces wired in here:
-*
-*   - AUTOCOMMIT: when the variable is 'off' (default 'on') and the current
-*     transaction is idle, prepend `BEGIN` once before the next non-exempt
-*     statement. The set of exempt commands mirrors upstream
-*     `command_no_begin()` — transaction-control verbs and a handful of
-*     non-transactional DDL.
-*
-*   - ON_ERROR_ROLLBACK: 'off' (default) | 'on' | 'interactive'. When active
-*     and we're inside a transaction, issue
-*     `SAVEPOINT pg_psql_temporary_savepoint` before the statement; on error
-*     `ROLLBACK TO`, on success `RELEASE` (unless the statement is itself a
-*     savepoint-management verb that already drops/replaces it).
-*
-*   - FETCH_COUNT: integer; when >0 and the statement is a single SELECT-ish
-*     query, wrap it in `DECLARE _psql_cursor CURSOR FOR ...; FETCH FORWARD
-*     N FROM _psql_cursor` until exhausted. Non-SELECT statements fall back
-*     to the simple path.
-*
-*   - SINGLESTEP: when `settings.singlestep` is true, print the SQL to stderr
-*     with the upstream confirmation banner and read one line from stdin.
-*     Input that starts with 'x' cancels the statement.
-*
-*   - Timing: when `settings.timing` is true, measure wallclock around the
-*     send/print path and write a `Time: X.XXX ms` line to stdout (mirrors
-*     upstream's `printf` in common.c, and matches the existing mainloop
-*     test expectations).
-*
-* What's deliberately not done here:
-*
-*   - SINGLELINE (-S): treating LF as a semicolon is a scanner concern, so it
-*     lives there — `scanSql` honours `ScanOptions.singleline` and the mainloop
-*     passes `settings.singleline` through on each pass. `sendQuery` itself
-*     needs no SINGLELINE branch; by the time a statement reaches here the
-*     scanner has already drawn the boundary.
-*
-*   - Pipeline mode (-X / `\startpipeline`): upstream gates SendQuery on
-*     `pset.send_mode == PSQL_SEND_PIPELINE`; that path is owned by WP-21.
-*
-*   - COPY FROM STDIN / TO STDOUT: upstream's ProcessResult dispatches on
-*     `PGRES_COPY_IN/OUT`. That belongs to WP-16; here we surface a clear
-*     error message if we ever see a copy result come back through
-*     `execSimple`.
-*/
-const readTxStatus = (conn) => {
-	return conn.txStatus ?? "I";
-};
-const SAVEPOINT_NAME = "pg_psql_temporary_savepoint";
-const CURSOR_NAME = "_psql_cursor";
-/**
-* Strip leading whitespace and `--` line / slash-star block comments from
-* `sql`. Mirrors what upstream psql's scanner advances past before handing a
-* statement to `PQexec` — the server-reported error `position` is a 1-based
-* offset into THAT trimmed buffer, so the `LINE N:` re-print computed from
-* `count('\n')` in `sql.slice(0, position - 1)` aligns with vanilla output
-* only when the same leading prelude is stripped here too.
-*
-* Block comments support nested depths (PG extension). Embedded comments
-* mid-statement are intentionally NOT stripped — they participate in the
-* line count of the executing statement, same as upstream.
-*
-* Exported for cmd_io / cmd_pipeline so backslash commands that capture or
-* inspect `queryBuf` see the same shape that the wire and `lastQuery`
-* receive.
-*/
-const stripLeadingCommentsAndWS = (sql) => {
-	let i = 0;
-	const n = sql.length;
-	while (i < n) {
-		const c = sql.charCodeAt(i);
-		if (c === 32 || c === 9 || c === 10 || c === 13 || c === 12 || c === 11) {
-			i++;
-			continue;
-		}
-		if (c === 45 && sql.charCodeAt(i + 1) === 45) {
-			i += 2;
-			while (i < n && sql.charCodeAt(i) !== 10) i++;
-			continue;
-		}
-		if (c === 47 && sql.charCodeAt(i + 1) === 42) {
-			i += 2;
-			let depth = 1;
-			while (i < n && depth > 0) if (sql.charCodeAt(i) === 47 && sql.charCodeAt(i + 1) === 42) {
-				depth++;
-				i += 2;
-			} else if (sql.charCodeAt(i) === 42 && sql.charCodeAt(i + 1) === 47) {
-				depth--;
-				i += 2;
-			} else i++;
-			continue;
-		}
-		break;
-	}
-	return i === 0 ? sql : sql.slice(i);
-};
-/** Strip leading whitespace and SQL comments, then upper-case for matching. */
-const peekKeywords = (sql, count = 3) => {
-	let i = 0;
-	while (i < sql.length) {
-		const ch = sql[i];
-		if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
-			i++;
-			continue;
-		}
-		if (ch === "-" && sql[i + 1] === "-") {
-			const nl = sql.indexOf("\n", i + 2);
-			if (nl === -1) return [];
-			i = nl + 1;
-			continue;
-		}
-		if (ch === "/" && sql[i + 1] === "*") {
-			const end = sql.indexOf("*/", i + 2);
-			if (end === -1) return [];
-			i = end + 2;
-			continue;
-		}
-		break;
-	}
-	return sql.slice(i).split(/[\s,;()]+/u, count + 1).slice(0, count).map((w) => w.toUpperCase());
-};
-/** Mirror of `command_no_begin()` in psql/common.c. */
-const commandNoBegin = (sql) => {
-	const [w0, w1, w2, w3] = peekKeywords(sql, 4);
-	if (!w0) return false;
-	switch (w0) {
-		case "ABORT":
-		case "BEGIN":
-		case "COMMIT":
-		case "END":
-		case "ROLLBACK":
-		case "START":
-		case "SAVEPOINT":
-		case "RELEASE": return true;
-		case "PREPARE": return w1 === "TRANSACTION";
-		case "VACUUM": return true;
-		case "CLUSTER": return w1 === void 0 || w1 === "";
-		case "CREATE":
-			if (w1 === "DATABASE" || w1 === "TABLESPACE") return true;
-			if (w1 === "INDEX" && w2 === "CONCURRENTLY") return true;
-			if (w1 === "UNIQUE" && w2 === "INDEX" && w3 === "CONCURRENTLY") return true;
-			return false;
-		case "DROP":
-			if (w1 === "DATABASE" || w1 === "TABLESPACE") return true;
-			if (w1 === "INDEX" && w2 === "CONCURRENTLY") return true;
-			return false;
-		case "REINDEX":
-			if (w1 === "DATABASE" || w1 === "SYSTEM") return true;
-			if (w1 === "INDEX" && w2 === "CONCURRENTLY") return true;
-			if (w1 === "TABLE" && w2 === "CONCURRENTLY") return true;
-			return false;
-		case "ALTER": return w1 === "SYSTEM";
-		case "DISCARD": return w1 === "ALL";
-		default: return false;
-	}
-};
-/** True when the statement opens with SELECT / VALUES / TABLE / WITH. */
-const isSelectCommand = (sql) => {
-	const [w0] = peekKeywords(sql, 1);
-	return w0 === "SELECT" || w0 === "VALUES" || w0 === "TABLE" || w0 === "WITH";
-};
-/**
-* Does this statement effectively destroy / replace the temporary savepoint?
-* Upstream's `svpt_gone` flag is set when the user's command is one of
-* COMMIT / ROLLBACK / SAVEPOINT / RELEASE. In those cases we must skip the
-* matching RELEASE because the named savepoint no longer exists.
-*/
-const destroysSavepoint = (sql) => {
-	const [w0] = peekKeywords(sql, 1);
-	return w0 === "COMMIT" || w0 === "ROLLBACK" || w0 === "SAVEPOINT" || w0 === "RELEASE";
-};
-const pickPrinter = (settings) => {
-	switch (settings.popt.topt.format) {
-		case "aligned":
-		case "wrapped": return alignedPrinter;
-		case "unaligned": return unalignedPrinter;
-		case "csv": return csvPrinter;
-		case "json": return jsonPrinter;
-		case "html": return htmlPrinter;
-		case "asciidoc": return asciidocPrinter;
-		case "latex": return latexPrinter;
-		case "latex-longtable": return latexLongtablePrinter;
-		case "troff-ms": return troffMsPrinter;
-		default: return alignedPrinter;
-	}
-};
-/**
-* Pick the output target for a query result.
-*
-* Precedence: explicit `oneShot` argument > the settings stash from
-* `\o FILE` (WP-15) > the REPL context's `stdout`.
-*/
-const pickOut = (ctx, oneShot) => {
-	if (oneShot) return oneShot;
-	return getQueryFout(ctx.settings) ?? ctx.stdout;
-};
-const readAutocommit = (settings) => settings.vars.asBool("AUTOCOMMIT", true);
-const readOnErrorRollback = (settings) => {
-	const raw = settings.vars.get("ON_ERROR_ROLLBACK");
-	if (raw === void 0) return settings.onErrorRollback;
-	const v = raw.toLowerCase();
-	if (v === "interactive") return "interactive";
-	if (v === "on" || v === "true" || v === "yes" || v === "1") return "on";
-	return "off";
-};
-const readFetchCount = (settings) => {
-	const v = settings.vars.asInt("FETCH_COUNT", settings.fetchCount);
-	if (typeof v !== "number") return 0;
-	return Math.max(0, v | 0);
-};
-const readSinglestep = (settings) => settings.singlestep || settings.vars.asBool("SINGLESTEP", false);
-/**
-* SHOW_ALL_RESULTS controls multi-statement `\;` printing. Default 'on' —
-* every result set is rendered. When 'off' / '0', only the LAST result set
-* is printed (upstream's `pset.show_all_results` flag, consulted by
-* `PrintQueryResults` in common.c).
-*/
-const readShowAllResults = (settings) => settings.vars.asBool("SHOW_ALL_RESULTS", true);
-const writeError = (ctx, message) => {
-	ctx.stderr.write(`psql: ERROR:  ${message}\n`);
-};
-/**
-* Render the verbosity-aware error report for the most recently captured
-* query error and write it to `ctx.stderr`. The leading severity line gets
-* the same `psql:[<file>:<n>]:` diagnostic prefix that upstream's
-* `pg_log_pre_callback` prepends — matching the format the regression-
-* derived conformance suite expects (e.g. `psql:<stdin>:N: ERROR: ...`).
-* Subsequent layers (`LINE N: ...`, caret, `DETAIL: ...`, ...) follow on
-* their own lines per {@link formatErrorReport}, unprefixed, to match
-* libpq's `PQresultErrorMessage` output shape. When the captured error is
-* missing (defensive — callers should always pair this with a preceding
-* `recordError`) we fall back to the plain client-side {@link writeError}
-* form so we never swallow the message entirely.
-*
-* Exported so the bind-path in mainloop can share the renderer.
-*/
-const writeQueryError = (ctx, fallbackMessage) => {
-	const e = ctx.settings.lastErrorResult;
-	if (!e || !e.message && !e.code && !e.sqlstate) {
-		writeError(ctx, fallbackMessage);
-		return;
-	}
-	const lines = formatErrorReport(e, ctx.settings.verbosity, ctx.settings.showContext);
-	const prefixed = [psqlErrorPrefix(ctx.settings) + lines[0], ...lines.slice(1)];
-	ctx.stderr.write(prefixed.join("\n") + "\n");
-};
-/**
-* Strip leading whitespace from a query and rebase a 1-based server position
-* to match. Mirrors upstream psql/mainloop.c's behaviour: a line containing
-* only a backslash command does not leave a `\n` in the query buffer, so the
-* subsequent SQL statement starts at "line 1" of its own context rather than
-* inheriting a blank line. Our mainloop doesn't perform that strip, so the
-* captured `sqlText` sometimes has a leading `\n` (e.g. after `\set
-* FETCH_COUNT 1\nSELECT error;`). Without this normalisation, `\errverbose`
-* would render `LINE 2: SELECT error;` where upstream renders `LINE 1: …`.
-*
-* Returns the trimmed text and the rebased position. If the rebased
-* position would land outside the trimmed text, it is dropped so the
-* formatter skips the `LINE`/caret block instead of mis-pointing.
-*/
-const normaliseSqlAndPosition = (sqlText, position) => {
-	let leading = 0;
-	while (leading < sqlText.length) {
-		const ch = sqlText.charCodeAt(leading);
-		if (ch !== 32 && ch !== 9 && ch !== 10 && ch !== 13 && ch !== 12) break;
-		leading++;
-	}
-	if (leading === 0) return {
-		sqlText,
-		position
-	};
-	const trimmed = sqlText.slice(leading);
-	if (typeof position !== "string") return {
-		sqlText: trimmed,
-		position
-	};
-	const original = parseInt(position, 10);
-	if (!Number.isFinite(original) || original <= 0) return {
-		sqlText: trimmed,
-		position
-	};
-	const rebased = original - leading;
-	if (rebased <= 0 || rebased > trimmed.length) return {
-		sqlText: trimmed,
-		position: void 0
-	};
-	return {
-		sqlText: trimmed,
-		position: String(rebased)
-	};
-};
-/**
-* Capture the full ErrorResponse-shaped payload from a thrown error.
-*
-* Our wire layer copies every named field of the server's ErrorResponse
-* (severity / code / detail / hint / position / file / line / routine /
-* …) onto the thrown Error as own properties (see `asThrowable` in
-* `wire/connection.ts`). We mirror those onto `settings.lastErrorResult`
-* so `\errverbose` can re-render the error in VERBOSE form — including
-* the `LINE N: …` re-print + `^` pointer and the `LOCATION:` footer.
-*
-* `sqlText` is the originating SQL text from the caller; required so the
-* `^` pointer can be positioned under the failing character. Leading
-* whitespace is stripped (and `position` is rebased) so the `LINE N`
-* counter reflects offsets within the user's statement rather than any
-* buffer noise carried over from prior backslash commands.
-*/
-const captureLastError = (settings, err, sqlText) => {
-	const fallbackMessage = err instanceof Error ? err.message : String(err);
-	const e = err ?? {};
-	const code = e.code;
-	const normalised = normaliseSqlAndPosition(sqlText, e.position);
-	settings.lastErrorResult = {
-		severity: e.severity,
-		code,
-		sqlstate: code,
-		message: e.message ?? fallbackMessage,
-		detail: e.detail,
-		hint: e.hint,
-		position: normalised.position,
-		internalPosition: e.internalPosition,
-		internalQuery: e.internalQuery,
-		where: e.where,
-		schema: e.schema,
-		table: e.table,
-		column: e.column,
-		dataType: e.dataType,
-		constraint: e.constraint,
-		file: e.file,
-		line: e.line,
-		routine: e.routine,
-		sqlText: normalised.sqlText
-	};
-	return settings.lastErrorResult.message ?? fallbackMessage;
-};
-const recordError = (ctx, err, sqlText = "") => captureLastError(ctx.settings, err, sqlText);
-/**
-* Update the per-statement diagnostic psql variables that upstream's
-* `SetResultVariables` / `SetErrorVariables` in `src/bin/psql/common.c`
-* maintains. Called after every dispatched statement (success and error
-* paths) so `\echo :LAST_ERROR_MESSAGE` and friends produce the same
-* values vanilla psql does.
-*
-*   - `SQLSTATE`         SQLSTATE of the *most recent* statement —
-*                        `"00000"` on success, the server-reported code
-*                        on error (defaults to `"XX000"` when missing).
-*   - `ERROR`            `"true"` if the most recent statement failed,
-*                        else `"false"`.
-*   - `ROW_COUNT`        affected/returned row count of the most recent
-*                        statement (from libpq's `PQcmdTuples`). `"0"`
-*                        on error.
-*   - `LAST_ERROR_*`     sticky — only mutated on error. Mirrors
-*                        upstream's "preserve until the next failure"
-*                        contract so a successful statement does not
-*                        clobber the prior error info.
-*
-* Exported so mainloop's bind / pipeline paths (which bypass {@link
-* sendQuery}) can share the same updater.
-*/
-const refreshErrorVars = (settings, outcome) => {
-	const { vars } = settings;
-	if (outcome.kind === "error") {
-		const last = settings.lastErrorResult;
-		const code = last?.code ?? last?.sqlstate ?? "XX000";
-		const message = last?.message ?? "";
-		vars.set("LAST_ERROR_MESSAGE", message);
-		vars.set("LAST_ERROR_SQLSTATE", code);
-		vars.set("SQLSTATE", code);
-		vars.set("ERROR", "true");
-		vars.set("ROW_COUNT", "0");
-		return;
-	}
-	vars.set("SQLSTATE", "00000");
-	vars.set("ERROR", "false");
-	const rc = outcome.rowCount ?? 0;
-	vars.set("ROW_COUNT", String(rc));
-};
-const readOneLine = (stdin) => new Promise((resolve) => {
-	let buf = "";
-	let resolved = false;
-	const onData = (chunk) => {
-		buf += chunk.toString();
-		const nl = buf.indexOf("\n");
-		if (nl !== -1) {
-			const line = buf.slice(0, nl);
-			cleanup();
-			if (!resolved) {
-				resolved = true;
-				resolve(line);
-			}
-		}
-	};
-	const onEnd = () => {
-		cleanup();
-		if (!resolved) {
-			resolved = true;
-			resolve(buf);
-		}
-	};
-	const cleanup = () => {
-		stdin.off("data", onData);
-		stdin.off("end", onEnd);
-		stdin.off("close", onEnd);
-	};
-	stdin.on("data", onData);
-	stdin.once("end", onEnd);
-	stdin.once("close", onEnd);
-});
-const confirmSinglestep = async (ctx, sql) => {
-	ctx.stderr.write(`***(Single step mode: verify command)*******************************************\n${sql}\n***(press return to proceed or enter x and return to cancel)********************\n`);
-	return !(await readOneLine(ctx.stdin)).trim().toLowerCase().startsWith("x");
-};
-/**
-* Reconstruct the libpq-style CommandComplete tag from the parsed parts our
-* wire layer stores on a ResultSet. INSERT carries `oid` + `rowCount`; the
-* other DML verbs (UPDATE/DELETE/MERGE/SELECT/MOVE/FETCH/COPY) carry just a
-* `rowCount`; DDL has neither.
-*
-* Matches upstream psql's `PQcmdStatus(conn)` output (which is the raw tag
-* the server sent — we round-trip it through our parser).
-*/
-const formatCommandTag = (rs) => {
-	const command = (rs.command || "").trim();
-	if (command.length === 0) return "";
-	if (command === "INSERT") return `INSERT ${rs.oid ?? 0} ${rs.rowCount ?? 0}`;
-	if (rs.rowCount !== null && rs.rowCount !== void 0) return `${command} ${rs.rowCount}`;
-	return command;
-};
-/**
-* Decide whether the pager should activate for the given batch of result
-* sets. We page when ANY of the sets-that-will-be-printed (i.e. tuples-
-* producing, and not gated out by SHOW_ALL_RESULTS) crosses the threshold.
-* The decision is centralised here so callers can override individual
-* decision inputs (e.g. tests that inject a fake `output`).
-*/
-const pickPagerDecision = (ctx, results, out) => {
-	const popt = ctx.settings.popt.topt;
-	if (popt.pager === "off") return false;
-	const redirectedOutput = getQueryFout(ctx.settings) !== null;
-	if (redirectedOutput) return false;
-	const showAll = readShowAllResults(ctx.settings);
-	const lastIdx = results.length - 1;
-	for (let i = 0; i < results.length; i++) {
-		const rs = results[i];
-		if (rs.fields.length === 0) continue;
-		if (!(showAll || i === lastIdx)) continue;
-		if (shouldPage({
-			pager: popt.pager,
-			pagerMinLines: popt.pagerMinLines,
-			rowCount: rs.rows.length,
-			colCount: rs.fields.length,
-			output: out,
-			redirectedOutput
-		})) return true;
-	}
-	return false;
-};
-const renderResultSets = async (ctx, results, out) => {
-	const printer = pickPrinter(ctx.settings);
-	let rowsAffected = 0;
-	let rowsPrinted = 0;
-	const showAll = readShowAllResults(ctx.settings);
-	const lastIdx = results.length - 1;
-	const tuplesOnly = ctx.settings.popt.topt.tuplesOnly;
-	const pager = pickPagerDecision(ctx, results, out) ? openPager({
-		pager: ctx.settings.popt.topt.pager,
-		pagerMinLines: ctx.settings.popt.topt.pagerMinLines,
-		stdout: out
-	}) : null;
-	const sink = pager?.spawned ? pager.out : out;
-	try {
-		for (let i = 0; i < results.length; i++) {
-			const rs = results[i];
-			const shouldEmit = showAll || i === lastIdx;
-			if (rs.copyOutBytes && rs.copyOutBytes.length > 0) for (const chunk of rs.copyOutBytes) sink.write(chunk);
-			if (rs.fields.length === 0) {
-				if (shouldEmit && !tuplesOnly && !ctx.settings.quiet && !rs.copyOutBytes) {
-					const tag = formatCommandTag(rs);
-					if (tag.length > 0) sink.write(`${tag}\n`);
-				}
-				rowsAffected += rs.rowCount ?? 0;
-			} else {
-				if (shouldEmit) await printer.printQuery(rs, ctx.settings.popt, sink);
-				rowsPrinted += rs.rows.length;
-			}
-		}
-	} finally {
-		if (pager?.spawned) try {
-			await pager.close();
-		} catch {}
-	}
-	const lastRowCount = results.length === 0 ? null : (() => {
-		const rs = results[results.length - 1];
-		if (rs.fields.length > 0) return rs.rows.length;
-		return rs.rowCount ?? null;
-	})();
-	return {
-		rowsAffected,
-		rowsPrinted,
-		lastRowCount
-	};
-};
-/**
-* Render a single {@link ResultSet} through the active printer and the
-* configured output target (respecting `\o FILE` redirects). Used by the
-* `\bind` / extended-query path in {@link mainloop.dispatchSendQuery} which
-* comes back with a single result instead of the array shape `execSimple`
-* produces. Returns a tally consistent with {@link renderResultSets}.
-*/
-const renderResultSet = (ctx, rs, out) => {
-	return renderResultSets(ctx, [rs], out ?? pickOut(ctx));
-};
-/**
-* Re-base a server-side `position` field so it points into the user's
-* original SQL rather than the synthetic statement we actually sent.
-*
-* The FETCH_COUNT path sends `DECLARE _psql_cursor NO SCROLL CURSOR FOR
-* <userSql>` for the DECLARE leg and `FETCH FORWARD N FROM _psql_cursor`
-* for each fetch. Server error positions (`P` field) come back in the
-* coordinates of whatever query we sent:
-*
-*   - DECLARE-time parser/planner errors carry a position into the DECLARE
-*     statement. We subtract the length of the prefix (`DECLARE … FOR `)
-*     so the caret lands under the failing token in `userSql`.
-*
-*   - FETCH-time runtime errors come from executing the cursor's underlying
-*     query (which IS `userSql`). The server reports the position relative
-*     to that underlying query, so it's already in `userSql` coordinates
-*     and we leave it alone.
-*
-* If we can't rebase a DECLARE-coord position into `userSql` bounds, we
-* strip it rather than render a caret pointing past end-of-line.
-*/
-const rebasePositionForCursor = (err, wrapper, userSql) => {
-	if (!err || typeof err !== "object") return;
-	const e = err;
-	if (typeof e.position !== "string") return;
-	const original = parseInt(e.position, 10);
-	if (!Number.isFinite(original) || original <= 0) return;
-	const stripped = userSql.replace(/;\s*$/u, "");
-	const offset = wrapper.indexOf(stripped);
-	if (offset === -1) return;
-	const rebased = original - offset;
-	if (rebased <= 0 || rebased > userSql.length) {
-		delete e.position;
-		return;
-	}
-	e.position = String(rebased);
-};
-const runCursorLoop = async (ctx, sql, fetchCount, out) => {
-	if (!ctx.settings.db) throw new Error("no connection to the server");
-	const db = ctx.settings.db;
-	const initiallyIdle = readTxStatus(db) === "I";
-	if (initiallyIdle) await db.execSimple("BEGIN");
-	const stripped = sql.replace(/;\s*$/u, "");
-	const declared = `DECLARE ${CURSOR_NAME} NO SCROLL CURSOR FOR ${stripped}`;
-	const fetchSql = `FETCH FORWARD ${String(fetchCount)} FROM ${CURSOR_NAME}`;
-	const rowsAffected = 0;
-	let rowsPrinted = 0;
-	let cursorOpen = false;
-	let currentWrapper = declared;
-	const printer = pickPrinter(ctx.settings);
-	let merged = null;
-	try {
-		await db.execSimple(declared);
-		cursorOpen = true;
-		while (true) {
-			currentWrapper = fetchSql;
-			const sets = await db.execSimple(fetchSql);
-			if (sets.length === 0) break;
-			const rs = sets[sets.length - 1];
-			const chunkRows = rs.rows.length;
-			if (chunkRows === 0) break;
-			if (merged === null) merged = {
-				command: rs.command,
-				fields: rs.fields,
-				rows: rs.rows.slice(),
-				rowCount: rs.rowCount,
-				oid: rs.oid,
-				notices: rs.notices
-			};
-			else for (const row of rs.rows) merged.rows.push(row);
-			rowsPrinted += chunkRows;
-			if (chunkRows < fetchCount) break;
-		}
-		if (merged !== null) {
-			merged.rowCount = merged.rows.length;
-			await printer.printQuery(merged, ctx.settings.popt, out);
-		}
-		await db.execSimple(`CLOSE ${CURSOR_NAME}`);
-		cursorOpen = false;
-		if (initiallyIdle) await db.execSimple("COMMIT");
-		return {
-			rowsAffected,
-			rowsPrinted,
-			lastRowCount: rowsPrinted
-		};
-	} catch (err) {
-		if (merged !== null) {
-			merged.rowCount = merged.rows.length;
-			const partialOpts = {
-				...ctx.settings.popt,
-				topt: {
-					...ctx.settings.popt.topt,
-					defaultFooter: false,
-					stopTable: false
-				}
-			};
-			try {
-				await printer.printQuery(merged, partialOpts, out);
-			} catch {}
-		}
-		rebasePositionForCursor(err, currentWrapper, sql);
-		if (cursorOpen) try {
-			await db.execSimple(`CLOSE ${CURSOR_NAME}`);
-		} catch {}
-		if (initiallyIdle) try {
-			await db.execSimple("ROLLBACK");
-		} catch {}
-		throw err;
-	}
-};
-const executeAndPrint = async (ctx, sqlRaw, opts = {}) => {
-	const sql = stripLeadingCommentsAndWS(sqlRaw);
-	const started = ctx.settings.timing ? performance.now() : 0;
-	const stats = {
-		rowsAffected: 0,
-		rowsPrinted: 0,
-		fetched: false,
-		hadError: false,
-		durationMs: 0
-	};
-	if (!ctx.settings.db) {
-		writeError(ctx, "no connection to the server");
-		stats.hadError = true;
-		return stats;
-	}
-	const out = pickOut(ctx, opts.oneShotOut);
-	const fetchCount = readFetchCount(ctx.settings);
-	let lastRowCount = null;
-	try {
-		if (fetchCount > 0 && isSelectCommand(sql)) {
-			const r = await runCursorLoop(ctx, sql, fetchCount, out);
-			stats.rowsAffected = r.rowsAffected;
-			stats.rowsPrinted = r.rowsPrinted;
-			stats.fetched = true;
-			lastRowCount = r.lastRowCount;
-		} else {
-			const results = await ctx.settings.db.execSimple(sql);
-			const r = await renderResultSets(ctx, results, out);
-			stats.rowsAffected = r.rowsAffected;
-			stats.rowsPrinted = r.rowsPrinted;
-			lastRowCount = r.lastRowCount;
-		}
-	} catch (err) {
-		const partial = err.partialResults;
-		if (partial && partial.length > 0) try {
-			const r = await renderResultSets(ctx, partial, out);
-			stats.rowsAffected = r.rowsAffected;
-			stats.rowsPrinted = r.rowsPrinted;
-		} catch {}
-		const message = recordError(ctx, err, sql);
-		writeQueryError(ctx, message);
-		stats.hadError = true;
-	} finally {
-		if (ctx.settings.timing) {
-			stats.durationMs = performance.now() - started;
-			ctx.stdout.write("\n" + formatDurationMs(stats.durationMs) + "\n");
-		}
-	}
-	refreshErrorVars(ctx.settings, stats.hadError ? { kind: "error" } : {
-		kind: "success",
-		rowCount: lastRowCount
-	});
-	return stats;
-};
-const sendQuery = async (ctx, sqlRaw, opts = {}) => {
-	const sql = stripLeadingCommentsAndWS(sqlRaw);
-	const stats = {
-		rowsAffected: 0,
-		rowsPrinted: 0,
-		fetched: false,
-		hadError: false,
-		durationMs: 0
-	};
-	ctx.settings.lastQuery = sql;
-	if (!ctx.settings.db) {
-		writeError(ctx, "no connection to the server");
-		stats.hadError = true;
-		return stats;
-	}
-	if (readSinglestep(ctx.settings)) {
-		if (!await confirmSinglestep(ctx, sql)) {
-			stats.hadError = true;
-			ctx.settings.lastErrorResult = { message: "command cancelled by user" };
-			return stats;
-		}
-	}
-	const db = ctx.settings.db;
-	const autocommit = readAutocommit(ctx.settings);
-	const onErrorRollback = readOnErrorRollback(ctx.settings);
-	const interactive = !ctx.settings.notty;
-	const started = ctx.settings.timing ? performance.now() : 0;
-	if (!autocommit && readTxStatus(db) === "I" && !commandNoBegin(sql)) try {
-		await db.execSimple("BEGIN");
-	} catch (err) {
-		const message = recordError(ctx, err);
-		writeQueryError(ctx, message);
-		stats.hadError = true;
-		if (ctx.settings.timing) {
-			stats.durationMs = performance.now() - started;
-			ctx.stdout.write("\n" + formatDurationMs(stats.durationMs) + "\n");
-		}
-		return stats;
-	}
-	const savepointActive = onErrorRollback !== "off" && (onErrorRollback === "on" || onErrorRollback === "interactive" && interactive) && readTxStatus(db) === "T";
-	let savepointIssued = false;
-	if (savepointActive) try {
-		await db.execSimple(`SAVEPOINT ${SAVEPOINT_NAME}`);
-		savepointIssued = true;
-	} catch (err) {
-		const message = recordError(ctx, err);
-		writeQueryError(ctx, message);
-		stats.hadError = true;
-		if (ctx.settings.timing) {
-			stats.durationMs = performance.now() - started;
-			ctx.stdout.write("\n" + formatDurationMs(stats.durationMs) + "\n");
-		}
-		return stats;
-	}
-	const out = pickOut(ctx, opts.oneShotOut);
-	const fetchCount = readFetchCount(ctx.settings);
-	let lastRowCount = null;
-	try {
-		if (fetchCount > 0 && isSelectCommand(sql)) {
-			const r = await runCursorLoop(ctx, sql, fetchCount, out);
-			stats.rowsAffected = r.rowsAffected;
-			stats.rowsPrinted = r.rowsPrinted;
-			stats.fetched = true;
-			lastRowCount = r.lastRowCount;
-		} else {
-			const results = await db.execSimple(sql);
-			const r = await renderResultSets(ctx, results, out);
-			stats.rowsAffected = r.rowsAffected;
-			stats.rowsPrinted = r.rowsPrinted;
-			lastRowCount = r.lastRowCount;
-		}
-	} catch (err) {
-		const partial = err.partialResults;
-		if (partial && partial.length > 0) try {
-			const r = await renderResultSets(ctx, partial, out);
-			stats.rowsAffected = r.rowsAffected;
-			stats.rowsPrinted = r.rowsPrinted;
-		} catch {}
-		const message = recordError(ctx, err, sql);
-		writeQueryError(ctx, message);
-		stats.hadError = true;
-	}
-	if (savepointIssued) try {
-		if (stats.hadError) {
-			await db.execSimple(`ROLLBACK TO SAVEPOINT ${SAVEPOINT_NAME}`);
-			await db.execSimple(`RELEASE SAVEPOINT ${SAVEPOINT_NAME}`);
-		} else if (!destroysSavepoint(sql) && readTxStatus(db) === "T") await db.execSimple(`RELEASE SAVEPOINT ${SAVEPOINT_NAME}`);
-	} catch (err) {
-		if (!stats.hadError) {
-			const message = recordError(ctx, err);
-			writeQueryError(ctx, message);
-			stats.hadError = true;
-		}
-	}
-	if (stats.hadError && ctx.settings.echo === "errors") {
-		let stmt = sql;
-		while (true) {
-			const before = stmt.length;
-			stmt = stmt.replace(/^[ \t\n\r\f]+/, "");
-			stmt = stmt.replace(/^--[^\n\r]*/, "");
-			if (stmt.length === before) break;
-		}
-		if (stmt.endsWith("\n")) stmt = stmt.slice(0, -1);
-		ctx.stderr.write(`STATEMENT:  ${stmt}\n`);
-	}
-	refreshErrorVars(ctx.settings, stats.hadError ? { kind: "error" } : {
-		kind: "success",
-		rowCount: lastRowCount
-	});
-	if (ctx.settings.timing) {
-		stats.durationMs = performance.now() - started;
-		ctx.stdout.write("\n" + formatDurationMs(stats.durationMs) + "\n");
-	}
-	return stats;
-};
-const psqlExec = async (conn, sql, ignoreError = false) => {
-	try {
-		const sets = await conn.execSimple(sql);
-		if (sets.length === 0) return null;
-		return sets[sets.length - 1];
-	} catch (err) {
-		if (ignoreError) return null;
-		throw err;
-	}
-};
-const __testing = {
-	commandNoBegin,
-	isSelectCommand,
-	destroysSavepoint,
-	peekKeywords,
-	SAVEPOINT_NAME,
-	CURSOR_NAME
-};
-//#endregion
+import { B as psqlExec, G as writeQueryError, H as renderResultSet, I as __testing, L as captureLastError, R as executeAndPrint, U as sendQuery, V as refreshErrorVars, W as stripLeadingCommentsAndWS, z as pickOut } from "../../_chunks/cmd_pipeline-CUbBO9U_.js";
 export { __testing, captureLastError, executeAndPrint, pickOut, psqlExec, refreshErrorVars, renderResultSet, sendQuery, stripLeadingCommentsAndWS, writeQueryError };