Skip to content

Add a harness that runs the ClickHouse core SQL tests through the driver - #624

Merged
ccoltx merged 6 commits into
masterfrom
polyglot/core-sql-tests
Nov 19, 2026
Merged

ccoltx merged 6 commits into
masterfrom
polyglot/core-sql-tests

Conversation

@polyglotAI-bot

@polyglotAI-bot polyglotAI-bot commented Nov 19, 2026 •

Copy link
Copy Markdown
Collaborator

Summary

This PR adds a harness that runs the ClickHouse core SQL tests (tests/queries/0_stateless) through the driver. It finds driver bugs: the upstream .reference files are the oracle for the result sets that the driver gives to an application.

test/clickhouse-test-runner is a C++ program that imitates clickhouse-client well enough for the upstream runner (tests/clickhouse-test) to drive it without changes. The program is an ODBC application:

  • It loads the ANSI driver through unixODBC (SQLDriverConnect with Driver=<path to libclickhouseodbc.so>, no DSN).
  • It sends each statement with SQLExecDirect. It reads the column metadata with SQLDescribeCol and SQLColAttribute, and each value with SQLGetData and the C type of the reported SQL type (for example SQL_C_NUMERIC for SQL_DECIMAL, SQL_C_TYPE_TIMESTAMP for SQL_TYPE_TIMESTAMP, SQL_C_GUID for SQL_GUID). Errors come from SQLGetDiagRec.
  • A type-directed renderer writes the values as TabSeparated text, as the server does. A live test compares this text with the server's own FORMAT TSV output for many expressions.
  • The session: one session_id in the query string of Url for all requests of an invocation. The command-line settings (log_comment, max_insert_threads, max_threads, send_logs_level) go in the Url query string, so with each query, not as SET.
  • One protocol (HTTP) and one backend: the driver's default result format, ODBCDriver2. An optional rowbinary backend (RowBinaryWithNamesAndTypes) is for driver development only. It is not in CI, and the README lists its gaps.

