Experimental postgres query (PR 3/4): multi-input + error formatting

[simonfaltum]

PR Stack

1. #5135 — PR 1: scaffold + autoscaling targeting + text output
2. #5136 — PR 2: provisioned + JSON/CSV streaming + types + sqlcli.ResolveFormat
3. PR 3 (this PR) — #5138 — multi-input + multi-statement rejection + error formatting + sqlcli.Collect
4. #5143 — PR 4: cancellation + timeout + TUI

Stacked on PR 2.

Why

PR 2 shipped a single-statement, single-input command. Real workflows want multi-input (set-then-query, file-then-stdin), multi-statement rejection with a friendly hint, and rich pg error formatting.

This PR also extends experimental/libs/sqlcli with input-collection logic shared by aitools and postgres. Same architectural principle as PR 2: instead of postgres growing its own duplicate of aitools' resolveSQLs, both commands now call sqlcli.Collect.

Changes

Architectural: experimental/libs/sqlcli/input.go adds:

• sqlcli.SQLFileExtension const (.sql).
• sqlcli.Input{SQL, Source} type — Source is the human-readable origin label ("--file PATH", "argv[N]", "stdin").
• sqlcli.CollectOptions{Cleaner func(string) string} — aitools passes its cleanSQL (strips comments+quotes); postgres passes the default TrimSpace because its multi-statement scanner needs comments preserved.
• sqlcli.Collect — files-first then positionals, stdin only when neither is present, .sql autodetect on positionals.

aitools' resolveSQLs collapses to a thin wrapper around sqlcli.Collect (drops the SQL strings, ignores Source). The "SQL statement #N is empty after removing comments" wording is replaced with sqlcli's argv[N] is empty; aitools tests updated.

User-facing changes for postgres query:

• Variadic positionals + repeatable --file + stdin fallback.
• Multi-statement strings rejected up front with a hint (the hand-written conservative scanner ignores ; inside string literals, identifiers, line/block comments, and dollar-quoted bodies; tag must be a valid unquoted identifier so $1 and $foo-bar$ are correctly NOT treated as tags).
• Multi-input output: per-unit blocks for text; canonical-shape JSON array {"source","sql","kind","elapsed_ms",...} for json; csv rejected pre-flight when N>1.
• Rich pg error formatting (SEVERITY: message (SQLSTATE XXXXX) with DETAIL/HINT lines), applied on both single-input and multi-input paths.

Single-input keeps streaming. runUnitBuffered is a thin wrapper around executeOne + a bufferSink, so the row-loop and error-wrapping logic stays in one place.

Test plan

• go test ./experimental/... (multistatement scanner: 28 cases including dollar-tag punctuation rejection, sqlcli.Collect: 12 cases including a custom-cleaner test, error formatting, multi-input renderers including byte-equal canonical-shape and first-unit-fails framing)
• go tool ... golangci-lint run ./experimental/... (0 issues)

[arsenyinfo]

Invalid dollar-quote tag character validation allows multi-statement SQL to bypass the single-statement guard

• Priority: P2
• Location: experimental/postgres/cmd/multistatement.go:136-153 (readDollarTag), called from multistatement.go:69-76 (checkSingleStatement), guard enforced at experimental/postgres/cmd/query.go:127-135
• Scenario: User passes input such as SELECT $foo-bar$a;b$foo-bar$. readDollarTag accepts foo-bar as a valid tag because it only rejects a digit-starting first character or whitespace/; anywhere; it does not reject punctuation like -. checkSingleStatement then calls scanDollarBody and skips over the ; as if it were inside a dollar-quoted body. PostgreSQL does not allow - in a dollar-quote tag (tags must follow unquoted-identifier rules: letters, digits, underscores only), so PostgreSQL would actually parse this as two statements. The pre-flight guard passes, the SQL is sent to the server, and either two statements execute or a parse error is returned — violating the guard's contract.
• Potential solution: After the digit-start check (line 144), validate every subsequent tag character against PostgreSQL identifier-continuation rules (Unicode letter, digit, or underscore); return ("", start) on the first character that fails. This prevents punctuation-containing pseudo-tags from being treated as real dollar-quote openers.

---

🔍 Reviewed by nitpicker