`get_diff_text` was calling `gh pr diff` unconditionally, but flaky
check containers do not have `enable_gh_auth=True` so `gh` is
unauthenticated. This caused Step 3 (coverage-relevant tests) to
always return 0 — the empty diff yielded no changed lines and the
CIDB coverage query was never issued.

Fix: in non-local runs use `git diff <merge_base_commit_sha>...HEAD`
(the merge base is stored in `JOB_KV_DATA` by `store_data.py`).
`gh pr diff` is kept for local runs only.

Also fix the cache guard: `not self._diff_text` treated an empty
string as uncached, causing `gh pr diff` to be called twice per job.
Changed to `self._diff_text is not None`.

Also fix `query_result.strip()` on a potentially-`None` CIDB result
(`or ""` guard on line 123).

The flaky check Docker container has no .git directory, so the previous
fix using `git diff <merge_base>...HEAD` failed with 'Not a git
repository'. `gh pr diff` also fails because there is no gh auth.

Use the unauthenticated GitHub API endpoint instead:
  https://patch-diff.githubusercontent.com/raw/ClickHouse/ClickHouse/pull/{PR}.diff

This works from any context (container, local, CI) without requiring
git history or gh authentication. `gh pr diff` is kept for local runs.

Two changes:

1. Remove force_ok_exit=True for flaky check.  The flag was unconditional,
   so any failure (actual test fail, server died, unexpected termination)
   was silently reported as Success.  Now flaky-check failures actually
   fail the CI job.

2. Move the time-limit enforcement from --global_time_limit inside
   clickhouse-test to Shell.run(timeout=...) on the Python side.

   With --global_time_limit, clickhouse-test raises GlobalTimeout inside
   the multiprocessing worker, which sends SIGTERM to every worker process.
   Workers die with 'Terminated: 15', cleanup is messy, and the result is
   marked 'terminated unexpectedly' (ERROR status).

   With Shell.run(timeout=...), SIGTERM is sent to the clickhouse-test
   process itself after the allotted time.  clickhouse-test handles SIGTERM
   via its own signal_handler, finishes the currently running tests, and
   exits cleanly — allowing the result to be collected properly.

…allel-self collisions

Tests that CREATE DATABASE with static (hardcoded) names fail when the
flaky check runs them in parallel with themselves — the second worker
finds the database already exists.  The existing mechanism renames only
the *primary* test database (to test_XXXXXXXX) but leaves explicitly
created extra databases unchanged.

This commit adds transparent name mangling for such tests:

1. Before executing a test, scan its content for CREATE DATABASE <name>
   where <name> is a bare identifier (not a query parameter like
   {VAR:Type}, not a shell variable like $VAR, not a keyword).

2. Derive a per-run suffix from the unique part of the primary database
   name: database='test_a1b2c3d4' → suffix='_a1b2c3d4'.

3. Write the test content with all occurrences of each extra database
   name replaced by name+suffix into a temp file in the test's tmp dir.
   Use the temp file for execution instead of the original.

4. After execution, normalize name+suffix → name in stdout (matching
   the existing replace_in_file(stdout, database, 'default') pattern).
   Reference files need no changes.

Two helper functions are added near replace_in_file():
- find_extra_databases(content): regex-based scanner with filters for
  SQL/shell keywords, shell-variable continuations (name${...}),
  names shorter than 3 chars, and built-in databases.
- mangle_extra_databases(content, extra_dbs, suffix): word-boundary
  replacement for all found names.

Validated on 114 tests with static extra databases (round-trip test:
mangle → normalize → compare with original reference: all pass) over
10165 total test files scanned.

…tdout

Previous approach mangled the test SQL but then normalized stdout back to
original names.  The correct approach (per user feedback) is:

1. Mangle the test file (name → name+suffix in a temp copy)
2. Mangle the reference file identically (name → name+suffix in a temp copy)
3. Compare stdout (containing mangled names) against the mangled reference

This way stdout is never post-processed and the comparison is direct.
self.reference_file is redirected to the temp mangled copy for the duration
of the test run.

Validated locally on 97 tests (89 with static extra databases + 8 unaffected):
- 45 passed, 10 skipped
- 22 'failures' are all pre-existing local env issues (missing test.hits
  dataset, no cluster, privileges, version incompatibilities)
- Only 1 failure (01470_show_databases_like) is mangling-related: the test
  uses LIKE '%01470' which doesn't match the suffixed name.  That test is
  tagged no-parallel and won't run in the flaky check.

Tests tagged no-parallel never run concurrently with themselves, so
hardcoded database names cannot collide.  Skipping the mangling for
them avoids false failures in cases like 01470_show_databases_like
where the test uses a partial name in a LIKE clause that wouldn't
match the suffixed database name.

.sh and .expect tests are executed directly as scripts, so the temp
copy must be executable.  Copy the original file's mode bits after
writing the mangled content.

…ktick support

Two fixes:

1. Skip temp-file creation for non-.sql tests (.sh, .expect).
   .sh scripts source ../shell_config.sh relative to their own path.
   When the mangled copy is placed in test_tmp_dir (a subdirectory of
   the tmp area, not the suite dir), that relative path no longer
   resolves and the script immediately fails with 'No such file or
   directory'. Restrict temp-file mangling to .sql tests only, where
   the file is piped via stdin and no relative sourcing occurs.

2. Support backtick-quoted database identifiers.
   _CREATE_DB_RE now matches both bare identifiers and `quoted` names.
   find_extra_databases picks the non-None group.
   mangle_extra_databases replaces both `name` → `name_sfx` (quoted)
   and word-boundary name → name_sfx (bare).
   Example: 03566_system_completions_table.sql uses
   CREATE DATABASE IF NOT EXISTS `0003566aaadatabase` which was
   previously undetected and now gets correctly mangled.

The approach of rewriting test SQL and reference files at runtime has
too many edge cases and breaks tests in CI. Reverting completely.

…nd-tests-gh-auth

…m substitution

When {CLICKHOUSE_DATABASE_1:Identifier} is used as a qualifier before
table names starting with digits (e.g. .03711_join_with), ClickHouse's
parser fails with a syntax error after the backtick-quoted identifier.
The test also has 'long' and 'no-parallel' tags, so it won't run in
parallel in flaky check. Revert to static db name and add no-flaky-check.

- clickhouse-test: also pass --param_CLICKHOUSE_DATABASE_2 for SQL tests
  that need a second extra database variable

- 01103, 02115, 03031: fix static database name in Distributed engine
  definition (engine=Distributed(cluster, db_name, ...) was not replaced
  by the initial script since it's not a standard SQL identifier context)

- 01527: fix dictGet with unqualified 'dict' in Distributed sharding key -
  use currentDatabase() || '.dict' since string literals aren't substituted

- 01656: remove USE statement (original had none) and update query_log
  LIKE filter to match the dynamic CREATE DATABASE query text instead of
  the old static name pattern '%database test_query_log_factories_info%'

- 03533: replace static --database test CLI argument with
  --database ${CLICKHOUSE_DATABASE_1} in the two places that need it

…text

After USE {CLICKHOUSE_DATABASE_1:Identifier}, DB currentDatabase() returns
the extra database. But table_for_dict was created before the USE statement
in the default database, so the dictionary source pointing to
DB currentDatabase() couldn't find it.

Fix: move CREATE TABLE and INSERT to after the USE statement so
table_for_dict lives in the same database as the dictionary source.