questdb 0.1.0 → 0.1.1

data/vendor/c-questdb-client/doc/COMPATIBILITY.md

@@ -1,6 +1,6 @@
 # Compatibility
 
-This page records the supported versions and toolchains for the 7.1.0 client
+This page records the supported versions and toolchains for the 7.2.0 client
 release. It is the repository source of truth; language guides should link here
 instead of inventing their own compatibility claims.
 

data/vendor/c-questdb-client/doc/CONSIDERATIONS.md

@@ -93,9 +93,12 @@ Flushing every row increases overhead, while unbounded buffers increase memory
 use and recovery time.
 
 For ILP, the buffer length is the exact pending encoded byte length. For
-QWP/UDP it is a size hint rather than an eventual datagram size. QWP/WebSocket
-column and row senders encode frames at publication time and apply their own
-store-and-forward limits.
+QWP/UDP it is a size hint rather than an eventual datagram size. For a
+QWP/WebSocket row buffer it is at least the size of the frame a flush encodes,
+unless store-and-forward has fallen back to full symbol dictionaries, so a
+buffer whose length is within the frame limit fits in one frame.
+QWP/WebSocket column and row senders encode frames at publication time and
+apply their own store-and-forward limits.
 
 Pool limits (`sender_pool_max`, `query_pool_max`) bound concurrent connections.
 At capacity, borrow operations wait up to `acquire_timeout_ms` or fail

data/vendor/c-questdb-client/doc/RELEASE_RUNBOOK.md

@@ -206,7 +206,7 @@ git fetch origin --tags --prune
 git switch main
 git pull --ff-only
 test -z "$(git status --porcelain=v1 --untracked-files=all)"
-git switch -c release/7.1.0
+git switch -c release/7.2.0
 ```
 
 Do not prepare a release from a dirty feature-branch checkout.
@@ -216,7 +216,7 @@ Do not prepare a release from a dirty feature-branch checkout.
 For a future version change, preview before modifying files:
 
 ```bash
-NEW_VERSION=7.1.0
+NEW_VERSION=7.2.0
 bump-my-version replace --new-version "$NEW_VERSION" --dry-run
 bump-my-version replace --new-version "$NEW_VERSION"
 ```
@@ -326,7 +326,7 @@ git switch main
 git pull --ff-only
 test -z "$(git status --porcelain=v1 --untracked-files=all)"
 
-VERSION=7.1.0
+VERSION=7.2.0
 RELEASE_SHA="$(git rev-parse HEAD)"
 
 git show --no-patch --format=fuller "$RELEASE_SHA"
@@ -487,7 +487,7 @@ git switch main
 git pull --ff-only
 test -z "$(git status --porcelain=v1 --untracked-files=all)"
 
-VERSION=7.1.0
+VERSION=7.2.0
 RELEASE_SHA="$(git rev-parse HEAD)"
 
 git show --no-patch --format=fuller "$RELEASE_SHA"
@@ -572,7 +572,7 @@ can hide packaging mistakes:
 SMOKE_ROOT="$(mktemp -d)"
 cargo new "$SMOKE_ROOT/qdb-rs-release-smoke"
 cd "$SMOKE_ROOT/qdb-rs-release-smoke"
-cargo add questdb-rs@=7.1.0
+cargo add questdb-rs@=7.2.0
 cargo check
 ```
 
@@ -627,11 +627,11 @@ A crates.io version cannot be overwritten or deleted.
 To yank without deleting the already published package:
 
 ```bash
-cargo yank --version 7.1.0 questdb-rs
+cargo yank --version 7.2.0 questdb-rs
 ```
 
 Yanking does not break consumers whose lockfiles already select the version.
-Never reuse 7.1.0 after yanking it.
+Never reuse 7.2.0 after yanking it.
 
 ## Final release checklist
 

data/vendor/c-questdb-client/doc/RELEASING.md

