questdb 0.1.0 → 0.1.1

data/vendor/c-questdb-client/questdb-rs/src/egress/wire/capabilities.rs

@@ -51,6 +51,28 @@ pub fn has_query_flags(capabilities: u32) -> bool {
     capabilities & CAP_QUERY_FLAGS != 0
 }
 
+/// Bit `0x04` is `CAP_COMPRESSION` on the server (zstd frame compression,
+/// negotiated through the `X-QWP-Accept-Encoding` upgrade header rather than
+/// through this word on the client side). Named here so the next capability
+/// does not reuse the value.
+pub const CAP_COMPRESSION: u32 = 0x0000_0004;
+
+/// Server honours `QUERY_REQUEST.timeout_ms`: it runs the query under the
+/// client-supplied timeout instead of the server-wide `query.timeout`, and
+/// reports expiry as [`StatusCode::QueryTimeout`].
+///
+/// Clients append `timeout_ms` only when this bit is set, so a server
+/// without it never receives the field. The server sets no ceiling, so a
+/// client timeout may legitimately exceed `query.timeout`.
+///
+/// [`StatusCode::QueryTimeout`]: super::msg_kind::StatusCode::QueryTimeout
+pub const CAP_QUERY_TIMEOUT: u32 = 0x0000_0008;
+
+/// True if the server honours the `QUERY_REQUEST` `timeout_ms` field.
+pub fn has_query_timeout(capabilities: u32) -> bool {
+    capabilities & CAP_QUERY_TIMEOUT != 0
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -64,4 +86,51 @@ mod tests {
         // Future bits with CAP_ZONE clear must not trip it.
         assert!(!has_zone(0xFFFF_FFFE));
     }
+
+    #[test]
+    fn has_query_flags_predicate() {
+        assert!(!has_query_flags(0));
+        assert!(has_query_flags(CAP_QUERY_FLAGS));
+        assert!(has_query_flags(CAP_QUERY_FLAGS | 0x8000_0000));
+        assert!(!has_query_flags(!CAP_QUERY_FLAGS));
+    }
+
+    #[test]
+    fn has_query_timeout_predicate() {
+        assert!(!has_query_timeout(0));
+        assert!(has_query_timeout(CAP_QUERY_TIMEOUT));
+        // The timeout bit rides alongside the flags bit on a current
+        // server; neither predicate may depend on the other's absence.
+        assert!(has_query_timeout(CAP_QUERY_TIMEOUT | CAP_QUERY_FLAGS));
+        assert!(has_query_flags(CAP_QUERY_TIMEOUT | CAP_QUERY_FLAGS));
+        assert!(!has_query_timeout(!CAP_QUERY_TIMEOUT));
+    }
+
+    #[test]
+    fn capability_bits_are_distinct_powers_of_two() {
+        // The server assigns these; a duplicated or non-power-of-two value
+        // would make one predicate answer for another capability.
+        let bits = [
+            CAP_ZONE,
+            CAP_QUERY_FLAGS,
+            CAP_COMPRESSION,
+            CAP_QUERY_TIMEOUT,
+        ];
+        let mut seen = 0u32;
+        for b in bits {
+            assert_eq!(b.count_ones(), 1, "0x{b:08X} is not a single bit");
+            assert_eq!(seen & b, 0, "0x{b:08X} duplicates an earlier bit");
+            seen |= b;
+        }
+        // Pin the wire values: the server's QwpConstants owns them.
+        assert_eq!(
+            (
+                CAP_ZONE,
+                CAP_QUERY_FLAGS,
+                CAP_COMPRESSION,
+                CAP_QUERY_TIMEOUT
+            ),
+            (0x01, 0x02, 0x04, 0x08)
+        );
+    }
 }

data/vendor/c-questdb-client/questdb-rs/src/egress/wire/msg_kind.rs