The program is a separate CMake project. The root CMakeLists.txt does not include it, so the driver build does not change. This is a port of the Go harness (ClickHouse/clickhouse-go#2141).

Tracking issue: ClickHouse/integrations#814

Results

Server and tests pinned together: 26.10.4.207 (test/clickhouse-test-runner/clickhouse-version; the upstream tag v26.10.4.207-stable).

  • First sweep of all 12,961 .sql tests: 9,356 OK, 2,679 FAIL, 926 skipped (tags), 844 s at -j 6. Each failure has a cause (environment, driver, or shim).
  • Allowlist: 9,176 tests (backend odbcdriver2, HTTP). No only= lines (one protocol).
  • Known failures: 1,414 tests in 15 groups: 1,127 in 10 driver groups, 287 in 5 shim groups. No [untriaged] group. KNOWN_FAILURES=all runs them: 1,414 of 1,414 fail, each with the error of its group.
  • 237 passing tests are left out for environment causes that only show under load (AGENTS.md, "Tests that are left out for load").
  • 04101_variant_adaptor_propagate_exceptions is left out after the first CI run: it expects MEMORY_LIMIT_EXCEEDED at max_memory_usage = 2000000, a limit set for the native protocol. Over HTTP the memory of the statement depends on the output format (curl: no error with FORMAT Null and FORMAT ODBCDriver2); it failed on the CI runner and passed locally (AGENTS.md, "Environment causes").
  • Three checks on a fresh server at -j 6 (more parallel than CI): 9,177 OK, 0 FAIL each, 526-529 s (before 04101_variant_adaptor_propagate_exceptions was left out).
  • CI: a build job builds the driver once (Release, Clang 18, as Linux.yml), and runs the unit tests of the shim with Clang 18 and GCC 11, with warnings as errors. Then 4 shards of about 2,300 tests each, at -j 4. Each test job runs SYSTEM FLUSH LOGS once when the server answers: on a new server the system log tables (system.query_log and others) exist only after the first flush, and 04409_system_documentation_source_and_entities failed when it ran as one of the first tests of a shard. Shard 1 measured about 3 minutes on 4 CPUs.
  • src/errorcodes.cpp (error names for the test hints) is generated by scripts/gen-error-codes.sh from src/Common/ErrorCodes.cpp of the upstream checkout. It is committed, because the build job compiles the shim before it gets the upstream tests. For the pinned version, the test jobs fail when the committed file is not the same as the generated one.

Client bugs found

These are not fixed in this PR, and no issues are filed. The maintainers decide. All are over HTTP (the only protocol of the driver), with the ANSI driver.

Groups in allowlist.txt (known failures):

  • [type-name-string] (798 tests): the driver gives the base type name only. SQL_DESC_TYPE_NAME is String for Array, Tuple, Map, Enum, IPv4/IPv6, Int128/Int256, Time64 and other types, and Nullable(...), LowCardinality(...) and type parameters are lost. So an application cannot tell an Array(String) from a String. The full name is in the ODBCDriver2 header, but no call returns it.
    • SQLExecDirect("SELECT ['a']"); SQLColAttribute(1, SQL_DESC_TYPE_NAME) → actual String (SQL_VARCHAR); expected Array(String).
  • [escape-scan] (120): ODBC escape processing changes string literals, without an error. replaceEscapeSequences also runs inside '...'.
    • SQLExecDirect("SELECT 'a{}b'") → actual ab; expected a{}b. (SQL_ATTR_NOSCAN = SQL_NOSCAN_ON stops it.)
  • [sql-scan-ternary] (117): the ternary operator c ? a : b cannot be sent: each ? outside quotes is a parameter marker, also with SQL_ATTR_NOSCAN. Maybe by design.
    • SQLExecDirect("SELECT 1 ? 2 : 3") → actual SYNTAX_ERROR; expected 2.
  • [numeric-64bit] (30): SQL_C_NUMERIC fails for values over 2^64-1. The internal value of the driver has 64 bits; SQL_NUMERIC_STRUCT.val has 128.
    • SELECT toDecimal128('18446744073709551616', 0); SQLGetData with SQL_ARD_TYPE = SQL_C_NUMERIC (38, 0) → actual "value is too big for internal representation"; expected the value.
  • [year-zero] (20): Date32 / DateTime64 in year 0000 read as 1970 through the struct types (silent wrong value). value_manip::normalize_date maps year 0 to 1970.
    • SELECT makeDate32(0, 1, 2); SQLGetData(SQL_C_TYPE_DATE) → actual 1970-01-02; expected 0000-01-02 (SQL_C_CHAR gives 0000-01-02).
  • [time-range] (18): Time is reported as SQL_TYPE_TIME, but holds -999:59:59 .. 999:59:59, so values outside 00:00:00 .. 23:59:59 fail as SQL_C_TYPE_TIME.
    • SELECT toTime('24:00:00'); SQLGetData(SQL_C_TYPE_TIME) → actual [HY000] Cannot interpret '24:00:00' as TIME; expected a SQL type whose C type holds the value.
  • [sql-scan] (10): the parameter-marker scan knows only '...' and "...", not comments, backticks or $$...$$. Wrong values without an error, or [42000].
    • SQLExecDirect("SELECT $$a?b$$") → actual a{odbc_positional_1:Nullable(Nothing)}b; expected a?b.
    • SQLExecDirect("SELECT 1 -- what @ is this") → actual [42000]; expected 1.
  • [float-subnormal] (6): SQL_C_DOUBLE / SQL_C_FLOAT fail for subnormal values (std::stod / std::stof give out_of_range).
    • SELECT toFloat64(5e-324); SQLGetData(SQL_C_DOUBLE) → actual "Cannot interpret '5e-324' as double"; expected 4.94e-324.
  • [sql-scan-at-sign] (5): ClickHouse syntax with @ is taken as a named parameter.
    • SQLExecDirect("DROP USER IF EXISTS u1@'%'") → actual [42000] Syntax error or access violation; expected success.
  • [datetime-output-format] (3): with date_time_output_format other than simple, SQL_C_TYPE_TIMESTAMP fails, because the driver parses the server's output text.
    • SELECT toDateTime('2020-10-14 21:00:00', 'UTC') SETTINGS date_time_output_format = 'iso'; SQLGetData(SQL_C_TYPE_TIMESTAMP) → actual "Cannot interpret '2020-10-14T21:00:00Z' as TIMESTAMP"; expected the timestamp.

Bugs found with the bug classes of the Go harness. No test in the allowlist shows them, because the shim does not use these functions:

  • [dt64-param-range]: a bound SQL_TYPE_TIMESTAMP parameter outside 1677-09-21 .. 2262-04-11 fails. The driver always sends it as DateTime64(9) (int64 nanoseconds), whatever the DecimalDigits (driver/utils/type_info.cpp).
    • SQLBindParameter(SQL_C_TYPE_TIMESTAMP, SQL_TYPE_TIMESTAMP, 29, 9) with 1600-01-01 00:00:00.123, INSERT into a DateTime64(3) column → actual DECIMAL_OVERFLOW ... cannot be parsed as Nullable(DateTime64(9)); expected the row. A literal in the SQL text works.
  • [timeout-no-cancel]: after a driver timeout, the query keeps running on the server and the session stays locked. Timeout drops the HTTP request only, and SQLCancel only closes the cursor.
    • Timeout=1 and a session_id; SQLExecDirect("SELECT sleep(3)") → [HY000] Timeout (expected SQLSTATE HYT00). Each next statement on the connection fails with SESSION_IS_LOCKED until the server query ends; expected: the server query is cancelled.
  • [driver-sql-in-session]: SQLGetInfo(SQL_DBMS_VER) and the catalog functions that build SQL (SQLTables, SQLColumns, SQLGetTypeInfo) run their SQL in the user's session. They are in query_log as the user's queries, and fail when the session has another dialect.
    • SET allow_experimental_kusto_dialect = 1, SET dialect = 'kusto', then SQLGetInfo(SQL_DBMS_VER) or SQLTables → actual SYNTAX_ERROR; expected the value or the list. (SQLExecDirect sends no query of its own.)
  • [session-off-by-default] (by design and documented, for a decision): without AutoSessionId=on or a session_id in Url, each statement runs in a new session, without an error or a warning.
    • SQLExecDirect("SET max_threads = 3") → SQL_SUCCESS; then SELECT getSetting('max_threads') gives the server default. CREATE TEMPORARY TABLE t ... succeeds, then SELECT count() FROM t gives UNKNOWN_TABLE.

Shim gaps (groups marked shim in allowlist.txt; not driver bugs):

  • [shim-output-format] (280): output formats other than the TabSeparated family and Null. The driver reads only ODBCDriver2 / RowBinaryWithNamesAndTypes, so the shim renders results itself, and does not implement Vertical, Pretty*, JSON*, CSV and binary formats.
  • [shim-output-setting] (4): settings that change the server's text output (output_format_decimal_trailing_zeros, format_tsv_null_representation, ...).
  • [shim-explain-ast-format] (1), [shim-format-null-error-text] (1), [shim-kql-split] (1): see the group headers.

Server-side or format causes, for a person to look at (not listed as known failures, see AGENTS.md, "Environment causes"):

  • ODBCDriver2 has no marker for the totals row: with WITH TOTALS, the totals row comes as a data row (109 tests).
  • ODBCDriver2 sends no extremes with extremes = 1 (13 tests).
  • Over HTTP, the response of a query without output (FORMAT Null) can end before the server queues its QueryFinish row in query_log, so a SYSTEM FLUSH LOGS in the next request can miss it. A plain curl shows the same race under load; the real client (TCP) does not. 92 tests are left out for it.

Run locally

Build the driver (build/driver/libclickhouseodbc.so), start the pinned server, then:

test/clickhouse-test-runner/scripts/fetch-upstream.sh
test/clickhouse-test-runner/scripts/run-upstream-tests.sh -j 8

KNOWN_FAILURES=<group-id> runs one group. scripts/run-with-real-client.sh runs the same tests through the real clickhouse-client (for triage). The README has the details: the environment variables, how the shim imitates clickhouse-client, the allowlist format, how to grow the allowlist, CI, and how to bump the version. AGENTS.md has the triage rules.

Checks

  • Shim: builds with Clang 18, GCC 12 and GCC 11 with warnings as errors; unit tests 36/36; live test 10/10.
  • clang-format 18 with the repository's .clang-format: clean. (clang-format 18 refuses that file, because two keys occur two times; the README shows the check with a copy that keeps the last value of each key.) shellcheck -x, actionlint: clean.
  • Driver build: not changed (the root CMakeLists.txt does not include test/).
  • No changelog entry and no version bump: the harness is not a part of the driver.

🤖 Generated with Claude Code


Note

Low Risk
Adds isolated test/CI tooling and documentation without changing driver runtime code; main impact is new GitHub Actions cost and workflow maintenance.

Overview
Introduces test/clickhouse-test-runner, an ODBC-based clickhouse-client shim that lets upstream tests/clickhouse-test run ClickHouse 0_stateless SQL tests against the ANSI driver, with TabSeparated rendering from SQLGetData, session/FORMAT/hint handling, unit tests, and live_test.py.

Adds .github/workflows/upstream-sql-tests.yml: build the driver and verify the shim under Clang/GCC, fetch pinned upstream tests (26.10.4.207), run a large allowlist in four CI shards, optional manual version override, and failure artifacts. Shell helpers handle upstream checkout, sharding, and triage via the real client.

Root AGENTS.md now points agents at harness triage rules; the shim is a separate CMake project and does not modify the driver build.

Reviewed by Cursor Bugbot for commit 884a740. Bugbot is set up for automated code reviews on this repo. Configure here.

test/clickhouse-test-runner is a C++ program on the ODBC API (unixODBC,
the ANSI driver) that imitates clickhouse-client, so that the core runner
(tests/clickhouse-test of ClickHouse/ClickHouse) drives the driver
unchanged. It sends each statement with SQLExecDirect, reads the columns
with SQLDescribeCol / SQLColAttribute and SQLGetData (the C type of the
reported SQL type), and writes the values as TabSeparated text with a
type-directed renderer. The .reference files of the upstream tests are
then the oracle for the driver's result sets.

- The shim, its unit tests (GoogleTest) and a live test that compares
  its rendering with the server's FORMAT TSV output.
- allowlist.txt: 9,177 tests, and 1,414 known failures in 15 groups
  (10 driver groups, 5 shim groups), each with a reproduction.
- The version pin (26.10.4.207), scripts to fetch the upstream tests of
  that version, to run the allowlist (shards, KNOWN_FAILURES=<id>) and
  to run the same tests through the real clickhouse-client.
- The workflow upstream-sql-tests.yml: nightly, manual (with a
  clickhouse_version input) and on changes to the harness; the driver is
  built once, then 4 shards.
- README.md, AGENTS.md (the triage rules), CLAUDE.md, and a pointer in
  the root AGENTS.md.

src/errorcodes.cpp is generated by scripts/gen-error-codes.sh from the
upstream checkout. It is committed, because the build job compiles the
shim before any checkout; the test jobs check that it is up to date.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@github-actions

github-actions Bot commented Nov 19, 2026 •

Copy link
Copy Markdown

AI review gate — AI review passed

Clean review from: Cursor Bugbot.

polyglotAI-bot and others added 2 commits November 19, 2026 08:52
The test sets max_memory_usage = 2000000 so that the native protocol
throws MEMORY_LIMIT_EXCEEDED inside FUNCTION moduloOrZero. Over HTTP the
memory of the statement is different and depends on the output format:

- real clickhouse-client (TCP), FORMAT Null: MEMORY_LIMIT_EXCEEDED in
  FUNCTION moduloOrZero, as the test expects;
- curl (HTTP), FORMAT Null and FORMAT ODBCDriver2: no error, peak 1.17 MB;
- curl (HTTP), FORMAT TSV: MEMORY_LIMIT_EXCEEDED, but in
  ParallelFormattingOutputFormat.

The shim sends a statement with an expected error without FORMAT Null,
so the result depends on the ODBCDriver2 output path of the server. The
test passed in all local checks and failed on the CI runner (the query
succeeded). This is an environment cause (the HTTP interface), not a
driver bug, so the test is not listed (rule 7). AGENTS.md now names
this case under the environment causes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
On a new server, the system log tables (system.query_log and others)
exist only after the first flush of the logs. The CI server runs no
query before the tests, so a test that reads these tables fails when it
is one of the first tests of a shard.
04409_system_documentation_source_and_entities expects the row of
system.query_log in system.documentation; it failed as the 7th test of
shard 4. On a new 26.10.4.207 server the row is missing, and one
SYSTEM FLUSH LOGS adds it (the same with clickhouse-client).

The workflow now runs SYSTEM FLUSH LOGS when the server answers. The
README gives the same step for local runs, and AGENTS.md names the case
under the environment causes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@polyglotAI-bot
polyglotAI-bot marked this pull request as ready for review November 19, 2026 10:12
@polyglotAI-bot
polyglotAI-bot requested review from a team and slabko as code owners November 19, 2026 10:12

@cursor cursor Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Cursor Bugbot has reviewed your changes using high effort and found 2 potential issues.

Fix All in Cursor

❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, have a team admin enable autofix in the Cursor dashboard.

Reviewed by Cursor Bugbot for commit 06a65d0. Configure here.

@connectorsec

Copy link
Copy Markdown

ConnectorSec security review — head 06a65d0

1. The program log writes the password in clear, and CI uploads that log as a public artifact — test/clickhouse-test-runner/src/runner.cpp:180, test/clickhouse-test-runner/src/main.cpp:85

  • Scenario: connect() logs the whole connection string, PWD= value included (runner.cpp:180), and run() logs the raw argv, including the value of --password (main.cpp:85). In CI, CLICKHOUSE_CLIENT_CLI_LOG is upstream-run.log (upstream-sql-tests.yml:214). When any shard fails, that file goes into a public artifact that is kept for 14 days (lines 222-231). GitHub masks registered secrets only in console output, never in artifacts. Nothing is exposed at this head: the job connects as the passwordless default user of a local container, and only empty or upstream test-fixture passwords reach the log. But the program supports --password and --secure. The first run against a server with a real password, for example a Cloud leg that reuses the secrets Linux.yml already has, would write that password in clear to the uploaded file.
  • Fix: log a copy of the connection string with the password replaced, and redact the --password value in the logged argv. The default argument keeps runner_test.cpp:48 unchanged.
--- a/test/clickhouse-test-runner/src/runner.h
+++ b/test/clickhouse-test-runner/src/runner.h
@@
-    std::string connectionString() const;
+    std::string connectionString(bool redact_password = false) const;
--- a/test/clickhouse-test-runner/src/runner.cpp
+++ b/test/clickhouse-test-runner/src/runner.cpp
@@
-std::string Runner::connectionString() const {
+std::string Runner::connectionString(bool redact_password) const {
@@
-        + ";UID=" + connectionStringValue(opts.user) + ";PWD=" + connectionStringValue(opts.password)
+        + ";UID=" + connectionStringValue(opts.user)
+        + ";PWD=" + ((redact_password && !opts.password.empty()) ? std::string("<redacted>") : connectionStringValue(opts.password))
         + ";Database=" + connectionStringValue(database) + ";Timeout=300";
@@ void Runner::connect() {
     const auto cs = connectionString();
-    log.add("connect", cs);
+    log.add("connect", connectionString(/* redact_password */ true));
--- a/test/clickhouse-test-runner/src/main.cpp
+++ b/test/clickhouse-test-runner/src/main.cpp
@@ int run(const std::vector<std::string> & argv) {
     {
         std::string joined;
-        for (const auto & a : argv)
-            joined += (joined.empty() ? "" : " ") + a;
+        bool redact_next = false;
+        for (const auto & a : argv) {
+            std::string shown = a;
+            if (redact_next)
+                shown = "<redacted>";
+            else if (a.starts_with("--password="))
+                shown = "--password=<redacted>";
+            redact_next = (a == "--password");
+            joined += (joined.empty() ? "" : " ") + shown;
+        }
         log.add("argv", joined);
     }

Static review by ConnectorSec (ClickHouse Product Security); no PR code was executed.

polyglotAI-bot and others added 2 commits November 19, 2026 11:23
… name

The shim took a top-level `FORMAT <name>` at the end of a query as the
output-format clause, also when `format` is a table or a column with an
implicit alias: `SELECT * FROM format f`, `SELECT format TSV`,
`SELECT 2 * format x`. It removed the words and sent a truncated statement,
so the result was a syntax error instead of the server's result. The INSERT
splitter had the same bug: `INSERT INTO t SELECT * FROM format f;` was read
as inline data and took the next statements with it.

The new operandExpected() in text.cpp tells if the token after a text is
in an operand position: after a keyword such as SELECT, FROM, AS, BY or a
comma or an operator. A keyword that is in an operand position itself is a
name (`AS mod`, `ORDER BY offset`), so a FORMAT after it is still the
clause. findFormatClause and insertDataStart both use it.

topLevelWords now skips `$tag$...$tag$` heredocs, as scanStatementEnd and
findFormatClause do: a FROM or SELECT in a heredoc no longer changes the
decision of formatAfterSelectFrom.

The old and the new code give the same result for each statement of the
12,961 upstream .sql tests, so the allowlist does not change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The log of CLICKHOUSE_CLIENT_CLI_LOG had the connection string with its
PWD= value and the command line with the value of --password. CI uploads
this log as an artifact when a job fails. The jobs use the passwordless
default user now, but a run against a server with a password would write
the password in clear to the artifact.

The log now has the password as `<redacted>`: Runner::connectionString()
has a redact_password argument, and redactedCommandLine() reads the
options as parseArgs does, so it finds the value of --password also after
an option that takes the next argument as its value. An empty password
stays empty.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@polyglotAI-bot

Copy link
Copy Markdown
Collaborator Author

Thanks. Fixed in 036de6e, as you suggested:

  • connect() logs connectionString(/* redact_password */ true). A password that is not empty is <redacted>; an empty one stays empty.
  • main.cpp logs redactedCommandLine(argv) (args.cpp), not the raw argv. It reads the options as parseArgs does, so it also finds the value of --password after an option that takes the next argument as its value. For example, -q --password --password secret gives the password secret to parseArgs, and only a check that is the same as parseArgs redacts it.

Tests: Args.RedactedCommandLine and Runner.ConnectionStringForTheLog. I also ran the shim with --password <secret> and --password=<secret> and with a log file: the log does not contain the secret. The driver's own error text already masks PWD. The README row of CLICKHOUSE_CLIENT_CLI_LOG now says that the password is redacted.

@security-ai-gate-reviewer

security-ai-gate-reviewer Bot commented Nov 19, 2026 •

Copy link
Copy Markdown

AI review gate — auto-approval withheld

The AI review gate is green, but the approver did not approve 884a740d: it changes paths that always require a human reviewer: .github/workflows/upstream-sql-tests.yml (commit fc7a9b7 has no verified signature; commit fc7a9b7 has no verified signature).

What to do: ask someone with write access who is not the PR author to approve this pull request.

History (latest 5 heads, newest first)

  • 884a740d8f7f withheld — it changes paths that always require a human reviewer: .github/workflows/upstream-sql-tests.yml (commit fc7a9b7 has no verified signature; commit fc7a9b7 has no verified signature)
  • 036de6eb462a withheld — it changes paths that always require a human reviewer: .github/workflows/upstream-sql-tests.yml (commit fc7a9b7 has no verified signature; commit fc7a9b7 has no verified signature)

@connectorsec

Copy link
Copy Markdown

ConnectorSec security review — head 036de6e

No new findings.

Resolved since 06a65d0: The program log writes the password in clear, and CI uploads that log as a public artifact. At 036de6e, Runner::connect() logs connectionString(/* redact_password */ true) (runner.cpp:181), and run() logs redactedCommandLine(argv) (main.cpp:82), which redacts the value of --password on each path where parseArgs sets the password (args.cpp:165).

Static review by ConnectorSec (ClickHouse Product Security); no PR code was executed.

- run-upstream-tests.sh gives the runner --dont_retry_failures. Without
  it, tests/clickhouse-test runs a failed test again when its output has
  one of its MESSAGES_TO_RETRY, and reports it as OK when it passes then,
  so a flaky test could enter the allowlist. RETRY_FAILED is now the
  only retry.
- For TSVRawWithNames and TSVRawWithNamesAndTypes (and their aliases),
  the shim writes the names and types without escapes, as the server
  does (TabSeparatedRowOutputFormat::writeLine). A name with a tab or a
  newline was written as `\t` / `\n`. Live test: names with a tab, a
  backslash, a quote, a newline and non-ASCII text, compared with the
  server's output; the escaped formats are the contrast case.

No test result changes: the allowlist is unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@ccoltx
ccoltx merged commit 4104378 into master Nov 19, 2026
25 checks passed
@ccoltx
ccoltx deleted the polyglot/core-sql-tests branch November 19, 2026 15:15
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

3 participants