@@ -18,10 +18,10 @@ git fetch origin --tags --prune
 git switch main
 git pull --ff-only
 test -z "$(git status --porcelain=v1 --untracked-files=all)"
-git switch -c release/7.1.0
+git switch -c release/7.2.0
 ```
 
-Replace `7.1.0` throughout these examples with the intended version.
+Replace `7.2.0` throughout these examples with the intended version.
 
 Confirm publisher access, a crates.io token configured with `cargo login` or a
 protected environment variable, a release verifier, and a merge-ready
@@ -38,13 +38,13 @@ uv tool install bump-my-version
 Preview and then apply the version update:
 
 ```bash
-bump-my-version replace --new-version 7.1.0 --dry-run
-bump-my-version replace --new-version 7.1.0
+bump-my-version replace --new-version 7.2.0 --dry-run
+bump-my-version replace --new-version 7.2.0
 ```
 
 Review every changed version and update the release notes, compatibility
 statements, and this repository's documentation. The QWP/WebSocket floor for
-7.1.0 is QuestDB 10.0 and the Rust MSRV is 1.91.0.
+7.2.0 is QuestDB 10.0 and the Rust MSRV is 1.91.0.
 
 Refresh every tracked lockfile containing this client:
 
@@ -85,7 +85,7 @@ Enterprise check, and release-candidate soak.
 From a clean checkout of the approved `main` commit:
 
 ```bash
-VERSION=7.1.0
+VERSION=7.2.0
 RELEASE_SHA="$(git rev-parse HEAD)"
 
 cd questdb-rs

data/vendor/c-questdb-client/include/questdb/egress/qwp_reader.h

@@ -977,6 +977,35 @@ QUESTDB_CLIENT_API void qwp_reader_query_initial_credit(
 QUESTDB_CLIENT_API void qwp_reader_query_set_reset_symbol_dict(
     qwp_reader_query*, bool reset);
 
+/**
+ * Run this query under its own timeout, in milliseconds, instead of the
+ * server-wide `query.timeout`. Overrides the connect string's
+ * `query_timeout_ms` for this query; `0` clears it (no client timeout).
+ * Mirrors `ReaderQuery::timeout`.
+ *
+ * Requires a server advertising `CAP_QUERY_TIMEOUT` (`0x08` in
+ * `qwp_reader_server_info_capabilities`). Unlike
+ * `qwp_reader_query_set_reset_symbol_dict`, this does NOT silently degrade:
+ * against an older server `qwp_reader_query_execute` fails with
+ * `line_sender_error_unsupported_server`, before anything is written, instead
+ * of running the query under the server default while the caller believes
+ * its timeout applied. The connection is untouched by that refusal. Raise
+ * the server's `query.timeout` instead, or clear the timeout here.
+ *
+ * The server applies no ceiling, so a value above `query.timeout` is
+ * honoured — which is the point for a long transform.
+ *
+ * On expiry the cursor terminates with `line_sender_error_query_timeout` and
+ * the connection stays open and authenticated, so the next query runs on it
+ * without reconnecting. DO NOT RETRY A WRITE on that error: a statement that
+ * completes past its timeout is answered with `EXEC_DONE` and its row count
+ * rather than a timeout (so a retry cannot apply it twice), and a DDL /
+ * INSERT / UPDATE that timed out waiting for the table writer may still be
+ * applied by that writer afterwards.
+ */
+QUESTDB_CLIENT_API void qwp_reader_query_set_timeout_ms(
+    qwp_reader_query*, uint64_t timeout_ms);
+
 /**
  * Install a failover-reset callback on the query. Replaces any previously
  * installed callback. `user_data` is opaque to the library; pass NULL if
@@ -1368,13 +1397,31 @@ QUESTDB_CLIENT_API bool qwp_reader_cursor_terminal_end(
 /**
  * If the terminal is `EXEC_DONE`, fill the output parameters and return
  * true; otherwise zeroes both outputs and returns false.
+ *
+ * `*out_rows_affected` is the row count of an `INSERT` / `UPDATE`. For a
+ * statement the server executes at parse time (`TRUNCATE`, `RENAME TABLE`,
+ * `SET`, ...) it reports no count: it sends `-1`, which arrives as
+ * `QWP_READER_ROWS_AFFECTED_UNKNOWN` (`UINT64_MAX`). `*out_op_type` is the
+ * server's operation-type byte, carried through opaquely.
  */
 QUESTDB_CLIENT_API bool qwp_reader_cursor_terminal_exec_done(
     const qwp_reader_cursor* cursor,
     uint8_t* out_op_type,
     uint64_t* out_rows_affected);
 
-/** Whether freeing this cursor leaves its reader reusable; false for NULL. */
+/** `*out_rows_affected` of `qwp_reader_cursor_terminal_exec_done` for a
+ *  statement that reports no row count. */
+#define QWP_READER_ROWS_AFFECTED_UNKNOWN UINT64_MAX
+
+/**
+ * Whether freeing this cursor leaves its reader reusable; false for NULL.
+ *
+ * True only once the stream reached a terminal frame (or was cancelled to
+ * one) with no query still active and the transport up. A cursor that is
+ * terminal only because a client-side error ended it mid-stream still has
+ * frames in flight; freeing it sends `CANCEL` and closes the transport, so
+ * this reports false for it.
+ */
 QUESTDB_CLIENT_API bool qwp_reader_cursor_connection_reusable(
     const qwp_reader_cursor* cursor);
 

data/vendor/c-questdb-client/include/questdb/egress/qwp_reader.hpp

@@ -27,6 +27,8 @@
 #include "qwp_reader.h"
 
 #include <array>
+#include <chrono>
+#include <cmath>
 #include <cstdint>
 #include <cstring>
 #include <functional>
@@ -1195,6 +1197,56 @@ public:
         return *this;
     }
 
