Replace buffer management with Arrow buffers

tiledb/api/Cargo.toml

@@ -9,7 +9,7 @@ path = "src/lib.rs"
 
 [dependencies]
 anyhow = { workspace = true }
-arrow = { version = "52.0.0", features = ["prettyprint"], optional = true }
+arrow = { version = "52.0.0", features = ["prettyprint"] }
 itertools = "0"
 num-traits = { version = "0.2", optional = true }
 paste = "1.0"
@@ -35,5 +35,9 @@ tiledb-utils = { workspace = true }
 
 [features]
 default = []
-proptest-strategies = ["dep:num-traits", "dep:proptest", "dep:proptest-derive", "dep:tiledb-test-utils"]
-arrow = ["dep:arrow"]
+proptest-strategies = [
+    "dep:num-traits",
+    "dep:proptest",
+    "dep:proptest-derive",
+    "dep:tiledb-test-utils",
+]

tiledb/api/examples/multi_range_subarray_arrow.rs

@@ -0,0 +1,154 @@
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use arrow::array as aa;
+use itertools::izip;
+
+use tiledb::array::{
+    Array, ArrayType, AttributeData, CellOrder, DimensionData, DomainData,
+    SchemaData, TileOrder,
+};
+use tiledb::context::Context;
+use tiledb::error::Error as TileDBError;
+use tiledb::query_arrow::{QueryBuilder, QueryLayout, QueryStatus, QueryType};
+use tiledb::Result as TileDBResult;
+use tiledb::{Datatype, Factory};
+
+const ARRAY_URI: &str = "multi_range_slicing";
+
+/// This example creates a 4x4 dense array with the contents:
+///
+/// Col:     1   2   3   4
+/// Row: 1   1   2   3   4
+///      2   5   6   7   8
+///      3   9  10  11  12
+///      4  13  14  15  16
+///
+/// The query run restricts rows to [1, 2, 4] and returns all columns which
+/// should produce these rows:
+///
+/// Row Col Value
+/// 1   1   1
+/// 1   2   2
+/// 1   3   3
+/// 1   4   4
+/// 2   1   5
+/// 2   2   6
+/// 2   3   7
+/// 2   4   8
+/// 4   1   13
+/// 4   2   14
+/// 4   3   15
+/// 4   4   16
+fn main() -> TileDBResult<()> {
+    if let Ok(manifest_dir) = std::env::var("CARGO_MANIFEST_DIR") {
+        let _ = std::env::set_current_dir(
+            PathBuf::from(manifest_dir).join("examples").join("output"),
+        );
+    }
+
+    let ctx = Context::new()?;
+    if Array::exists(&ctx, ARRAY_URI)? {
+        Array::delete(&ctx, ARRAY_URI)?;
+    }
+
+    create_array(&ctx)?;
+    write_array(&ctx)?;
+
+    let array = Array::open(&ctx, ARRAY_URI, tiledb::array::Mode::Read)?;
+    let mut query = QueryBuilder::new(array, QueryType::Read)
+        .with_layout(QueryLayout::RowMajor)
+        .start_fields()
+        .field("rows")
+        .field("cols")
+        .field("a")
+        .end_fields()
+        .start_subarray()
+        .add_range("rows", &[1, 2])
+        .add_range("rows", &[4, 4])
+        .add_range("cols", &[1, 4])
+        .end_subarray()
+        .build()
+        .map_err(|e| TileDBError::Other(format!("{e}")))?;
+
+    let status = query
+        .submit()
+        .map_err(|e| TileDBError::Other(format!("{e}")))?;
+
+    if !matches!(status, QueryStatus::Completed) {
+        return Err(TileDBError::Other("Make this better.".to_string()));
+    }
+
+    let buffers = query
+        .buffers()
+        .map_err(|e| TileDBError::Other(format!("{e}")))?;
+
+    let rows = buffers.get::<aa::Int32Array>("rows").unwrap();
+    let cols = buffers.get::<aa::Int32Array>("cols").unwrap();
+    let attr = buffers.get::<aa::Int32Array>("a").unwrap();
+
+    for (r, c, a) in izip!(rows.values(), cols.values(), attr.values()) {
+        println!("{} {} {}", r, c, a);
+    }
+
+    Ok(())
+}
+
+fn create_array(ctx: &Context) -> TileDBResult<()> {
+    let schema = SchemaData {
+        array_type: ArrayType::Dense,
+        domain: DomainData {
+            dimension: vec![
+                DimensionData {
+                    name: "rows".to_owned(),
+                    datatype: Datatype::Int32,
+                    constraints: ([1i32, 4], 4i32).into(),
+                    filters: None,
+                },
+                DimensionData {
+                    name: "cols".to_owned(),
+                    datatype: Datatype::Int32,
+                    constraints: ([1i32, 4], 4i32).into(),
+                    filters: None,
+                },
+            ],
+        },
+        attributes: vec![AttributeData {
+            name: "a".to_owned(),
+            datatype: Datatype::Int32,
+            ..Default::default()
+        }],
+        tile_order: Some(TileOrder::RowMajor),
+        cell_order: Some(CellOrder::RowMajor),
+
+        ..Default::default()
+    };
+
+    let schema = schema.create(ctx)?;
+    Array::create(ctx, ARRAY_URI, schema)?;
+    Ok(())
+}
+
+fn write_array(ctx: &Context) -> TileDBResult<()> {
+    let data = Arc::new(aa::Int32Array::from(vec![
+        1i32, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+    ]));
+
+    let array =
+        tiledb::Array::open(ctx, ARRAY_URI, tiledb::array::Mode::Write)?;
+
+    let mut query = QueryBuilder::new(array, QueryType::Write)
+        .with_layout(QueryLayout::RowMajor)
+        .start_fields()
+        .field_with_buffer("a", data)
+        .end_fields()
+        .build()
+        .map_err(|e| TileDBError::Other(format!("{e}")))?;
+
+    let (_, _) = query
+        .submit()
+        .and_then(|_| query.finalize())
+        .map_err(|e| TileDBError::Other(format!("{e}")))?;
+
+    Ok(())
+}