1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

//! Pass arrow-rs objects to and from an R session
//!
//! ## Motivating Example
//!
//! Say we have the following `DBI` connection which we will send requests to using arrow.
//! The result of `dbGetQueryArrow()` is a `nanoarrow_array_stream`. We want to
//! count the number of rows in each batch of the steam using Rust.
//!
//! ```r
//! # adapted from https://github.com/r-dbi/DBI/blob/main/vignettes/DBI-arrow.Rmd
//!
//! library(DBI)
//! con <- dbConnect(RSQLite::SQLite())
//! data <- data.frame(
//!   a = runif(10000, 0, 10),
//!   b = rnorm(10000, 4.5),
//!   c = sample(letters, 10000, TRUE)
//! )
//!
//! dbWriteTable(con, "tbl", data)
//! ```
//!
//! We can write an extendr function which creates an `ArrowArrayStreamReader`
//! from an `&Robj`. In the function we instantiate a counter to keep track
//! of the number of rows per chunk. For each chunk we print the number of rows.
//!
//! ```ignore
//! #[extendr]
//! /// @export
//! fn process_stream(stream: Robj) -> i32 {
//!     let rb = ArrowArrayStreamReader::from_arrow_robj(&stream)
//!         .unwrap();
//!
//!     let mut n = 0;
//!
//!     rprintln!("Processing `ArrowArrayStreamReader`...");
//!     for chunk in rb {
//!         let chunk_rows = chunk.unwrap().num_rows();
//!         rprintln!("Found {chunk_rows} rows");
//!         n += chunk_rows as i32;
//!     }
//!
//!     n
//! }
//! ```
//!
//! With this function we can use it on the output of `dbGetQueryArrow()` or other Arrow
//! related DBI functions.
//!
//! ```r
//! query <- dbGetQueryArrow(con, "SELECT * FROM tbl WHERE a < 3")
//! process_stream(query)
//! #> Processing `ArrowArrayStreamReader`...
//! #> Found 256 rows
//! #> Found 256 rows
//! #> Found 256 rows
//! #> ... truncated ...
//! #> Found 256 rows
//! #> Found 256 rows
//! #> Found 143 rows
//! #> [1] 2959
//! ```
pub mod from;
pub mod to;