+    /**
+     * Run this query under its own timeout instead of the server-wide
+     * `query.timeout`. Overrides the connect string's `query_timeout_ms`;
+     * `0` clears it. Requires a server advertising `CAP_QUERY_TIMEOUT`
+     * (`0x08`) — against an older one `execute()` throws
+     * `error_code::unsupported_server`, before anything is written, rather
+     * than silently running under the server default; the connection is
+     * untouched. The server applies no ceiling, so a value above
+     * `query.timeout` is honoured.
+     *
+     * On expiry the cursor terminates with `error_code::query_timeout` and
+     * the connection stays usable. Do not retry a write on it: a statement
+     * that outlives its timeout is reported as `EXEC_DONE` instead, and a
+     * DDL / INSERT / UPDATE that timed out waiting for the table writer may
+     * still be applied afterwards.
+     */
+    query& timeout_ms(uint64_t timeout_ms)
+    {
+        ensure_impl();
+        ::qwp_reader_query_set_timeout_ms(_impl, timeout_ms);
+        return *this;
+    }
+
+    /** `timeout_ms` taking a `std::chrono` duration. A non-zero duration
+     *  below 1 ms rounds up to 1 ms, never down to "no timeout"; one too
+     *  large for the wire saturates at its maximum. Only zero clears the
+     *  timeout: a negative, NaN or infinite duration throws
+     *  `error_code::invalid_api_call`. */
+    template <typename Rep, typename Period>
+    query& timeout(std::chrono::duration<Rep, Period> d)
+    {
+        // Convert in double: `duration_cast` to an integral rep is UB for
+        // NaN and for values outside the target range.
+        const double ms = std::chrono::duration<double, std::milli>{d}.count();
+        if (std::isnan(ms) || std::isinf(ms))
+            throw ::questdb::error{
+                error_code::invalid_api_call,
+                "query::timeout(): duration must be finite"};
+        if (ms < 0.0)
+            throw ::questdb::error{
+                error_code::invalid_api_call,
+                "query::timeout(): duration must not be negative"};
+        if (ms == 0.0)
+            return timeout_ms(0);
+        if (ms >= 18446744073709551616.0) // 2^64
+            return timeout_ms(UINT64_MAX);
+        const auto as_u64 = static_cast<uint64_t>(ms);
+        return timeout_ms(as_u64 == 0 ? 1 : as_u64);
+    }
+
     /**
      * Install a failover-reset callback. Replaces any previously installed
      * callback. The closure is stored on the heap and remains alive for

data/vendor/c-questdb-client/include/questdb/ingress/line_sender.h

@@ -168,7 +168,11 @@ typedef enum line_sender_error_code
     /** HTTP-upgrade or WebSocket handshake failure. */
     line_sender_error_handshake_error = 20,
 
