arrowbricks 1.3.2__tar.gz → 1.3.3__tar.gz

{arrowbricks-1.3.2 → arrowbricks-1.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arrowbricks
-Version: 1.3.2
+Version: 1.3.3
 Requires-Dist: arro3-core>=0.8 ; extra == 'arro3'
 Provides-Extra: arro3
 License-File: LICENSE
@@ -191,7 +191,7 @@ con.register("my_table", table)
 con.sql("SELECT count(*) FROM my_table").show()
 ```
 
-`ReplayableArrowChunk` works the same way for Arrow-IPC bytes you fetched and stored earlier (e.g. `client.execute_arrow_statement(...)`'s raw chunk bytes, cached in Redis/a file/wherever) -- DuckDB's registration path calls `__arrow_c_stream__` twice (a schema peek, then the actual scan), which is exactly what `ReplayableArrowChunk` exists to support:
+`ReplayableArrowChunk` works the same way for Arrow-IPC bytes you fetched and stored earlier (e.g. a raw chunk's bytes, cached in Redis/a file/wherever) -- DuckDB's registration path calls `__arrow_c_stream__` twice (a schema peek, then the actual scan), which is exactly what `ReplayableArrowChunk` exists to support:
 
 ```python
 from arrowbricks import ReplayableArrowChunk

{arrowbricks-1.3.2 → arrowbricks-1.3.3}/README.md

@@ -179,7 +179,7 @@ con.register("my_table", table)
 con.sql("SELECT count(*) FROM my_table").show()
 ```
 
-`ReplayableArrowChunk` works the same way for Arrow-IPC bytes you fetched and stored earlier (e.g. `client.execute_arrow_statement(...)`'s raw chunk bytes, cached in Redis/a file/wherever) -- DuckDB's registration path calls `__arrow_c_stream__` twice (a schema peek, then the actual scan), which is exactly what `ReplayableArrowChunk` exists to support:
+`ReplayableArrowChunk` works the same way for Arrow-IPC bytes you fetched and stored earlier (e.g. a raw chunk's bytes, cached in Redis/a file/wherever) -- DuckDB's registration path calls `__arrow_c_stream__` twice (a schema peek, then the actual scan), which is exactly what `ReplayableArrowChunk` exists to support:
 
 ```python
 from arrowbricks import ReplayableArrowChunk

{arrowbricks-1.3.2 → arrowbricks-1.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arrowbricks"
-version = "1.3.2"
+version = "1.3.3"
 description = "Runs SQL against a Databricks SQL warehouse via the Statement Execution API and hands you the result as Arrow -- a DB-API-ish Cursor (fetchone/fetchmany/fetchall/fetchall_arrow) or NDJSON streaming. Rust/PyO3 core throughout -- zero required runtime dependencies."
 readme = "README.md"
 license = "MIT"
@@ -10,8 +10,8 @@ requires-python = ">=3.11"
 # (see rust/arrowbricks_core's own reqwest client + Arrow-IPC/NDJSON
 # writer). arro3-core is optional (see below): only Cursor.fetchone/
 # fetchmany/fetchall's row materialization needs it -- fetchall_arrow,
-# execute_arrow, stream_query_json, upload_volume_file/delete_volume_file,
-# and Cursor.description all work with zero dependencies installed.
+# stream_query_json, upload_volume_file/delete_volume_file, and
+# Cursor.description all work with zero dependencies installed.
 dependencies = []
 
 [project.optional-dependencies]

{arrowbricks-1.3.2 → arrowbricks-1.3.3}/rust/arrowbricks_core/Cargo.lock

@@ -240,7 +240,7 @@ dependencies = [
 
 [[package]]
 name = "arrowbricks_core"
-version = "1.3.2"
+version = "1.3.3"
 dependencies = [
  "arrow",
  "arrow-json",

{arrowbricks-1.3.2 → arrowbricks-1.3.3}/rust/arrowbricks_core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "arrowbricks_core"
-version = "1.3.2"
+version = "1.3.3"
 edition = "2024"
 readme = "README.md"
 

{arrowbricks-1.3.2 → arrowbricks-1.3.3}/rust/arrowbricks_core/README.md

@@ -48,7 +48,8 @@ async def main():
         warehouse_id="abcd1234efgh5678",
         token="dapi...",
     )
-    table = await client.execute_arrow("SELECT * FROM my_catalog.my_schema.my_table LIMIT 100")
+    result = await client.execute("SELECT * FROM my_catalog.my_schema.my_table LIMIT 100")
+    table = await result.fetchall_arrow()
     print(table.num_rows)
 
 
@@ -66,17 +67,14 @@ unlike the table object itself.
 ## API
 
 - `Client(host, warehouse_id, *, token=None, token_provider=None, chunk_fetch_concurrency=64, http_timeout=60.0, wait_timeout="30s", warehouse_start_timeout=300.0, warehouse_confirmed_running_ttl_s=30.0, compress_results=True)` -- exactly one of `token`/`token_provider`. `token_provider` is a callable (sync or async) returning a token string, called fresh on every request, no caching. `compress_results` requests LZ4-compressed cloud-fetch chunks (see above); set `False` to opt out.
-- `Client.execute_arrow(statement, *, catalog=None, schema=None, parameters=None) -> Table` -- eager: fetches and assembles the whole result before returning. `parameters` is Databricks' own named-parameter format (`[{"name":..., "value":..., "type":...}]`), passed straight through.
-- `Client.execute(statement, *, catalog=None, schema=None, parameters=None) -> ResultSet` -- submits and starts background chunk fetching without pulling anything yet.
+- `Client.execute(statement, *, catalog=None, schema=None, parameters=None) -> ResultSet` -- submits and starts background chunk fetching without pulling anything yet. `parameters` is Databricks' own named-parameter format (`[{"name":..., "value":..., "type":...}]`), passed straight through.
   - `ResultSet.fetchmany_arrow(n) -> Table` -- pulls/decodes only as many chunks as needed for `n` rows, buffering the rest; may return fewer than `n` once exhausted.
   - `ResultSet.fetchall_arrow() -> Table` -- drains everything remaining.
+  - `ResultSet.fetchall_arrow_streamed(*, total_timeout_s=None)` -- same as `fetchall_arrow()`, but an async iterator yielding the `HEARTBEAT` singleton while pulling chunks instead of blocking silently (bridge e.g. an SSE connection through the download), then a `Table` exactly once. Raises if `total_timeout_s` elapses first.
   - `ResultSet.schema() -> list[tuple[str, str]] | None` -- the real decoded Arrow schema as `(name, type_name)` string pairs, once known (after >=1 fetch); `None` before that. Computed directly in Rust -- unlike a `Table`'s own `.schema`, this needs no arro3 install.
   - `ResultSet.statement_id`, `ResultSet.num_chunks`, `ResultSet.columns` (manifest-based pre-fetch schema estimate, also arro3-free).
-- `Client.execute_json(statement, *, catalog=None, schema=None, parameters=None) -> list[list[str | None]]` -- JSON_ARRAY format, no Arrow parse. Every non-null value comes back as a string regardless of real column type (Databricks' own contract) -- cast by the manifest's column type yourself if you want native Python types.
 - `Client.stream_ndjson_lines(statement, *, catalog=None, schema=None, parameters=None, total_timeout_s=None)` -- chunk-at-a-time: an async iterator yielding the `HEARTBEAT` singleton while waiting on the statement or any individual chunk, then a `list[str]` of NDJSON lines (one per row, explicit nulls, ISO-8601 timestamps) per chunk in logical order. Decode and JSON encoding both happen in Rust -- backs `stream_query_json` end to end.
 - `Client.upload_volume_file(volume_path, data: bytes)` / `Client.delete_volume_file(volume_path)` -- Unity Catalog volume files via the Files API. Delete treats a 404 as success (idempotent). Both raise a plain `RuntimeError` (message only) on failure.
-- `Client.execute_streamed(statement, *, catalog=None, schema=None, parameters=None, total_timeout_s=None)` -- like `execute()`, but an async iterator yielding the `HEARTBEAT` singleton while waiting on Databricks instead of blocking silently (bridge e.g. an SSE connection through a slow warehouse cold start), then a `ResultSet` exactly once. Raises if `total_timeout_s` elapses first.
-  - `ResultSet.fetchall_arrow_streamed(*, total_timeout_s=None)` -- same idea for the chunk-download phase: yields `HEARTBEAT` while pulling chunks, then a `Table` exactly once.
 - `write_ipc_stream(stream, buf)` -- free function; writes any object implementing `__arrow_c_stream__` (a `Table` from this crate, arro3, pyarrow, ...) as uncompressed Arrow-IPC stream bytes to a Python file-like object. No dependency needed regardless of the input's origin.
 - `read_ipc_stream(data: bytes) -> Table` -- free function; the exact inverse of `write_ipc_stream`, parsing raw Arrow-IPC stream bytes back into a `Table`. No dependency needed regardless of where the bytes came from -- backs `arrowbricks.ReplayableArrowChunk`, which needs to re-parse the same cached bytes on every `__arrow_c_stream__` call.
 - `HEARTBEAT` -- module-level singleton; compare with `is`, e.g. `if item is _core.HEARTBEAT: ...`.
@@ -90,7 +88,8 @@ directly, no pandas/pyarrow conversion step, no extra dependency:
 ```python
 import duckdb
 
-result = await client.execute_arrow("SELECT * FROM my_catalog.my_schema.my_table")
+result_set = await client.execute("SELECT * FROM my_catalog.my_schema.my_table")
+result = await result_set.fetchall_arrow()
 print(duckdb.sql("SELECT count(*) FROM result").fetchall())
 ```
 

{arrowbricks-1.3.2 → arrowbricks-1.3.3}/rust/arrowbricks_core/examples/duckdb_query.py

@@ -27,7 +27,8 @@ async def main() -> None:
         warehouse_id=os.environ["DATABRICKS_WAREHOUSE_ID"],
         token=os.environ["DATABRICKS_TOKEN"],
     )
-    result = await client.execute_arrow("SELECT * FROM my_catalog.my_schema.my_table LIMIT 1000000")  # noqa: F841 -- read by DuckDB's replacement scan via local variable name, not a literal Python reference
+    result_set = await client.execute("SELECT * FROM my_catalog.my_schema.my_table LIMIT 1000000")
+    result = await result_set.fetchall_arrow()  # noqa: F841 -- read by DuckDB's replacement scan via local variable name, not a literal Python reference
 
     # `result` is queryable by variable name -- DuckDB imports it zero-copy,
     # no pandas/pyarrow conversion step in between.

{arrowbricks-1.3.2 → arrowbricks-1.3.3}/rust/arrowbricks_core/src/client.rs

@@ -197,7 +197,18 @@ impl ApiError {
     /// (excluding `is_connect()`/`is_timeout()`, already handled) also covers
     /// hyper's own "connection closed before message completed" pooled-
     /// connection-reuse race, which fires before any body is even read and
-    /// is equally safe to retry on an idempotent request.
+    /// is equally safe to retry on an idempotent request. Unlike `is_decode()`
+    /// (hit for real on a 400-chunk fetch and reproduced with a directed
+    /// test), this specific race is reasoned from reqwest/hyper's own source,
+    /// not independently reproduced -- a directed attempt to force it
+    /// self-healed 20/20 times (hyper's own idle-connection health check
+    /// evidently detects a closed peer and opens a fresh connection before
+    /// ever handing the dead one out for reuse, at least under a simple,
+    /// low-concurrency test). Kept anyway since it's safe regardless (scoped
+    /// to idempotent requests only) and the window may still be reachable
+    /// under real production concurrency even though a quick local test
+    /// couldn't force it -- treat as a plausible defensive measure, not a
+    /// confirmed fix for an observed failure.
     fn from_reqwest(e: reqwest::Error, idempotent: bool) -> Self {
         // `is_decode()` (reqwest's `Kind::Decode`) isn't only content-decoding
         // -- `Response::bytes()`/`.text()`/`.json()` also wrap a body read
@@ -219,8 +230,18 @@ impl ApiError {
         }
     }
 
-    fn from_status(status: StatusCode, body: &str) -> Self {
-        let transient = matches!(status.as_u16(), 401 | 403 | 408 | 429) || status.is_server_error();
+    /// `idempotent` only gates the 5xx case -- 401/403/408/429 mean the
+    /// request was rejected before any processing started (auth failure,
+    /// rate limit, client-side timeout), safe to retry regardless of method.
+    /// A 5xx is murkier: it usually means the same, but it can also mean the
+    /// backend already accepted and started the statement before some later
+    /// failure (e.g. a gateway timeout) produced the 5xx anyway -- found in
+    /// code review that this call was unconditionally transient even for the
+    /// statement-submit POST, bypassing the exact idempotency reasoning
+    /// `from_reqwest`'s `idempotent` param exists for (retrying that POST
+    /// risks a second, duplicate execution of arbitrary caller SQL).
+    fn from_status(status: StatusCode, body: &str, idempotent: bool) -> Self {
+        let transient = matches!(status.as_u16(), 401 | 403 | 408 | 429) || (idempotent && status.is_server_error());
         Self {
             message: format!("HTTP {status}: {body}"),
             transient,
@@ -316,14 +337,22 @@ fn decompress_lz4_frame(compressed: &Bytes) -> Result<Bytes, ApiError> {
     // small lower bound.
     let mut out = Vec::with_capacity(compressed.len() * 4);
     let mut decoder = lz4_flex::frame::FrameDecoder::new(&compressed[..]);
-    loop {
-        let before = out.len();
+    // Terminate on the *reader* being exhausted, not on "output stopped
+    // growing" -- found in code review that a frame which happens to decode
+    // to zero bytes (a real, valid LZ4 Frame shape: header + immediate
+    // EndMark) makes one `read_to_end` call return `Ok(0)` for that frame
+    // without erroring and without necessarily advancing into the next
+    // frame yet, which the old `out.len() == before` check read as "no more
+    // frames" -- silently dropping every subsequent concatenated frame with
+    // no error at all. Same silent-truncation shape as the original
+    // multi-frame bug this loop exists to fix. Looping while the reader
+    // still has bytes left (regardless of whether the last call grew `out`)
+    // is the correct fix -- verified against a zero-content frame sandwiched
+    // between two real ones, see `decompress_lz4_frame_survives_a_zero_content_frame_in_the_middle`.
+    while !decoder.get_ref().is_empty() {
         decoder
             .read_to_end(&mut out)
             .map_err(|e| ApiError::permanent(format!("LZ4 frame decompress failed: {e}")))?;
-        if out.len() == before {
-            break;
-        }
     }
     Ok(Bytes::from(out))
 }
@@ -499,7 +528,7 @@ impl DbClient {
             let status = resp.status();
             let text = resp.text().await.map_err(|e| ApiError::from_reqwest(e, idempotent))?;
             if !status.is_success() {
-                return Err(ApiError::from_status(status, &text));
+                return Err(ApiError::from_status(status, &text, idempotent));
             }
             serde_json::from_str::<T>(&text).map_err(|e| ApiError::permanent(format!("bad JSON body: {e}")))
         })
@@ -530,7 +559,7 @@ impl DbClient {
             let status = resp.status();
             if !status.is_success() {
                 let text = resp.text().await.unwrap_or_default();
-                return Err(ApiError::from_status(status, &text));
+                return Err(ApiError::from_status(status, &text, true));
             }
             let bytes = resp.bytes().await.map_err(|e| ApiError::from_reqwest(e, true))?;
             if !compressed {
@@ -837,7 +866,7 @@ impl DbClient {
             let status = resp.status();
             if !status.is_success() {
                 let text = resp.text().await.unwrap_or_default();
-                return Err(ApiError::from_status(status, &text));
+                return Err(ApiError::from_status(status, &text, true));
             }
             Ok(())
         })
@@ -866,7 +895,7 @@ impl DbClient {
                 return Ok(());
             }
             let text = resp.text().await.unwrap_or_default();
-            Err(ApiError::from_status(status, &text))
+            Err(ApiError::from_status(status, &text, true))
         })
         .await
     }
@@ -932,6 +961,44 @@ mod tests {
         assert_eq!(decompressed, Bytes::from(expected));
     }
 
+    /// Regression test for a bug found in code review: a real, valid LZ4
+    /// Frame that happens to decode to zero bytes (a header immediately
+    /// followed by an EndMark -- a legal frame shape, not malformed input)
+    /// makes `read_to_end` return `Ok(0)` for that frame without erroring.
+    /// The old loop read "output didn't grow" as "no more frames" and
+    /// stopped there, silently dropping every frame concatenated after the
+    /// empty one. `decompress_lz4_frame` must keep going as long as the
+    /// underlying reader still has bytes left, not just as long as output
+    /// keeps growing.
+    #[test]
+    fn decompress_lz4_frame_survives_a_zero_content_frame_in_the_middle() {
+        use std::io::Write;
+
+        fn compress_one_frame(data: &[u8]) -> Vec<u8> {
+            let mut encoder = lz4_flex::frame::FrameEncoder::new(Vec::new());
+            encoder.write_all(data).unwrap();
+            encoder.finish().unwrap()
+        }
+
+        let part_a = b"the quick brown fox jumps over the lazy dog ".repeat(50);
+        let part_b = b"pack my box with five dozen liquor jugs ".repeat(50);
+        let mut concatenated_frames = Vec::new();
+        concatenated_frames.extend(compress_one_frame(&part_a));
+        concatenated_frames.extend(compress_one_frame(b"")); // real frame, zero content
+        concatenated_frames.extend(compress_one_frame(&part_b));
+
+        let decompressed = decompress_lz4_frame(&Bytes::from(concatenated_frames)).unwrap();
+
+        let mut expected = Vec::new();
+        expected.extend_from_slice(&part_a);
+        expected.extend_from_slice(&part_b);
+        assert_eq!(
+            decompressed,
+            Bytes::from(expected),
+            "the frame after the zero-content one must not be silently dropped"
+        );
+    }
+
     fn ok_task() -> tokio::task::JoinHandle<Result<(), ApiError>> {
         tokio::spawn(async { Ok(()) })
     }

{arrowbricks-1.3.2 → arrowbricks-1.3.3}/rust/arrowbricks_core/src/lib.rs

@@ -19,11 +19,6 @@ use client::{ApiError, DbClient, TokenFuture, TokenProvider};
 use heartbeat::{HeartbeatStream, HeartbeatWait, Tick};
 use pipeline::{NdjsonStream, ResultStream};
 
-#[pyfunction]
-fn ping() -> &'static str {
-    "pong"
-}
-
 /// Writes any object implementing `__arrow_c_stream__` (a `Table`/
 /// `RecordBatchReader` from this crate, arro3, pyarrow, or anything else
 /// Arrow-C-Data-Interface-compatible) as Arrow-IPC stream bytes to `buf` (a
@@ -125,19 +120,32 @@ fn heartbeat_singleton(py: Python<'_>) -> PyResult<Py<PyHeartbeat>> {
 /// whatever this future awaits.
 ///
 /// `get_token` isn't only ever called from the outermost task
-/// `future_into_py` wraps -- `execute()`/`execute_arrow()` spawn chunk-fetch
+/// `future_into_py` wraps -- `execute()`'s `ResultSet` spawns chunk-fetch
 /// worker tasks (`fetch_chunks_with_backpressure`) that each call an
 /// authenticated endpoint (chunk-index resolution) too, and those inner
 /// `tokio::spawn`ed tasks don't inherit the outer task's asyncio-event-loop
 /// context. Calling `pyo3_async_runtimes::tokio::into_future` from one of
 /// them fails with "no running event loop" -- caught by testing an async
 /// `token_provider` against a multi-chunk result, not by the eager/sync
-/// cases alone. Fix: capture the current task's `TaskLocals` on first use
-/// (guaranteed to be the outer context, since `execute_arrow_statement`
-/// always needs a token before any worker is spawned) and cache it, so
-/// later calls -- including from worker tasks -- run inside
-/// `pyo3_async_runtimes::tokio::scope` with that same captured context
-/// instead of trying to discover one from whatever task happens to call.
+/// cases alone. Fix: capture the current task's `TaskLocals` (guaranteed to
+/// be the outer context, since `execute_arrow_statement` always needs a
+/// token before any worker is spawned) and cache it, so later calls --
+/// including from worker tasks -- run inside `pyo3_async_runtimes::tokio::scope`
+/// with that same captured context instead of trying to discover one from
+/// whatever task happens to call.
+///
+/// The capture re-runs on **every** call from a context that has its own
+/// loop, not just the first ever -- found in code review that caching only
+/// once-if-`None` pins the `DbClient` (which persists across many separate
+/// `execute()` calls, by design -- see its own doc comment) to whichever
+/// event loop happened to be running the very first time a token was ever
+/// requested. A second, later `asyncio.run()` (or any fresh loop -- a
+/// restarted worker, a new pytest-asyncio test) then scopes the awaited
+/// provider onto a loop that's already closed, failing with "Event loop is
+/// closed" instead of just using the current one. Re-capturing costs
+/// nothing extra from a worker task (its own attempt fails, same as before,
+/// falling through to whatever's cached) since the outer call for *this*
+/// statement already refreshed the cache before any worker was spawned.
 struct PyTokenProvider {
     callable: Py<PyAny>,
     locals: Mutex<Option<TaskLocals>>,
@@ -148,13 +156,15 @@ impl TokenProvider for PyTokenProvider {
         let callable = Python::attach(|py| self.callable.clone_ref(py));
         let locals = {
             let mut guard = self.locals.lock().unwrap();
-            if guard.is_none() {
-                // Best-effort: if this call isn't in a context with a
-                // running loop either, leave it None and fall through to
-                // the no-scope path below (matches today's behavior).
-                if let Ok(captured) = Python::attach(pyo3_async_runtimes::tokio::get_current_locals) {
-                    *guard = Some(captured);
-                }
+            // Unconditional, not `if guard.is_none()` -- see this struct's
+            // own doc comment for why caching only once pinned the client to
+            // its first-ever event loop. Best-effort: if this particular
+            // call isn't in a context with a running loop either (a worker
+            // task), leave whatever's already cached alone and fall through
+            // to using that (or the no-scope path below, if nothing has ever
+            // been captured at all).
+            if let Ok(captured) = Python::attach(pyo3_async_runtimes::tokio::get_current_locals) {
+                *guard = Some(captured);
             }
             guard.clone()
         };
@@ -192,8 +202,8 @@ impl TokenProvider for PyTokenProvider {
 }
 
 /// One Databricks SQL warehouse endpoint -- a persistent `reqwest::Client`
-/// (connection pool) reused across every `execute`/`execute_arrow` call,
-/// same reason Python's own `DatabricksClient` reuses one `httpx.AsyncClient`
+/// (connection pool) reused across every `execute` call, same reason
+/// Python's own `DatabricksClient` reuses one `httpx.AsyncClient`
 /// rather than building a fresh one per statement: repeated TCP+TLS
 /// handshakes are pure waste against the same host.
 #[pyclass(name = "Client")]
@@ -234,7 +244,12 @@ impl PyDbClient {
         compress_results: bool,
     ) -> PyResult<Self> {
         let db_client = match (token, token_provider) {
-            (Some(t), _) => DbClient::new(&host, &warehouse_id, &t),
+            (Some(_), Some(_)) => {
+                return Err(PyValueError::new_err(
+                    "Client needs exactly one of `token` or `token_provider`, not both",
+                ));
+            }
+            (Some(t), None) => DbClient::new(&host, &warehouse_id, &t),
             (None, Some(callable)) => {
                 let provider: Arc<dyn TokenProvider> = Arc::new(PyTokenProvider {
                     callable,
@@ -257,32 +272,6 @@ impl PyDbClient {
         })
     }
 
-    /// Full submit->poll->fetch->reorder->decode pipeline for one
-    /// ARROW_STREAM statement, eagerly assembling the whole result. Returns
-    /// a `pyo3_arrow` `Table` -- it implements the Arrow C Data Interface
-    /// (`__arrow_c_stream__`), so DuckDB/pyarrow/arro3 can all import it
-    /// directly, zero-copy. For a large result where you don't want the
-    /// whole thing pulled upfront, use `execute()` + `ResultSet.fetchmany_arrow`.
-    #[pyo3(signature = (statement, catalog=None, schema=None, parameters=None))]
-    fn execute_arrow<'py>(
-        &self,
-        py: Python<'py>,
-        statement: String,
-        catalog: Option<String>,
-        schema: Option<String>,
-        parameters: Option<Py<PyAny>>,
-    ) -> PyResult<Bound<'py, PyAny>> {
-        let client = self.inner.clone();
-        let parameters = parameters_to_value(py, parameters)?;
-        pyo3_async_runtimes::tokio::future_into_py(py, async move {
-            let result = pipeline::run_pipeline(client, &statement, catalog.as_deref(), schema.as_deref(), parameters)
-                .await
-                .map_err(|e| PyRuntimeError::new_err(e.message))?;
-            let arrow_schema = result.schema.unwrap_or_else(|| Arc::new(Schema::empty()));
-            PyTable::try_new(result.batches, arrow_schema).map_err(|e| PyRuntimeError::new_err(e.to_string()))
-        })
-    }
-
     /// Submits the statement and starts background chunk fetching, without
     /// pulling any of it yet -- returns a `ResultSet` for on-demand
     /// `fetchmany_arrow`/`fetchall_arrow`, mirroring `cursor.py`'s
@@ -312,60 +301,6 @@ impl PyDbClient {
         })
     }
 
-    /// Like `execute()`, but yields `HEARTBEAT` while waiting on Databricks
-    /// instead of blocking silently -- for bridging e.g. an SSE connection
-    /// during a possible multi-minute cold warehouse start. Yields
-    /// `HEARTBEAT` zero or more times, then a `ResultSet` once ready to
-    /// fetch. Not async itself (matches `cursor.py`'s own `execute_streamed`,
-    /// a sync method returning an async generator) -- the submit/poll starts
-    /// running immediately in the background regardless of when the caller
-    /// starts iterating.
-    #[pyo3(signature = (statement, catalog=None, schema=None, parameters=None, total_timeout_s=None))]
-    fn execute_streamed(
-        &self,
-        py: Python<'_>,
-        statement: String,
-        catalog: Option<String>,
-        schema: Option<String>,
-        parameters: Option<Py<PyAny>>,
-        total_timeout_s: Option<f64>,
-    ) -> PyResult<PyExecuteStreamedIter> {
-        let client = self.inner.clone();
-        let parameters = parameters_to_value(py, parameters)?;
-        let fut = async move {
-            pipeline::execute_lazy(client, &statement, catalog.as_deref(), schema.as_deref(), parameters).await
-        };
-        Ok(PyExecuteStreamedIter {
-            wait: Arc::new(AsyncMutex::new(Some(HeartbeatWait::new(fut, total_timeout_s)))),
-        })
-    }
-
-    /// Full submit->poll->fetch->reorder pipeline for one JSON_ARRAY
-    /// statement -- no Arrow parse at all. Returns a plain list of rows,
-    /// each row a list of values where every non-null value is a *string*
-    /// (Databricks' own JSON_ARRAY contract, not this crate's choice) --
-    /// cast by the manifest's column type_name yourself if you want native
-    /// Python types.
-    #[pyo3(signature = (statement, catalog=None, schema=None, parameters=None))]
-    fn execute_json<'py>(
-        &self,
-        py: Python<'py>,
-        statement: String,
-        catalog: Option<String>,
-        schema: Option<String>,
-        parameters: Option<Py<PyAny>>,
-    ) -> PyResult<Bound<'py, PyAny>> {
-        let client = self.inner.clone();
-        let parameters = parameters_to_value(py, parameters)?;
-        pyo3_async_runtimes::tokio::future_into_py(py, async move {
-            let result =
-                pipeline::run_json_pipeline(client, &statement, catalog.as_deref(), schema.as_deref(), parameters)
-                    .await
-                    .map_err(|e| PyRuntimeError::new_err(e.message))?;
-            Ok(result.rows)
-        })
-    }
-
     /// Uploads `data` to a Unity Catalog volume path via the Files API,
     /// overwriting anything already there.
     #[pyo3(signature = (volume_path, data))]
@@ -398,15 +333,16 @@ impl PyDbClient {
         })
     }
 
-    /// Chunk-at-a-time counterpart to `execute_arrow`, entirely backing
-    /// `stream_query_json`: yields `HEARTBEAT` while waiting on each
+    /// Chunk-at-a-time counterpart to `execute`+`fetchall_arrow`, entirely
+    /// backing `stream_query_json`: yields `HEARTBEAT` while waiting on each
     /// still-in-flight chunk (not just the initial statement wait), then a
     /// `list[str]` of NDJSON lines (one per row, arro3-`write_ndjson(
     /// explicit_nulls=True)`-compatible) per chunk as it arrives in logical
     /// order -- decode and JSON-encoding both happen here, so there's no
     /// further Python-side conversion step. Not async itself, same as
-    /// `execute_streamed` -- the returned iterator's `__anext__` does the
-    /// real work, including the initial submit/poll on its very first call.
+    /// `ResultSet.fetchall_arrow_streamed` -- the returned iterator's
+    /// `__anext__` does the real work, including the initial submit/poll on
+    /// its very first call.
     #[pyo3(signature = (statement, catalog=None, schema=None, parameters=None, total_timeout_s=None, non_finite_as_string=false))]
     #[allow(clippy::too_many_arguments)]
     fn stream_ndjson_lines(
@@ -525,49 +461,6 @@ impl PyResultSet {
     }
 }
 
-/// Async iterator returned by `Client.execute_streamed`: yields the
-/// `HEARTBEAT` singleton zero or more times, then a `ResultSet` exactly
-/// once, then stops.
-#[pyclass(name = "ExecuteStreamedIter")]
-struct PyExecuteStreamedIter {
-    wait: Arc<AsyncMutex<Option<HeartbeatWait<ResultStream>>>>,
-}
-
-#[pymethods]
-impl PyExecuteStreamedIter {
-    fn __aiter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
-        slf
-    }
-
-    fn __anext__<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
-        let wait = self.wait.clone();
-        pyo3_async_runtimes::tokio::future_into_py(py, async move {
-            let mut guard = wait.lock().await;
-            let Some(w) = guard.as_mut() else {
-                return Err(PyStopAsyncIteration::new_err(()));
-            };
-            match w.tick().await {
-                Ok(Some(Tick::Heartbeat)) => Python::attach(|py| heartbeat_singleton(py).map(|h| h.into_any())),
-                Ok(Some(Tick::Ready(stream))) => {
-                    *guard = None;
-                    let result_set = PyResultSet {
-                        statement_id: stream.statement_id.clone(),
-                        num_chunks: stream.num_chunks,
-                        columns: column_pairs(&stream.columns),
-                        inner: Arc::new(AsyncMutex::new(stream)),
-                    };
-                    Python::attach(|py| Py::new(py, result_set).map(|rs| rs.into_any()))
-                }
-                Ok(None) => Err(PyStopAsyncIteration::new_err(())),
-                Err(e) => {
-                    *guard = None;
-                    Err(PyRuntimeError::new_err(e.message))
-                }
-            }
-        })
-    }
-}
-
 /// Async iterator returned by `ResultSet.fetchall_arrow_streamed`: yields
 /// the `HEARTBEAT` singleton zero or more times, then a `Table` exactly
 /// once, then stops.
@@ -717,13 +610,11 @@ impl PyNdjsonStreamIter {
 /// "arrowbricks._core", manifest-path pointing back at this crate).
 #[pymodule]
 fn _core(m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(ping, m)?)?;
     m.add_function(wrap_pyfunction!(write_ipc_stream, m)?)?;
     m.add_function(wrap_pyfunction!(read_ipc_stream, m)?)?;
     m.add_class::<PyDbClient>()?;
     m.add_class::<PyResultSet>()?;
     m.add_class::<PyHeartbeat>()?;
-    m.add_class::<PyExecuteStreamedIter>()?;
     m.add_class::<PyFetchallArrowStreamedIter>()?;
     m.add_class::<PyNdjsonStreamIter>()?;
     m.add("HEARTBEAT", heartbeat_singleton(m.py())?)?;