…ranch-4.2 (#69463)

### What problem does this PR solve?

Related PR: #69314

Problem Summary:

- `COM_STMT_SEND_LONG_DATA` returns an unexpected response and does not
bind uploaded chunks, leaving streaming clients out of sync. Accept
chunks without replying, defer upload errors until EXECUTE, and clear
uploaded data after execution or RESET.
- Reusing cached server-prepared statements through a non-master FE can
fail because the master prepares each forwarded execution independently.
Forward complete parameter types and values, including streamed
parameters, and use the active prepare-stage context during proxy
planning.
- Empty results with `useCursorFetch=true` can hang or leave unread
packets, including when connection attributes are absent or rewritten.
Return an empty cursor, complete FETCH with `LAST_ROW_SENT`, and
preserve framing for older FEs through an optional peer capability.
- Completed EXECUTE payloads can remain attached to idle connections.
Release command payload buffers after response finalization and
forwarding finish.

Backport adaptations for branch-4.2:

- Keep protocol state in the existing
`ConnectContext`/`ConnectProcessor` architecture and preserve
branch-4.2's expansion of cached parameter types only when forwarding.
- Regenerate regression expectations with the standard test script to
retain branch-4.2's existing VARBINARY function semantics.

### Release note

Fix streamed prepared parameters, repeated prepared execution through
non-master FEs, and empty cursor fetch hangs.

### Check List (For Author)

- Test
- [x] Regression test: `prepared_stmt_p0/send_long_data` and
`prepared_stmt_p0/cursor_fetch_empty_result` passed with
`run-regression-test.sh`.
- [x] Unit Test: 91 FE tests passed with `run-fe-ut.sh`, with zero
failures, errors or skips.
- [x] Manual test: Connector/J 8.0.27, 8.0.33, 8.4.0 and 9.7.0 each
passed 428 checks against the built branch-4.2 FE and BE 4.1.3. Connect
explicitly to master and follower endpoints; verify streamed bytes,
empty streams and statement reuse; run 50 batches of three rows per
version and compare all stored values; alternate empty/nonempty cursor
results with and without connection attributes, including forwarded
execution and connection reuse.
- [x] Full FE build passed via `build.sh --fe`; Checkstyle passed with
zero violations.

- Behavior changed:
- [x] Yes. Long-data uploads have no response; forwarded parameters are
self-contained; empty cursors complete through FETCH; completed command
buffers are released.

- Does this need documentation?
    - [x] No.

### Check List (For Reviewer who merge this PR)

- [ ] Confirm the release note
- [ ] Confirm test cases
- [ ] Confirm document
- [ ] Add branch pick label

### What problem does this PR solve?

Related PR: #69314

JDBC `setBytes()` and Connector/ODBC binary bindings can send
`MYSQL_TYPE_VAR_STRING` / `MYSQL_TYPE_STRING` rather than BLOB. FE
decoded those bytes with Java's replacement UTF-8 decoder, silently
changing arbitrary binary data. For example, `0080FF4100C328` became
`00EFBFBDEFBFBD4100EFBFBD28` in `SELECT HEX(?)`. The BLOB handling added
by #69314 did not cover these wire types.

Decode string parameters strictly and retain non-UTF-8 payloads as
binary literals. Bind those payloads through a BE-side cast to the
original string category, preserving string function and comparison
typing without replacing bytes. Valid UTF-8 retains the existing text
literal types, and BLOB types retain their existing binary behavior. Use
value-based binary literal child hashes so equivalent casts remain equal
after rebinding and forwarding.

### Release note

Preserve non-UTF-8 bytes in MySQL server-prepared string parameters,
including JDBC `setBytes()` and Connector/ODBC binary bindings.

### Check List (For Author)

- Test:
- [x] Regression test: generated and replayed
`prepared_stmt_p0/binary_parameters`; replayed
`prepared_stmt_p0/send_long_data`. Covers all byte values, malformed
UTF-8, parameter reuse, stored HEX/MD5, string expression predicates,
NULL/empty values and ordinary Unicode text.
- [x] Unit Test: 17 tests passed across `MysqlParameterLiteralTest` and
`MysqlConnectProcessorLongDataTest`, including string wire aliases,
cached types, uploads and forwarding.
- [x] Manual test: Connector/J 8.2.0 server-prepared `setBytes`,
`setBinaryStream` and `setBlob` preserve `0080FF4100C328`.
- [x] Manual test: Linux Connector/ODBC 5.3.14 Unicode, 17 cases passed,
including 1-MiB binary/Unicode inputs. An additional 17-case
proxy-rewritten VARCHAR wire-type probe also passed.
    - [x] FE build and Checkstyle passed.
- Behavior changed:
- [x] Yes. Non-UTF-8 string-coded parameters preserve the input bytes
instead of substituting U+FFFD. Valid UTF-8 text behavior is unchanged.
- Does this need documentation?
    - [x] No.

Runtime regression checks used the newly built master FE with an
existing 4.1.4 BE and condition cache disabled. The predicate regression
uses `CONCAT(value, '') = ?`; direct constant predicate pushdown on a
current master BE was not validated. No BE, storage-format or
protocol-field changes are included.

…meter types (#70150)

### What problem does this PR solve?

Issue Number: None

Related PR: #68162, #69314

Problem Summary:

**In short.** This ports `MysqlPreparedStatementForwardingTest` from
branch-4.1 #68162 to master. Master already has the fix the test guards,
through #69314. The port adds what master's own tests do not cover: a
NULL bitmap of two bytes, and the forward request that `FEOpExecutor`
builds and Thrift carries. The PR changes tests only.

**Background.** A client that runs a server-side prepared statement
again may leave out the parameter types (`new_params_bind_flag` = 0) and
have the server reuse the ones it cached. A follower forwards every
COM_STMT_EXECUTE to the master. The master prepares the statement again
for each forwarded execution, so it has no cached types and cannot bind
the parameters. #68162 fixed this on branch-4.1, together with the Lance
prepared vector search it was written for. Master fixed it independently
in #69314: when the client reuses cached types,
`MysqlConnectProcessor.handleExecute` writes the forwarded packet again,
with the NULL bitmap, `new_params_bind_flag` = 1, every type code
including the unsigned flag, and the values. #69314 also has the prepare
stage plan with the context of the re-parsed statement, which is the
other generic part of #68162. Its tests in
`MysqlConnectProcessorLongDataTest` cover cached types, unsigned flags,
changing NULLs, changing types, all-NULL executions and the prepare
context.

**What those tests leave out.** They use at most four parameters, so the
NULL bitmap always fits in one byte. They also give the master the
buffer kept on the follower's context, rather than the request
`FEOpExecutor.buildStmtForwardParams` builds.

**What this PR adds.** The test runs a ten-parameter statement five
times on a follower connection:

- The parameter types are sent with the first and the fourth execution;
the other executions reuse the cached ones.
- One execution has a NULL parameter in each byte of the NULL bitmap.
- An unsigned INT parameter becomes a BIGINT in the fourth execution.

After each execution, the test builds the forward request with
`FEOpExecutor`, passes it through a Thrift round trip and executes it on
a new proxy context whose placeholders have no types. It then checks
three things: every parameter binds to the same value as on the
follower, the unsigned flag carries over, and the client's packet is
read to its end and left unchanged. The code is the 4.1 test adapted to
master's structure: master's `PrepareCommand`, query id and audit setup,
as in `MysqlConnectProcessorLongDataTest`, and expressions compared
directly. The 4.1 assertion that the follower keeps the client's buffer
was dropped, because master writes a separate buffer for cached types by
design.

**Results.**

| `handleExecute` on master | `MysqlConnectProcessorLongDataTest` (14) |
`MysqlPreparedStatementForwardingTest` (1) |
|---|---|---|
| as is | pass | pass |
| no rewrite of the forwarded packet for cached types (the bug #68162
fixed) | 3 fail | fails: the master binds untyped placeholders (`No
value present`) |
| the rewrite keeps only the first byte of the NULL bitmap | pass |
fails: the master reads the packet one byte off |

Co-authored-by: Gabriel <[email protected]>