7.2.0

Overview

7.2.0 adds per-query timeouts to the QWP/WebSocket reader and exposes the
effective frame cap of a standalone QWP/WebSocket sender. It also fixes the
frame-size check on standalone flushes, which changes the error code an
oversized frame reports: read "Breaking changes" before upgrading if your
code matches on InvalidApiCall.

The C and C++ clients are distributed as source. No pre-built native binaries
are attached; use the tag's source archive.

Compatibility

• QWP over WebSocket requires QuestDB 10.0 or newer.
• Per-query timeouts need server support that no released QuestDB has yet
  (questdb/questdb#7768). Against a server that doesn't advertise it, a query
  that carries a timeout fails before anything is sent, rather than running
  under the server's default timeout. This includes a default set with
  query_timeout_ms in the connect string.
• Rust MSRV is 1.91.0. The published questdb-rs crate supports Arrow
  >=58, <60 and Polars >=0.52, <0.55.

See doc/COMPATIBILITY.md
for the full matrix.

Breaking changes

• An oversized standalone QWP/WebSocket flush fails with BatchTooLarge
  (#227). It previously failed with InvalidApiCall. C, C++, and Rust code
  that matched InvalidApiCall for this case must match BatchTooLarge. The
  message now names the limit that applied.

New

• Per-query timeouts for the QWP/WebSocket reader (#214), overriding the
  server-wide query.timeout in either direction:

  • Rust: ReaderQuery::timeout(Duration), and query_timeout_ms in the
    connect string as a per-connection default (0 means none).
  • C: qwp_reader_query_set_timeout_ms().
  • C++: query::timeout_ms(uint64_t) and query::timeout(chrono::duration).

  A timed-out query fails with ErrorCode::QueryTimeout
  (line_sender_error_query_timeout) and leaves the connection usable. Do not
  retry a write on this error: a DDL, INSERT, or UPDATE that timed out may
  still be applied. A positive timeout under 1 ms rounds up to 1 ms;
  Duration::ZERO clears a default inherited from the connect string.

• ROWS_AFFECTED_UNKNOWN: a public value reporting that the number of
  affected rows is unknown (#214).

• Sender::effective_frame_cap() and C
  line_sender_qwpws_effective_frame_cap() (#227) return the frame cap a
  standalone QWP/WebSocket sender enforces, and whether the server advertised
  one. There is no C++ wrapper yet.

Fixes

• A standalone QWP/WebSocket flush checks the encoded frame against the
  smallest of max_buf_size, the server's advertised X-QWP-Max-Batch-Size,
  and the store-and-forward segment payload capacity, as the pooled sender
  already does (#227). A frame between the segment capacity (just under 4 MiB
  by default) and a larger server cap used to pass the check and then fail
  inside the queue.

Full changelog: 7.1.0...7.2.0