-    /** Server returned an unsupported QWP version, encoding, or capability. */
+    /** Server returned an unsupported QWP version, encoding, or capability.
+     *  Also raised client-side, before anything is written, when a query
+     *  carries a per-query timeout and the server does not advertise
+     *  `CAP_QUERY_TIMEOUT` (see `qwp_reader_query_set_timeout_ms`); the
+     *  connection is untouched by that refusal. */
     line_sender_error_unsupported_server = 21,
 
     /** Wire-format violation: bad magic, truncated frame, unknown
@@ -290,6 +294,24 @@ typedef enum line_sender_error_code
      *  queued prefix already carried are duplicated.
      */
     line_sender_error_symbol_dict_full = 37,
+
+    /** The query ran past the timeout it carried: server-reported QWP
+     *  `QUERY_TIMEOUT` (status `0x0E`), produced only for a request that
+     *  supplied `timeout_ms` (see `qwp_reader_query_set_timeout_ms`). A
+     *  timeout requested against a server that does not advertise
+     *  `CAP_QUERY_TIMEOUT` is refused with
+     *  `line_sender_error_unsupported_server` instead, so retrying a timeout
+     *  with a larger budget cannot loop against a server that ignores it.
+     *
+     *  Per-query, not per-connection: the connection stays open and
+     *  authenticated, so the next query runs on it without reconnecting.
+     *
+     *  DO NOT RETRY A WRITE ON THIS ERROR. A statement that completes past
+     *  its timeout is reported as `EXEC_DONE` with its row count rather than
+     *  as a timeout, precisely so a retrying client cannot apply it twice;
+     *  and a DDL / INSERT / UPDATE that timed out waiting for the table
+     *  writer may still be applied by that writer afterwards. */
+    line_sender_error_query_timeout = 38,
 } line_sender_error_code;
 
 /**
@@ -352,6 +374,7 @@ typedef line_sender_error_code questdb_error_code;
 #define questdb_error_store_resend_required                                    \
     line_sender_error_store_resend_required
 #define questdb_error_symbol_dict_full line_sender_error_symbol_dict_full
+#define questdb_error_query_timeout line_sender_error_query_timeout
 
 /** The protocol used to connect with. */
 typedef enum line_sender_protocol
@@ -833,9 +856,12 @@ void line_sender_buffer_clear(line_sender_buffer* buffer);
 /**
  * The current encoded size of the buffered data.
  *
- * For ILP buffers this is the exact pending byte length. For QWP buffers this
- * is a buffered size hint, not the exact size of an eventual UDP datagram or
- * WebSocket replay frame.
+ * For ILP buffers this is the exact pending byte length. For QWP/UDP buffers
+ * this is a buffered size hint, not the exact size of an eventual datagram.
+ * For QWP/WebSocket buffers it is at least the size of the frame that
+ * flushing the buffer encodes, unless store-and-forward has fallen back to
+ * sending full symbol dictionaries because its symbol side-file could not be
+ * opened or rolled back.
  */
 QUESTDB_CLIENT_API
 size_t line_sender_buffer_size(const line_sender_buffer* buffer);
@@ -2193,6 +2219,22 @@ bool line_sender_qwpws_errors_dropped(
     uint64_t* dropped_out,
     line_sender_error** err_out);
 