@@ -93,6 +93,12 @@ pub enum StatusCode {
     SecurityError = 0x08,
     Cancelled = 0x0A,
     LimitExceeded = 0x0B,
+    /// The query ran past the `timeout_ms` it carried. Per-query, not
+    /// per-connection: the connection stays open and authenticated, so a
+    /// pooled client runs its next query on it instead of reconnecting.
+    /// Only sent to clients that supplied a timeout; a request without one
+    /// gets [`Self::LimitExceeded`] for the same condition.
+    QueryTimeout = 0x0E,
 }
 
 impl StatusCode {
@@ -104,6 +110,7 @@ impl StatusCode {
             0x08 => StatusCode::SecurityError,
             0x0A => StatusCode::Cancelled,
             0x0B => StatusCode::LimitExceeded,
+            0x0E => StatusCode::QueryTimeout,
             other => {
                 return Err(fmt!(
                     ProtocolError,
@@ -157,8 +164,34 @@ mod tests {
             StatusCode::SecurityError,
             StatusCode::Cancelled,
             StatusCode::LimitExceeded,
+            StatusCode::QueryTimeout,
         ] {
             assert_eq!(StatusCode::from_u8(s.as_u8()).unwrap(), s);
         }
     }
+
+    #[test]
+    fn status_code_wire_values_pinned() {
+        // The server's QwpConstants owns these numbers; a drifted
+        // discriminant would mis-report one server error as another.
+        assert_eq!(StatusCode::SchemaMismatch.as_u8(), 0x03);
+        assert_eq!(StatusCode::ParseError.as_u8(), 0x05);
+        assert_eq!(StatusCode::InternalError.as_u8(), 0x06);
+        assert_eq!(StatusCode::SecurityError.as_u8(), 0x08);
+        assert_eq!(StatusCode::Cancelled.as_u8(), 0x0A);
+        assert_eq!(StatusCode::LimitExceeded.as_u8(), 0x0B);
+        assert_eq!(StatusCode::QueryTimeout.as_u8(), 0x0E);
+    }
+
+    #[test]
+    fn unknown_status_code_rejected() {
+        // 0x0C / 0x0D sit between LimitExceeded and QueryTimeout and are
+        // unassigned: they must not silently decode as a neighbour.
+        for byte in [0x00, 0x04, 0x0C, 0x0D, 0x0F, 0xFF] {
+            assert!(
+                StatusCode::from_u8(byte).is_err(),
+                "0x{byte:02X} must not decode"
+            );
+        }
+    }
 }

data/vendor/c-questdb-client/questdb-rs/src/error.rs

@@ -140,6 +140,12 @@ pub enum ErrorCode {
     HandshakeError,
 
     /// 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
+    /// [`ReaderQuery::timeout`](crate::egress::ReaderQuery::timeout). The
+    /// connection is untouched by that refusal.
     UnsupportedServer,
 
     /// Wire-format violation: bad magic, truncated frame, unknown discriminant,
@@ -174,6 +180,24 @@ pub enum ErrorCode {
     /// Query was cancelled (locally or via server `CANCELLED` status `0x0A`).
     Cancelled,
 
+    /// The query ran past the timeout it carried: server-reported QWP
+    /// `QUERY_TIMEOUT` (status `0x0E`), produced only for a request that
+    /// supplied `timeout_ms`. Per-query, so the connection stays usable and
+    /// a pooled client runs its next query on it.
+    ///
+    /// A timeout requested against a server that does not advertise
+    /// `CAP_QUERY_TIMEOUT` is refused with [`Self::UnsupportedServer`]
+    /// instead, so a caller that retries a timeout with a larger budget
+    /// does not loop against a server that ignores every budget — see
+    /// [`ReaderQuery::timeout`](crate::egress::ReaderQuery::timeout).
+    ///
+    /// **Do not retry a write on this error.** A DDL / `INSERT` / `UPDATE`
+    /// that timed out waiting for the table writer may still be applied
+    /// afterwards, and a statement that completes past its timeout is
+    /// reported as `EXEC_DONE` rather than a timeout precisely so a
+    /// retrying client cannot apply it twice.
+    QueryTimeout,
+
     /// Mid-query failover was eligible but at least one batch had already
     /// been delivered to the caller, and the cursor's `on_failover_reset`
     /// callback was not installed. Failover would replay the query from the
@@ -202,11 +226,14 @@ pub enum ErrorCode {
     /// bug; not user-recoverable. Only emitted on the `arrow` feature.
     ArrowExport,
 
-    /// An irreducible QWP/WebSocket unit (the table schema plus a single
-    /// row block) exceeds the negotiated per-batch cap
-    /// (`min(max_buf_size, server X-QWP-Max-Batch-Size)`). Chunk publication
-    /// splits oversize inputs into smaller frames automatically, so this only
-    /// surfaces when splitting cannot make a frame fit. Distinct from
+    /// A QWP/WebSocket frame exceeds the negotiated per-frame cap
+    /// (`min(max_buf_size, server X-QWP-Max-Batch-Size)`, further bounded by
+    /// the store-and-forward segment payload capacity). Chunk publication
+    /// splits oversize inputs into smaller frames automatically, so there this
+    /// only surfaces for an irreducible unit (the table schema plus a single
+    /// row block). A row [`Buffer`](crate::ingress::Buffer) is published as one
+    /// frame and is never split, so flushing one whose encoded frame exceeds
+    /// the cap fails with this code and publishes nothing. Distinct from
     /// [`InvalidApiCall`](Self::InvalidApiCall) so callers can recognise it
     /// without matching on the error message text.
     BatchTooLarge,
@@ -608,6 +635,7 @@ mod tests {
                 ErrorCode::LimitExceeded => {}
                 ErrorCode::ServerLimitExceeded => {}
                 ErrorCode::Cancelled => {}
+                ErrorCode::QueryTimeout => {}
                 ErrorCode::FailoverWouldDuplicate => {}
                 ErrorCode::SchemaDrift => {}
                 ErrorCode::NoSchema => {}

data/vendor/c-questdb-client/questdb-rs/src/ingress/buffer/qwp.rs

@@ -2559,9 +2559,8 @@ impl QwpWsSizeHint {
         }
 
         QWP_MESSAGE_HEADER_SIZE
-            + 2
             + self.encoded_tables_len
-            + qwp_varint_size(0)
+            + QWP_WS_SYMBOL_ID_MAX_LEN
             + qwp_varint_size(self.symbol_dict_count as u64)
             + self.symbol_dict_bytes
     }
@@ -2831,7 +2830,7 @@ impl QwpWsColumnarBuffer {
 
     #[cfg(test)]
     fn recompute_len_slow(&self) -> usize {
-        let mut total = QWP_MESSAGE_HEADER_SIZE + 2;
+        let mut total = QWP_MESSAGE_HEADER_SIZE;
         let mut symbol_dict_count = 0usize;
         let mut symbol_dict_bytes = 0usize;
         for table in self.tables.iter().filter(|table| table.row_count > 0) {
@@ -2854,7 +2853,10 @@ impl QwpWsColumnarBuffer {
                 }
             }
         }
-        total + qwp_varint_size(0) + qwp_varint_size(symbol_dict_count as u64) + symbol_dict_bytes
+        total
+            + QWP_WS_SYMBOL_ID_MAX_LEN
+            + qwp_varint_size(symbol_dict_count as u64)
+            + symbol_dict_bytes
     }
 
     #[cfg(test)]
@@ -4127,7 +4129,7 @@ impl QwpWsColumnBuffer {
     fn rollback_rows_from(&mut self, from: u32) {
         if let QwpWsColumnValues::Symbol { cells, dict, .. } = &self.values {
             for cell in cells.iter().rev().take_while(|cell| cell.row_idx >= from) {
-                self.symbol_cells_encoded_len -= qwp_varint_size(cell.local_id as u64);
+                self.symbol_cells_encoded_len -= QWP_WS_SYMBOL_ID_MAX_LEN;
                 if cell.is_new {
                     let entry = &dict[cell.local_id as usize];
                     self.symbol_dict_encoded_len -= qwp_string_byte_len(entry.len as usize);
@@ -4317,7 +4319,7 @@ impl QwpWsColumnBuffer {
             is_new,
         });
         self.increment_non_null()?;
-        self.symbol_cells_encoded_len += qwp_varint_size(local_id as u64);
+        self.symbol_cells_encoded_len += QWP_WS_SYMBOL_ID_MAX_LEN;
         if is_new {
             self.symbol_dict_encoded_len += qwp_string_byte_len(bytes.len());
         }
@@ -4881,10 +4883,7 @@ impl QwpWsColumnValues {
                 cells.len().saturating_mul(8)
             }
             Self::String { cells, data } => (cells.len() + 1).saturating_mul(4) + data.len(),
-            Self::Symbol { cells, .. } => cells
-                .iter()
-                .map(|cell| qwp_varint_size(cell.local_id as u64))
-                .sum(),
+            Self::Symbol { cells, .. } => cells.len().saturating_mul(QWP_WS_SYMBOL_ID_MAX_LEN),
             Self::Decimal { cells, .. } => {
                 1 + cells
                     .iter()
@@ -5502,6 +5501,15 @@ impl Default for SymbolGlobalDict {
 #[cfg(feature = "_sender-qwp-ws")]
 pub(crate) const MAX_CONN_SYMBOL_DICT_SIZE: usize = 2_000_000;
 
+/// Bytes the QWP/WS size hint charges for each connection-wide symbol id a
+/// frame carries: every symbol cell, and the delta dictionary's start id.
+/// The buffer cannot see those ids until the flush interns its symbols, so
+/// it charges the widest varint an id can take. Ids stay below
+/// [`MAX_CONN_SYMBOL_DICT_SIZE`] and the start id reaches it at most, which
+/// keeps the hint at or above the encoded frame.
+#[cfg(feature = "_sender-qwp-ws")]
+const QWP_WS_SYMBOL_ID_MAX_LEN: usize = qwp_varint_size(MAX_CONN_SYMBOL_DICT_SIZE as u64);
+
 /// Per-connection cap on the cumulative UTF-8 heap (in bytes) the QWP/WS global
 /// symbol dictionary holds. Matches `MAX_CONN_DICT_HEAP_BYTES` in the egress
 /// reader (`egress/symbol_dict.rs`) and the Java reference client. The entry
@@ -7421,7 +7429,7 @@ fn qwp_string_byte_len(byte_len: usize) -> usize {
     qwp_varint_size(byte_len as u64) + byte_len
 }
 
-fn qwp_varint_size(mut value: u64) -> usize {
+const fn qwp_varint_size(mut value: u64) -> usize {
     let mut size = 1usize;
     while value > 0x7F {
         value >>= 7;
@@ -10562,6 +10570,83 @@ mod tests {
         assert_eq!(buf.len(), buf.recompute_len_slow());
     }
 
+    #[cfg(feature = "_sender-qwp-ws")]
+    #[test]
+    fn qwp_ws_size_hint_covers_encoded_frame_when_symbol_ids_widen() {
+        // A frame carries each symbol cell as its connection-wide id. The
+        // 500-value column comes first, so the other columns' ids start past
+        // its own, and the connection may have interned symbols before.
+        fn add_rows(buf: &mut QwpWsColumnarBuffer, rows: std::ops::Range<i64>) {
+            for i in rows {
+                let row = buf.table("trades").unwrap();
+                row.symbol("ticker", format!("T{:03}", (i * 7919) % 500).as_str())
+                    .unwrap();
+                row.symbol(
+                    "exchange",
+                    ["NYSE", "NASDAQ", "ARCA", "BATS"][(i % 4) as usize],
+                )
+                .unwrap();
+                row.symbol("side", ["buy", "sell"][((i / 3) % 2) as usize])
+                    .unwrap();
+                row.symbol("ccy", ["USD", "EUR", "GBP"][((i / 5) % 3) as usize])
+                    .unwrap();
+                if i % 3 != 0 {
+                    row.symbol("venue", format!("V{}", (i / 7) % 8).as_str())
+                        .unwrap();
+                }
+                row.column_f64("price", i as f64 * 0.5).unwrap();
+                row.at_now().unwrap();
+            }
+        }
+
+        fn assert_covers(
+            buf: &QwpWsColumnarBuffer,
+            global_dict: &mut SymbolGlobalDict,
+            warm: usize,
+            what: &str,
+        ) {
+            let mut scratch = QwpWsEncodeScratch::new();
+            let mut out = Vec::new();
+            buf.encode_ws_replay_message_with_defer(
+                &mut out,
+                &mut scratch,
+                global_dict,
+                QWP_VERSION_1,
+                false,
+                true,
+            )
+            .unwrap();
+            assert!(
+                out.len() <= buf.len(),
+                "{what} after {warm} interned symbols: encoded {} bytes, size hint {}",
+                out.len(),
+                buf.len()
+            );
+        }
+
+        for warm in [0usize, 127, 128, 16_383, 16_384] {
+            let mut global_dict = SymbolGlobalDict::new();
+            for i in 0..warm {
+                global_dict.intern(format!("w{i:05}").as_bytes()).unwrap();
+            }
+            let mut buf = QwpWsColumnarBuffer::new(127);
+
+            add_rows(&mut buf, 0..600);
+            assert_covers(&buf, &mut global_dict, warm, "new symbols");
+
+            buf.clear();
+            add_rows(&mut buf, 600..1200);
+            assert_covers(&buf, &mut global_dict, warm, "known symbols");
+
+            let before_marker = buf.len();
+            buf.set_marker().unwrap();
+            add_rows(&mut buf, 1200..1201);
+            buf.rewind_to_marker().unwrap();
+            assert_eq!(buf.len(), before_marker);
+            assert_covers(&buf, &mut global_dict, warm, "after a rewind");
+        }
+    }
+
     #[cfg(feature = "_sender-qwp-ws")]
     #[test]
     fn qwp_ws_cached_size_hint_recomputes_only_dirty_tables() {

data/vendor/c-questdb-client/questdb-rs/src/ingress/buffer.rs

@@ -549,9 +549,12 @@ impl Buffer {
     ///
     /// For ILP buffers this is the exact serialized byte count. For QWP/UDP
     /// buffers this is the size hint used for flush planning. For QWP/WebSocket
-    /// buffers this is only a local size hint; symbol-ID remapping and replay
-    /// dictionary state can change the eventual frame size. The sender
-    /// enforces `max_buf_size` against the encoded replay message.
+    /// buffers this is a size hint that is at least the size of the frame a
+    /// flush encodes: it charges each symbol value the widest connection-wide
+    /// id. It falls short only once store-and-forward sends full symbol
+    /// dictionaries, which it does when its symbol side-file cannot be opened
+    /// or rolled back. The sender enforces `max_buf_size` against the encoded
+    /// replay message.
     pub fn len(&self) -> usize {
         match &self.inner {
             BufferInner::Ilp(inner) => inner.len(),

data/vendor/c-questdb-client/questdb-rs/src/ingress/column_sender/sender.rs

@@ -33,6 +33,7 @@ use crate::ErrorCode;
 use crate::ingress::AckLevel;
 use crate::ingress::QwpWsSenderError;
 use crate::ingress::buffer::{Buffer, QwpWsColumnarBuffer, QwpWsEncodeScratch, SymbolGlobalDict};
+use crate::ingress::sender::effective_hard_frame_cap;
 use crate::ingress::sender::qwp_ws::{
     SyncQwpWsHandlerState, publish_qwp_ws_payload_background, qwp_ws_acked_fsn_background,
     qwp_ws_begin_close_background, qwp_ws_check_error_background,
@@ -2250,22 +2251,6 @@ impl SfaBackend {
     }
 }
 
-fn effective_hard_frame_cap(
-    max_buf_size: usize,
-    server_max_batch_size: usize,
-    sfa_frame_payload_cap: usize,
-) -> (usize, bool) {
-    let configured_cap = if server_max_batch_size == 0 {
-        max_buf_size
-    } else {
-        max_buf_size.min(server_max_batch_size)
-    };
-    (
-        configured_cap.min(sfa_frame_payload_cap),
-        server_max_batch_size != 0,
-    )
-}
-
 /// The store-and-forward `wait` poll loop made no progress toward `boundary`
 /// for `sync_timeout`. The connection is alive but the server is not advancing
 /// the ack/durable watermark (e.g. back-pressured WAL or a stuck commit).

data/vendor/c-questdb-client/questdb-rs/src/ingress/sender/qwp_ws.rs

@@ -108,14 +108,12 @@ pub(crate) struct TrafficGate {
 #[derive(Default)]
 struct TrafficGateState {
     current: Option<TcpStream>,
-    /// Raw handle of the ORIGINAL socket, not the `current` dup. Winsock
-    /// `shutdown()` does not unblock a `recv()` already in progress on
-    /// another thread, so `shutdown()` first runs `CancelIoEx` — and that
-    /// must target the handle the blocked thread issued its I/O on; a
-    /// `try_clone` (WSADuplicateSocket) handle is not guaranteed to share
-    /// the file object. Only valid while `current` is `Some`: every close
-    /// of the original is mutex-ordered behind `clear()`/re-register, so
-    /// the handle cannot be recycled while the gate still holds it.
+    /// Raw handle of the ORIGINAL socket, not the `current` dup: a shutdown
+    /// through the `try_clone` (WSADuplicateSocket) dup can leave later
+    /// `recv()`s on the original blocking. Only valid while `current` is
+    /// `Some`: every close of the original is mutex-ordered behind
+    /// `clear()`/re-register, so the handle cannot be recycled while the
+    /// gate still holds it.
     #[cfg(windows)]
     original: Option<std::os::windows::io::RawSocket>,
     shut: bool,
@@ -222,15 +220,19 @@ impl TrafficGate {
         state.shut = true;
         #[cfg(windows)]
         if let Some(original) = state.original.take() {
-            // Winsock shutdown() does not unblock an in-progress recv() on
-            // another thread. Cancel outstanding I/O on the worker's own
-            // handle first, mirroring the Java client's windows/net.c
-            // shutdown(). A failure with ERROR_NOT_FOUND (nothing pending)
-            // is expected and deliberately ignored.
+            use std::os::windows::io::FromRawSocket;
             use windows_sys::Win32::Foundation::HANDLE;
+            // Shutdown does not wake an in-flight recv(), so CancelIoEx
+            // follows it; the reverse order lets a recv() slip in between.
+            // SAFETY: `original` is open while `current` is `Some`.
+            let original_stream =
+                std::mem::ManuallyDrop::new(unsafe { TcpStream::from_raw_socket(original) });
+            let shut = shutdown_socket(&original_stream);
             unsafe {
                 windows_sys::Win32::System::IO::CancelIoEx(original as HANDLE, std::ptr::null());
             }
+            state.current = None;
+            return shut;
         }
         if let Some(stream) = state.current.take() {
             shutdown_socket(&stream)?;
@@ -511,6 +513,9 @@ pub(crate) struct ManualQwpWsHandlerState {
     send_core: QwpWsSendCore<BlockingQwpWsTransport>,
     pub(crate) server_max_batch_size: Arc<AtomicUsize>,
     pub(crate) request_durable_ack: bool,
+    /// Hard cap on a single queued frame's payload, as on
+    /// [`SyncQwpWsHandlerState::sfa_frame_payload_cap`].
+    pub(crate) sfa_frame_payload_cap: usize,
     orphan_drainers: Option<ManualOrphanDrainers>,
     append_deadline: Duration,
     close_drain_timeout: Duration,
@@ -3698,6 +3703,7 @@ pub(crate) fn open_manual_qwp_ws(
         send_core: parts.send_core,
         server_max_batch_size,
         request_durable_ack: *qwp_ws.request_durable_ack,
+        sfa_frame_payload_cap: segment_payload_capacity(*qwp_ws.sf_max_segment_bytes),
         orphan_drainers,
         append_deadline: *qwp_ws.sf_append_deadline,
         close_drain_timeout: *qwp_ws.close_flush_timeout,

data/vendor/c-questdb-client/questdb-rs/src/ingress/sender/qwp_ws_driver.rs

@@ -5774,15 +5774,8 @@ mod tests {
             .unwrap();
         let _server_streams = server.join().unwrap();
 
-        // A short read timeout plus a retry loop instead of one indefinitely
-        // blocking read: on Windows the gate's CancelIoEx only cancels a recv
-        // already in flight, and Winsock shutdown() does not wake one entered
-        // afterwards, so a single read can straddle the shutdown and miss
-        // both wake-ups. Retrying sidesteps the race: once the gate has shut
-        // the replacement socket down, the next read attempt fails
-        // immediately. A missing reconnect registration still fails the test,
-        // because the gate never touches this socket and every attempt times
-        // out until the deadline.
+        // Retry short reads so a missed wake-up fails at the deadline
+        // instead of hanging the test.
         transport
             .stream
             .set_timeouts(Some(Duration::from_millis(100)), None)

data/vendor/c-questdb-client/questdb-rs/src/ingress/sender/qwp_ws_publisher.rs

@@ -275,8 +275,8 @@ pub(crate) fn qwp_ws_encoded_message_size_error(
     max_buf_size: usize,
 ) -> crate::Error {
     error::fmt!(
-        InvalidApiCall,
-        "Could not flush buffer: QWP/WebSocket encoded message size of {} exceeds maximum configured allowed size of {} bytes.",
+        BatchTooLarge,
+        "Could not flush buffer: QWP/WebSocket encoded message size of {} bytes exceeds the per-frame cap of {} bytes.",
         encoded_len,
         max_buf_size
     )
@@ -405,7 +405,7 @@ mod tests {
         let err = encoder
             .encode_with_max_size(&buffer, local_hint)
             .unwrap_err();
-        assert_eq!(err.code(), ErrorCode::InvalidApiCall);
+        assert_eq!(err.code(), ErrorCode::BatchTooLarge);
         assert!(err.msg().contains("QWP/WebSocket encoded message size"));
         assert_eq!(encoder.global_dict.len(), seeded_symbols);