questdb 0.1.0 → 0.1.1

data/vendor/c-questdb-client/questdb-rs/tests/egress_live_server.rs

@@ -3664,6 +3664,40 @@ fn cursor_short_circuits_after_query_error() {
     }
 }
 
+#[test]
+#[ignore = "the pinned questdb submodule does not advertise CAP_QUERY_TIMEOUT yet"]
+fn query_timeout_ends_query_and_keeps_connection() {
+    let srv = server();
+    let mut reader = make_reader(srv);
+    let mut cur = reader
+        .prepare("sleep(10)")
+        .timeout(Duration::from_secs(1))
+        .execute()
+        .expect("execute");
+    let err = loop {
+        match cur.next_batch() {
+            Ok(Some(_)) => {}
+            Ok(None) => panic!("sleep(10) must not finish under a 1s timeout"),
+            Err(e) => break e,
+        }
+    };
+    assert_eq!(
+        err.code(),
+        questdb::ErrorCode::QueryTimeout,
+        "{}",
+        err.msg()
+    );
+    assert!(cur.connection_reusable());
+    drop(cur);
+
+    let mut cur = reader
+        .prepare("SELECT x FROM long_sequence(3)")
+        .execute()
+        .expect("execute after timeout");
+    let view = cur.next_batch().expect("next_batch").expect("Some batch");
+    assert_eq!(view.row_count(), 3);
+}
+
 #[test]
 fn null_handling_long_densifies() {
     let srv = server();

data/vendor/c-questdb-client/questdb-rs-ffi/Cargo.lock

@@ -1173,7 +1173,7 @@ dependencies = [
 
 [[package]]
 name = "questdb-rs"
-version = "7.1.0"
+version = "7.2.0"
 dependencies = [
  "aligned-vec",
  "arrow",
@@ -1207,7 +1207,7 @@ dependencies = [
 
 [[package]]
 name = "questdb-rs-ffi"
-version = "7.1.0"
+version = "7.2.0"
 dependencies = [
  "arrow",
  "libc",

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

@@ -1,6 +1,6 @@
 [package]
 name = "questdb-rs-ffi"
-version = "7.1.0"
+version = "7.2.0"
 edition = "2024"
 rust-version = "1.91.0"
 publish = false

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

@@ -2877,6 +2877,10 @@ pub unsafe extern "C" fn qwp_reader_cursor_terminal_end(
 /// If the cursor's terminal is `EXEC_DONE`, set `*out_op_type` and
 /// `*out_rows_affected` and return true. Otherwise zeroes both outputs and
 /// returns false. NULL handle also zeroes the outputs and returns false.
+///
+/// A statement the server executes at parse time reports no row count: it
+/// sends `-1`, which arrives as `ROWS_AFFECTED_UNKNOWN` (`u64::MAX`, the
+/// header's `QWP_READER_ROWS_AFFECTED_UNKNOWN`).
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn qwp_reader_cursor_terminal_exec_done(
     cursor: *const qwp_reader_cursor,
@@ -3020,6 +3024,33 @@ pub unsafe extern "C" fn qwp_reader_query_set_reset_symbol_dict(
     unsafe { mutate_query(query, |q| q.reset_symbol_dict(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`; `0` clears it. Mirrors `ReaderQuery::timeout`.
+///
+/// Unlike `qwp_reader_query_set_reset_symbol_dict`, this does NOT silently
+/// degrade: against a server that does not advertise `CAP_QUERY_TIMEOUT`,
+/// `qwp_reader_query_execute` fails with
+/// `line_sender_error_unsupported_server`, before anything is written,
+/// rather than letting the caller believe a timeout applied; the connection
+/// is untouched by that refusal. On expiry the query ends with
+/// `line_sender_error_query_timeout` and the connection stays usable — but
+/// do not retry a write on it, because 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.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn qwp_reader_query_set_timeout_ms(
+    query: *mut qwp_reader_query,
+    timeout_ms: u64,
+) {
+    unsafe {
+        mutate_query(query, |q| {
+            q.timeout(std::time::Duration::from_millis(timeout_ms))
+        })
+    }
+}
+
 /// Report a NULL out-param contract violation through `err_out`.
 #[inline]
 unsafe fn null_out_param_err(err_out: *mut *mut questdb_error, fn_name: &str) {

data/vendor/c-questdb-client/questdb-rs-ffi/src/lib.rs

@@ -337,6 +337,10 @@ pub 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.
+    /// 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
     /// discriminant, invalid varint, symbol-dict reference miss, etc.
@@ -442,6 +446,24 @@ pub enum line_sender_error_code {
     /// check `line_sender_error_in_doubt` before resending, or the rows the
     /// 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,
 }
 
 /// Neutral spelling of the client-wide error category. The released
@@ -533,6 +555,7 @@ impl From<ErrorCode> for line_sender_error_code {
                 line_sender_error_code::line_sender_error_store_resend_required
             }
             ErrorCode::SymbolDictFull => line_sender_error_code::line_sender_error_symbol_dict_full,
+            ErrorCode::QueryTimeout => line_sender_error_code::line_sender_error_query_timeout,
             _ => line_sender_error_code::line_sender_error_invalid_api_call,
         }
     }
@@ -1493,9 +1516,12 @@ pub unsafe extern "C" fn line_sender_buffer_clear(buffer: *mut line_sender_buffe
 
 /// 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.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn line_sender_buffer_size(buffer: *const line_sender_buffer) -> size_t {
     unsafe {
@@ -3932,6 +3958,46 @@ pub unsafe extern "C" fn line_sender_qwpws_errors_dropped(
     }
 }
 
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn line_sender_qwpws_effective_frame_cap(
+    sender: *const line_sender,
+    cap_out: *mut usize,
+    server_cap_known_out: *mut bool,
+    err_out: *mut *mut line_sender_error,
+) -> bool {
+    unsafe {
+        if cap_out.is_null() || server_cap_known_out.is_null() {
+            let output = if cap_out.is_null() {
+                "cap_out"
+            } else {
+                "server_cap_known_out"
+            };
+            set_err_out(
+                err_out,
+                ErrorCode::InvalidApiCall,
+                format!("line_sender_qwpws_effective_frame_cap requires non-NULL {output}"),
+            );
+            return false;
+        }
+        let Some(sender) =
+            qwpws_line_sender_ref(sender, err_out, "line_sender_qwpws_effective_frame_cap")
+        else {
+            return false;
+        };
+        match sender.effective_frame_cap() {
+            Ok((cap, server_cap_known)) => {
+                *cap_out = cap;
+                *server_cap_known_out = server_cap_known;
+                true
+            }
+            Err(err) => {
+                set_err_out_from_sender_error(err_out, sender, err);
+                false
+            }
+        }
+    }
+}
+
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn line_sender_qwpws_close_drain(
     sender: *mut line_sender,
@@ -5873,6 +5939,7 @@ mod tests {
                 36,
             ),
             (E::SymbolDictFull, line_sender_error_symbol_dict_full, 37),
+            (E::QueryTimeout, line_sender_error_query_timeout, 38),
         ]
     }
 

data/vendor/c-questdb-client/system_test/arrow_ffi.py

@@ -148,6 +148,7 @@ class ClientErrorCode:
     BATCH_TOO_LARGE = 35
     STORE_RESEND_REQUIRED = 36
     SYMBOL_DICT_FULL = 37
+    QUERY_TIMEOUT = 38
 
 
 def _setsig(name, restype, *argtypes):

data/vendor/c-questdb-client/system_test/enterprise_e2e/tests/test_failover.py

@@ -798,19 +798,25 @@ def test_orphan_drainer_durable_ack_survives_kill_c_client_rust(
     p1.kill_9()
     wait_port_free(p1_ports.http)
     wait_port_free(p1_ports.pg)
+    # Stop the old drainer before P2 opens the same ports. It can reconnect
+    # autonomously, and the fresh CONNECT below could replay the slot again.
+    c_client_rust_sidecar.close()
     if p1.db_root.exists():
         shutil.rmtree(p1.db_root)
     obj_store.wipe()
 
     p2 = server_factory("p2", db_root_name="p2-fresh")
     p2.start(http_port=p1_ports.http, pg_port=p1_ports.pg)
+    # Replay is at least once across a lost ACK. Prepare the fresh target with
+    # the same dedup key used by the other SF recovery tests.
+    execute_ddl(port=p1_ports.pg, ddl=(
+        f'CREATE TABLE "{table}" ('
+        "v LONG, timestamp TIMESTAMP"
+        ") TIMESTAMP(timestamp) PARTITION BY DAY WAL "
+        "DEDUP UPSERT KEYS(timestamp, v)"
+    ))
 
-    # When P1 died mid-drain the orphan worker returned RetryLater and stopped:
-    # the Rust drainer (drain_orphan_to_completion) does NOT autonomously
-    # reconnect to a successor within one attempt. The orphan slot is only
-    # re-attempted by a *fresh* orphan scan, which runs on the next CONNECT with
-    # drain_orphans=on. Reconnect the foreground sender so a new scan adopts the
-    # still-un-acked ghost slot and replays it to P2.
+    # A new scan adopts the still-un-acked ghost slot and replays it to P2.
     c_client_rust_sidecar.connect(fg_cs)
 
     wait_for_dense_sequence(port=p1_ports.pg, table=table,

data/vendor/c-questdb-client/system_test/enterprise_e2e/tests/test_orphan_drainer_bindings.py

@@ -25,7 +25,7 @@ from pathlib import Path
 
 import pytest
 
-from lib.pg_query import count_rows, wait_for_dense_sequence
+from lib.pg_query import count_rows, execute_ddl, wait_for_dense_sequence
 from lib.server import wait_port_free
 
 LOG = logging.getLogger(__name__)
@@ -76,15 +76,23 @@ def _survives_kill_body(sidecar, server_factory, obj_store, scenario_dir: Path,
     p1.kill_9()
     wait_port_free(p1_ports.http)
     wait_port_free(p1_ports.pg)
+    # Stop the old drainer before P2 opens the same ports; it can reconnect
+    # autonomously while the fresh CONNECT below is preparing another replay.
+    sidecar.close()
     if p1.db_root.exists():
         shutil.rmtree(p1.db_root)
     obj_store.wipe()
 
     p2 = server_factory("p2", db_root_name="p2-fresh")
     p2.start(http_port=p1_ports.http, pg_port=p1_ports.pg)
-
-    # A fresh orphan scan on reconnect re-adopts the still-un-acked ghost slot
-    # and replays it to P2.
+    execute_ddl(port=p1_ports.pg, ddl=(
+        f'CREATE TABLE "{table}" ('
+        "v LONG, timestamp TIMESTAMP"
+        ") TIMESTAMP(timestamp) PARTITION BY DAY WAL "
+        "DEDUP UPSERT KEYS(timestamp, v)"
+    ))
+
+    # A fresh scan re-adopts the still-un-acked ghost slot and replays it to P2.
     sidecar.connect(fg_cs)
     wait_for_dense_sequence(port=p1_ports.pg, table=table,
                             expected_count=row_count, timeout_s=60.0)

data/vendor/c-questdb-client/system_test/failover_clients/Cargo.lock

@@ -2679,7 +2679,7 @@ checksum = "7aceffde1cbf8e67f34cdfd70d2436396176d6ff648fa719e0231fb9856ef3e9"
 
 [[package]]
 name = "questdb-rs"
-version = "7.1.0"
+version = "7.2.0"
 dependencies = [
  "aligned-vec",
  "arrow",

data/vendor/c-questdb-client/system_test/soak/workload_rs/Cargo.lock

@@ -2785,7 +2785,7 @@ checksum = "7aceffde1cbf8e67f34cdfd70d2436396176d6ff648fa719e0231fb9856ef3e9"
 
 [[package]]
 name = "questdb-rs"
-version = "7.1.0"
+version = "7.2.0"
 dependencies = [
  "aligned-vec",
  "arrow",

data/vendor/c-questdb-client.version

@@ -1 +1 @@
-c-questdb-client 6daaea468263a289685a9a483c68a3baf69b38c4 (7.1.0)
+c-questdb-client a236dbffba41239d08740ea0d24eb7e0e7fafa47 (7.2.0)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: questdb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - QuestDB
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-20 00:00:00.000000000 Z
+date: 2026-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -148,6 +148,7 @@ files:
 - examples/tls_auth.rb
 - ext/questdb_ingress/extconf.rb
 - ext/questdb_ingress/questdb_ingress.c
+- ext/questdb_ingress/unlink_build_ruby.rb
 - lib/questdb.rb
 - lib/questdb/arrow.rb
 - lib/questdb/client.rb
@@ -173,6 +174,7 @@ files:
 - script/build-native-gem
 - script/build-release-ruby
 - script/check-license-headers
+- script/check-native-linkage
 - script/fault-soak
 - script/query-failover-smoke
 - script/stage-native-extension
@@ -184,6 +186,7 @@ files:
 - test/buffer_test.rb
 - test/client_test.rb
 - test/direct_ingestion_test.rb
+- test/extconf_link_flags_test.rb
 - test/integration_test.rb
 - test/live_callbacks_test.rb
 - test/native_lifecycle_test.rb