+/**
+ * Return the current hard per-frame cap of a QWP/WebSocket sender: the
+ * smallest of `max_buf_size`, the server's advertised `X-QWP-Max-Batch-Size`
+ * and the store-and-forward segment payload capacity. A flush whose encoded
+ * frame exceeds it fails with `line_sender_error_batch_too_large` and
+ * publishes nothing. `*server_cap_known_out` is true when the current
+ * connection advertised `X-QWP-Max-Batch-Size`, whether or not that value is
+ * the binding limit. The value can change after reconnect.
+ */
+QUESTDB_CLIENT_API
+bool line_sender_qwpws_effective_frame_cap(
+    const line_sender* sender,
+    size_t* cap_out,
+    bool* server_cap_known_out,
+    line_sender_error** err_out);
+
 /**
  * Stop accepting new QWP/WebSocket publications and wait for already-published
  * frames to resolve. The timeout is configured with the QWP/WebSocket

data/vendor/c-questdb-client/include/questdb/ingress/line_sender.hpp

@@ -224,9 +224,12 @@ public:
     /**
      * The current encoded size of the buffered data.
      *
-     * For ILP buffers this is the exact pending byte length. For QWP buffers
-     * this is a buffered size hint, not the exact size of any eventual UDP
-     * datagram.
+     * For ILP buffers this is the exact pending byte length. For QWP/UDP
+     * buffers this is a buffered size hint, not the exact size of any
+     * eventual datagram. For QWP/WebSocket buffers it is at least the size of
+     * the frame that flushing the buffer encodes, unless store-and-forward
+     * has fallen back to sending full symbol dictionaries because its symbol
+     * side-file could not be opened or rolled back.
      */
     size_t size() const noexcept
     {
@@ -1259,7 +1262,7 @@ private:
     static inline ::line_sender_utf8 name()
     {
         // Maintained by .bumpversion.cfg
-        static const char user_agent[] = "questdb/c++/7.1.0";
+        static const char user_agent[] = "questdb/c++/7.2.0";
         ::line_sender_utf8 utf8 =
             ::line_sender_utf8_assert(sizeof(user_agent) - 1, user_agent);
         return utf8;

data/vendor/c-questdb-client/include/questdb/ingress/line_sender_core.hpp

@@ -104,6 +104,7 @@ enum class error_code : int
     batch_too_large = ::line_sender_error_batch_too_large,
     store_resend_required = ::line_sender_error_store_resend_required,
     symbol_dict_full = ::line_sender_error_symbol_dict_full,
+    query_timeout = ::line_sender_error_query_timeout,
 };
 // clang-format on
 

data/vendor/c-questdb-client/questdb-rs/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "questdb-rs"
-version = "7.1.0"
+version = "7.2.0"
 edition = "2024"
 rust-version = "1.91.0"
 license = "Apache-2.0"

data/vendor/c-questdb-client/questdb-rs/README.md

@@ -24,7 +24,7 @@ also supported for ingestion.
 * [Repository compatibility matrix](../doc/COMPATIBILITY.md)
 * [InfluxDB Line Protocol reference](https://questdb.com/docs/reference/api/ilp/overview/)
 
-Version 7.1.0 requires Rust 1.91.0. QWP over WebSocket requires QuestDB 10.0
+Version 7.2.0 requires Rust 1.91.0. QWP over WebSocket requires QuestDB 10.0
 or newer.
 
 ## Transports
@@ -178,21 +178,21 @@ then see the
 
 ## Examples
 
-A selection of usage examples is available in the [examples directory](https://github.com/questdb/c-questdb-client/tree/7.1.0/questdb-rs/examples):
+A selection of usage examples is available in the [examples directory](https://github.com/questdb/c-questdb-client/tree/7.2.0/questdb-rs/examples):
 
 | Example | Description |
 |---------|-------------|
-| [`basic.rs`](https://github.com/questdb/c-questdb-client/blob/7.1.0/questdb-rs/examples/basic.rs) | Minimal TCP ingestion example; shows basic row and array ingestion. |
-| [`auth.rs`](https://github.com/questdb/c-questdb-client/blob/7.1.0/questdb-rs/examples/auth.rs) | Adds authentication (user/password, token) to basic ingestion. |
-| [`auth_tls.rs`](https://github.com/questdb/c-questdb-client/blob/7.1.0/questdb-rs/examples/auth_tls.rs) | Like `auth.rs`, but uses TLS for encrypted TCP connections. |
-| [`from_conf.rs`](https://github.com/questdb/c-questdb-client/blob/7.1.0/questdb-rs/examples/from_conf.rs) | Configures client via connection string instead of builder pattern. |
-| [`from_env.rs`](https://github.com/questdb/c-questdb-client/blob/7.1.0/questdb-rs/examples/from_env.rs) | Reads config from `QDB_CLIENT_CONF` environment variable. |
-| [`http.rs`](https://github.com/questdb/c-questdb-client/blob/7.1.0/questdb-rs/examples/http.rs) | Uses HTTP transport and demonstrates array ingestion with `ndarray`. |
-| [`protocol_version.rs`](https://github.com/questdb/c-questdb-client/blob/7.1.0/questdb-rs/examples/protocol_version.rs) | Shows protocol version selection and feature differences (e.g. arrays). |
-| [`qwp_ws_chunk_and_query.rs`](https://github.com/questdb/c-questdb-client/blob/7.1.0/questdb-rs/examples/qwp_ws_chunk_and_query.rs) | Shares one `QuestDb` pool between concurrent columnar ingestion and query workers. |
-| [`qwp_ws_l1_quotes.rs`](https://github.com/questdb/c-questdb-client/blob/7.1.0/questdb-rs/examples/qwp_ws_l1_quotes.rs) | Columnar ingestion over QWP/WebSocket via the `QuestDb` connection pool. |
-| [`qwp_egress_read.rs`](https://github.com/questdb/c-questdb-client/blob/7.1.0/questdb-rs/examples/qwp_egress_read.rs) | Runs a SQL query and streams the result set over QWP/WebSocket. |
-| [`polars.rs`](https://github.com/questdb/c-questdb-client/blob/7.1.0/questdb-rs/examples/polars.rs) | Round trip: ingests a Polars `DataFrame` and queries it back as one. |
+| [`basic.rs`](https://github.com/questdb/c-questdb-client/blob/7.2.0/questdb-rs/examples/basic.rs) | Minimal TCP ingestion example; shows basic row and array ingestion. |
+| [`auth.rs`](https://github.com/questdb/c-questdb-client/blob/7.2.0/questdb-rs/examples/auth.rs) | Adds authentication (user/password, token) to basic ingestion. |
+| [`auth_tls.rs`](https://github.com/questdb/c-questdb-client/blob/7.2.0/questdb-rs/examples/auth_tls.rs) | Like `auth.rs`, but uses TLS for encrypted TCP connections. |
+| [`from_conf.rs`](https://github.com/questdb/c-questdb-client/blob/7.2.0/questdb-rs/examples/from_conf.rs) | Configures client via connection string instead of builder pattern. |
+| [`from_env.rs`](https://github.com/questdb/c-questdb-client/blob/7.2.0/questdb-rs/examples/from_env.rs) | Reads config from `QDB_CLIENT_CONF` environment variable. |
+| [`http.rs`](https://github.com/questdb/c-questdb-client/blob/7.2.0/questdb-rs/examples/http.rs) | Uses HTTP transport and demonstrates array ingestion with `ndarray`. |
+| [`protocol_version.rs`](https://github.com/questdb/c-questdb-client/blob/7.2.0/questdb-rs/examples/protocol_version.rs) | Shows protocol version selection and feature differences (e.g. arrays). |
+| [`qwp_ws_chunk_and_query.rs`](https://github.com/questdb/c-questdb-client/blob/7.2.0/questdb-rs/examples/qwp_ws_chunk_and_query.rs) | Shares one `QuestDb` pool between concurrent columnar ingestion and query workers. |
+| [`qwp_ws_l1_quotes.rs`](https://github.com/questdb/c-questdb-client/blob/7.2.0/questdb-rs/examples/qwp_ws_l1_quotes.rs) | Columnar ingestion over QWP/WebSocket via the `QuestDb` connection pool. |
+| [`qwp_egress_read.rs`](https://github.com/questdb/c-questdb-client/blob/7.2.0/questdb-rs/examples/qwp_egress_read.rs) | Runs a SQL query and streams the result set over QWP/WebSocket. |
+| [`polars.rs`](https://github.com/questdb/c-questdb-client/blob/7.2.0/questdb-rs/examples/polars.rs) | Round trip: ingests a Polars `DataFrame` and queries it back as one. |
 
 ## Crate features
 

data/vendor/c-questdb-client/questdb-rs/src/egress/config.rs

@@ -88,6 +88,11 @@ pub const DEFAULT_PATH: &str = "/read/v1";
 pub const HIGHEST_KNOWN_VERSION: u8 = crate::egress::wire::PROTOCOL_VERSION;
 
 /// Default WS port (matches QuestDB HTTP / ILP-HTTP convention).
+/// Default `query_timeout_ms`: `0`, i.e. no client-supplied per-query
+/// timeout, so each query runs under the server-wide `query.timeout`.
+/// Matches the Java client's `query_timeout_ms` default.
+pub const DEFAULT_QUERY_TIMEOUT_MS: u64 = 0;
+
 const DEFAULT_PLAIN_PORT: &str = "9000";
 const DEFAULT_TLS_PORT: &str = "9000";
 
@@ -489,6 +494,19 @@ pub struct ReaderConfig {
     /// handshake, the WS upgrade (see `auth_timeout_ms`), or the
     /// `SERVER_INFO` read (see `server_info_timeout_ms`).
     pub connect_timeout_ms: u64,
+    /// Default per-query timeout in milliseconds, applied to every query
+    /// this reader runs unless the query overrides it with
+    /// [`ReaderQuery::timeout`](crate::egress::ReaderQuery::timeout). `0`
+    /// (the default) means no client timeout: each query runs under the
+    /// server-wide `query.timeout`.
+    ///
+    /// A non-zero value requires a server advertising `CAP_QUERY_TIMEOUT`;
+    /// against an older server every query is refused before anything is
+    /// sent, with [`crate::ErrorCode::UnsupportedServer`], rather than
+    /// silently running under the server default. The server applies no
+    /// ceiling, so this may legitimately exceed `query.timeout` — which is
+    /// the point for long transforms. Connect-string key: `query_timeout_ms`.
+    pub query_timeout_ms: u64,
     /// Client's zone identifier — opaque case-insensitive string (e.g.
     /// `eu-west-1a`, `dc-amsterdam`). When set, the host-health tracker
     /// prefers endpoints whose server-advertised `zone_id` matches
@@ -770,6 +788,7 @@ impl ReaderConfig {
         let mut auth_timeout_ms: u64 = DEFAULT_AUTH_TIMEOUT_MS;
         let server_info_timeout_ms: u64 = DEFAULT_SERVER_INFO_TIMEOUT_MS;
         let mut connect_timeout_ms: u64 = 0;
+        let mut query_timeout_ms: u64 = DEFAULT_QUERY_TIMEOUT_MS;
         let mut zone: Option<String> = None;
         let mut tls_verify = TlsVerify::On;
         let mut tls_ca = default_tls_ca();
@@ -914,6 +933,9 @@ impl ReaderConfig {
                 "connect_timeout" => {
                     connect_timeout_ms = parse_value("connect_timeout", val)?;
                 }
+                "query_timeout_ms" => {
+                    query_timeout_ms = parse_value("query_timeout_ms", val)?;
+                }
                 "zone" => {
                     // Empty / whitespace-only is treated as unset
                     // (zone-blind). Reject CR/LF — these are headers /
@@ -1044,6 +1066,7 @@ impl ReaderConfig {
             auth_timeout_ms,
             server_info_timeout_ms,
             connect_timeout_ms,
+            query_timeout_ms,
             zone,
             auth,
             tls_verify,
@@ -1986,6 +2009,61 @@ mod tests {
         assert!(err.msg().contains("connect_timeout"), "msg: {}", err.msg());
     }
 
+    // --- query_timeout_ms (per-query timeout default) ---
+
+    #[test]
+    fn query_timeout_defaults_to_none() {
+        let c = ReaderConfig::from_conf("ws::addr=h:1").unwrap();
+        assert_eq!(
+            c.query_timeout_ms, 0,
+            "default must leave queries under the server-wide query.timeout"
+        );
+        assert_eq!(DEFAULT_QUERY_TIMEOUT_MS, 0);
+    }
+
+    #[test]
+    fn query_timeout_parses_from_connect_string() {
+        let c = ReaderConfig::from_conf("ws::addr=h:1;query_timeout_ms=600000").unwrap();
+        assert_eq!(c.query_timeout_ms, 600_000);
+    }
+
+    #[test]
+    fn query_timeout_zero_is_no_timeout() {
+        // `0` is the documented sentinel for "send no timeout_ms". The
+        // server rejects a zero on the wire, so the client must express
+        // "none" by omitting the field, never by sending 0.
+        let c = ReaderConfig::from_conf("ws::addr=h:1;query_timeout_ms=0").unwrap();
+        assert_eq!(c.query_timeout_ms, 0);
+    }
+
+    #[test]
+    fn query_timeout_has_no_ceiling() {
+        // Deliberate: the server applies no ceiling either, and a dbt-style
+        // transform legitimately wants longer than `query.timeout`. A cap
+        // here would silently cut such a query short.
+        let c = ReaderConfig::from_conf("ws::addr=h:1;query_timeout_ms=86400000").unwrap();
+        assert_eq!(c.query_timeout_ms, 86_400_000);
+    }
+
+    #[test]
+    fn query_timeout_non_numeric_rejected() {
+        let err = ReaderConfig::from_conf("ws::addr=h:1;query_timeout_ms=soon").unwrap_err();
+        assert_eq!(err.code(), ErrorCode::ConfigError);
+        assert!(
+            err.msg().contains("query_timeout_ms"),
+            "msg must name the key: {}",
+            err.msg()
+        );
+    }
+
+    #[test]
+    fn query_timeout_negative_rejected() {
+        // The field is an unsigned varint on the wire; a negative value is
+        // a `STATUS_PARSE_ERROR` at the server, so reject it at parse time.
+        let err = ReaderConfig::from_conf("ws::addr=h:1;query_timeout_ms=-1").unwrap_err();
+        assert_eq!(err.code(), ErrorCode::ConfigError);
+    }
+
     #[test]
     fn failover_max_duration_defaults_to_30s() {
         let c = ReaderConfig::from_conf("ws::addr=h:1").unwrap();

data/vendor/c-questdb-client/questdb-rs/src/egress/mod.rs

@@ -90,8 +90,8 @@ pub use config::{
 };
 #[cfg(feature = "sync-reader-qwp-ws")]
 pub use reader::{
-    BatchView, Cursor, FailoverPhase, FailoverProgressEvent, FailoverResetEvent, Reader,
-    ReaderQuery, ReaderStats, Terminal,
+    BatchView, Cursor, FailoverPhase, FailoverProgressEvent, FailoverResetEvent,
+    ROWS_AFFECTED_UNKNOWN, Reader, ReaderQuery, ReaderStats, Terminal,
 };
 pub use server_event::{ServerInfo, ServerRole, UpgradeReject};
 pub use symbol_dict::{SymbolDict, SymbolEntry};