Apache Arrow

https://docs.rs/arrow/latest/arrow/
Admin
Apache Arrow is a cross-language development platform providing a complete, safe, native Rust...
Tokens:865,292
Snippets:12,171
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Box::from_raw Examples

Source: https://docs.rs/arrow/latest/arrow/array/type.DynComparator.html

Examples demonstrating how to reconstruct a Box from a raw pointer or manually allocate memory for a Box.

```rust
let x = Box::new(5);
let ptr = Box::into_raw(x);
let x = unsafe { Box::from_raw(ptr) };
```

```rust
use std::alloc::{alloc, Layout};

unsafe {
    let ptr = alloc(Layout::new::<i32>()) as *mut i32;
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `ptr`, though for this
    // simple example `*ptr = 5` would have worked as well.
    ptr.write(5);
    let x = Box::from_raw(ptr);
}
```

--------------------------------

### Box::into_raw Examples

Source: https://docs.rs/arrow/latest/arrow/array/type.DynComparator.html

Examples demonstrating how to consume a Box into a raw pointer and perform cleanup.

```rust
let x = Box::new(String::from("Hello"));
let ptr = Box::into_raw(x);
let x = unsafe { Box::from_raw(ptr) };
```

```rust
use std::alloc::{dealloc, Layout};
use std::ptr;

let x = Box::new(String::from("Hello"));
let ptr = Box::into_raw(x);
unsafe {
    ptr::drop_in_place(ptr);
    dealloc(ptr as *mut u8, Layout::new::<String>());
}
```

```rust
let x = Box::new(String::from("Hello"));
let ptr = Box::into_raw(x);
unsafe {
    drop(Box::from_raw(ptr));
}
```

--------------------------------

### Box::from_non_null Examples

Source: https://docs.rs/arrow/latest/arrow/array/type.DynComparator.html

Examples demonstrating how to reconstruct a Box from a NonNull pointer or manually allocate memory for a Box using NonNull.

```rust
let x = Box::new(5);
let non_null = Box::into_non_null(x);
let x = unsafe { Box::from_non_null(non_null) };
```

```rust
use std::alloc::{alloc, Layout};
use std::ptr::NonNull;

unsafe {
    let non_null = NonNull::new(alloc(Layout::new::<i32>()).cast::<i32>())
        .expect("alloc should have successfully allocated memory");
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `non_null`.
    non_null.write(5);
    let x = Box::from_non_null(non_null);
}
```

--------------------------------

### Get First Element

Source: https://docs.rs/arrow/latest/arrow/array/builder/struct.OffsetBufferBuilder.html?search=std%3A%3Avec

Example usage of the first method on a slice.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&10), v.first());

let w: &[i32] = &[];
assert_eq!(None, w.first());
```

--------------------------------

### Using BinaryDictionaryBuilder

Source: https://docs.rs/arrow/latest/arrow/array/builder/type.BinaryDictionaryBuilder.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example demonstrating how to initialize a builder, append values, and finish the array.

```rust
// Create a dictionary array indexed by bytes whose values are binary.
// It can thus hold up to 256 distinct binary values.


let mut builder = BinaryDictionaryBuilder::<Int8Type>::new();

// The builder builds the dictionary value by value
builder.append(b"abc").unwrap();
builder.append_null();
builder.append(b"def").unwrap();
builder.append(b"def").unwrap();
builder.append(b"abc").unwrap();
let array = builder.finish();

assert_eq!(
  array.keys(),
  &Int8Array::from(vec![Some(0), None, Some(1), Some(1), Some(0)])
);

// Values are polymorphic and so require a downcast.
let av = array.values();
let ava: &BinaryArray = av.as_any().downcast_ref::<BinaryArray>().unwrap();

assert_eq!(ava.value(0), b"abc");
assert_eq!(ava.value(1), b"def");
```

--------------------------------

### Int64Array Construction

Source: https://docs.rs/arrow/latest/arrow/array/array/type.Int64Array.html?search=

Examples of how to construct an Int64Array from different data sources.

```APIDOC
## Construction

### Description
Create an Int64Array from a vector of optional i64 values, a vector of i64 values, or by collecting from an iterator.

### Examples
```rust
// Create from Vec<Option<i64>>
let arr = Int64Array::from(vec![Some(1), None, Some(2)]);

// Create from Vec<i64>
let arr = Int64Array::from(vec![1, 2, 3]);

// Create iter/collect
let arr: Int64Array = std::iter::repeat(42).take(10).collect();
```
```

--------------------------------

### UInt8Array Construction

Source: https://docs.rs/arrow/latest/arrow/array/type.UInt8Array.html

Examples of how to construct a UInt8Array from various data sources.

```APIDOC
## Construction

### Description
UInt8Array can be created from vectors of optional values, vectors of values, or by collecting from an iterator.

### Examples
```rust
// Create from Vec<Option<u8>>
let arr = UInt8Array::from(vec![Some(1), None, Some(2)]);

// Create from Vec<u8>
let arr = UInt8Array::from(vec![1, 2, 3]);

// Create iter/collect
let arr: UInt8Array = std::iter::repeat(42).take(10).collect();
```
```

--------------------------------

### Splitting off first element

Source: https://docs.rs/arrow/latest/arrow/buffer/struct.MutableBuffer.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples for split_off_first and split_off_first_mut.

```rust
let mut slice: &[_] = &['a', 'b', 'c'];
let first = slice.split_off_first().unwrap();

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'a');
```

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
let first = slice.split_off_first_mut().unwrap();
*first = 'd';

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'d');
```

--------------------------------

### UInt32Array Construction

Source: https://docs.rs/arrow/latest/arrow/array/array/type.UInt32Array.html

Examples of how to construct a UInt32Array from different data sources.

```APIDOC
## Construction

### Description
Create a new UInt32Array from various input types.

### Examples
```rust
// Create from Vec<Option<u32>>
let arr = UInt32Array::from(vec![Some(1), None, Some(2)]);

// Create from Vec<u32>
let arr = UInt32Array::from(vec![1, 2, 3]);

// Create iter/collect
let arr: UInt32Array = std::iter::repeat(42).take(10).collect();
```
```

--------------------------------

### Finish and Build BufferBuilder

Source: https://docs.rs/arrow/latest/arrow/array/builder/type.Date32BufferBuilder.html?search=

Examples demonstrating how to finalize a BufferBuilder by either resetting it or consuming it.

```rust
let mut builder = BufferBuilder::<u8>::new(10);
builder.append_slice(&[42, 44, 46]);
let buffer = builder.finish();
assert_eq!(unsafe { buffer.typed_data::<u8>() }, &[42, 44, 46]);
```

```rust
let mut builder = BufferBuilder::<u8>::new(10);
builder.append_slice(&[42, 44, 46]);
let buffer = builder.build();
assert_eq!(unsafe { buffer.typed_data::<u8>() }, &[42, 44, 46]);
```

--------------------------------

### Int32Array Construction

Source: https://docs.rs/arrow/latest/arrow/array/array/type.Int32Array.html

Examples of how to construct an Int32Array from different data sources.

```APIDOC
## Construction

### Description
Construct an Int32Array from a vector of optional integers, a vector of integers, or an iterator.

### Examples
```rust
// Create from Vec<Option<i32>>
let arr = Int32Array::from(vec![Some(1), None, Some(2)]);

// Create from Vec<i32>
let arr = Int32Array::from(vec![1, 2, 3]);

// Create iter/collect
let arr: Int32Array = std::iter::repeat(42).take(10).collect();
```
```

--------------------------------

### Int16Array Construction

Source: https://docs.rs/arrow/latest/arrow/array/array/type.Int16Array.html?search=u32+-%3E+bool

Examples of how to construct an Int16Array from different data sources.

```APIDOC
## Construction

### Description
Create an Int16Array from standard Rust collections.

### Examples
```rust
// Create from Vec<Option<i16>>
let arr = Int16Array::from(vec![Some(1), None, Some(2)]);

// Create from Vec<i16>
let arr = Int16Array::from(vec![1, 2, 3]);

// Create via iterator
let arr: Int16Array = std::iter::repeat(42).take(10).collect();
```
```

--------------------------------

### Constructing UInt64Array

Source: https://docs.rs/arrow/latest/arrow/array/array/type.UInt64Array.html?search=

Examples of creating a UInt64Array from vectors or iterators.

```rust
// Create from Vec<Option<u64>>
let arr = UInt64Array::from(vec![Some(1), None, Some(2)]);
// Create from Vec<u64>
let arr = UInt64Array::from(vec![1, 2, 3]);
// Create iter/collect
let arr: UInt64Array = std::iter::repeat(42).take(10).collect();
```

--------------------------------

### Float64Array Construction

Source: https://docs.rs/arrow/latest/arrow/array/array/type.Float64Array.html

Examples of how to construct a Float64Array from vectors or iterators.

```APIDOC
## Construction

### Description
Create a new Float64Array from standard Rust collections.

### Examples
```rust
// Create from Vec<Option<f64>>
let arr = Float64Array::from(vec![Some(1.0), None, Some(2.0)]);

// Create from Vec<f64>
let arr = Float64Array::from(vec![1.0, 2.0, 3.0]);

// Create via iterator
let arr: Float64Array = std::iter::repeat(42.0).take(10).collect();
```
```

--------------------------------

### Int8Array Construction

Source: https://docs.rs/arrow/latest/arrow/array/array/type.Int8Array.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples of how to construct an Int8Array from different data sources.

```APIDOC
## Construction

```rust
// Create from Vec<Option<i8>>
let arr = Int8Array::from(vec![Some(1), None, Some(2)]);

// Create from Vec<i8>
let arr = Int8Array::from(vec![1, 2, 3]);

// Create iter/collect
let arr: Int8Array = std::iter::repeat(42).take(10).collect();
```
```

--------------------------------

### Decimal64Array Construction

Source: https://docs.rs/arrow/latest/arrow/array/array/type.Decimal64Array.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples of how to construct a Decimal64Array from various input types.

```APIDOC
## Construction

### Description
Create a new Decimal64Array from standard Rust collections.

### Examples
```rust
// Create from Vec<Option<i64>>
let arr = Decimal64Array::from(vec![Some(1), None, Some(2)]);

// Create from Vec<i64>
let arr = Decimal64Array::from(vec![1, 2, 3]);

// Create via iterator
let arr: Decimal64Array = std::iter::repeat(42).take(10).collect();
```
```

--------------------------------

### UInt16Array Construction

Source: https://docs.rs/arrow/latest/arrow/array/array/type.UInt16Array.html?search=

Examples of how to construct a UInt16Array from various Rust collections.

```APIDOC
## Construction

### Description
Create a new UInt16Array from standard Rust collections.

### Examples
```rust
// Create from Vec<Option<u16>>
let arr = UInt16Array::from(vec![Some(1), None, Some(2)]);

// Create from Vec<u16>
let arr = UInt16Array::from(vec![1, 2, 3]);

// Create iter/collect
let arr: UInt16Array = std::iter::repeat(42).take(10).collect();
```
```

--------------------------------

### Constructing Float64Array

Source: https://docs.rs/arrow/latest/arrow/array/array/type.Float64Array.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples showing how to create a Float64Array from vectors or iterators.

```rust
// Create from Vec<Option<f32>>
let arr = Float64Array::from(vec![Some(1.0), None, Some(2.0)]);
// Create from Vec<f32>
let arr = Float64Array::from(vec![1.0, 2.0, 3.0]);
// Create iter/collect
let arr: Float64Array = std::iter::repeat(42.0).take(10).collect();
```

--------------------------------

### UInt8Array Construction

Source: https://docs.rs/arrow/latest/arrow/array/type.UInt8Array.html?search=std%3A%3Avec

Examples of how to construct a UInt8Array from various Rust data structures.

```APIDOC
## UInt8Array Construction

### Description
UInt8Array can be constructed from standard Rust collections such as Vec or via iterators.

### Examples
```rust
// Create from Vec<Option<u8>>
let arr = UInt8Array::from(vec![Some(1), None, Some(2)]);

// Create from Vec<u8>
let arr = UInt8Array::from(vec![1, 2, 3]);

// Create iter/collect
let arr: UInt8Array = std::iter::repeat(42).take(10).collect();
```
```

--------------------------------

### Constructing Fields

Source: https://docs.rs/arrow/latest/arrow/datatypes/struct.Fields.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples of creating a Fields instance from vectors or iterators of Field or FieldRef.

```rust
// Can be constructed from Vec<Field>
Fields::from(vec![Field::new("a", DataType::Boolean, false)]);
// Can be constructed from Vec<FieldRef>
Fields::from(vec![Arc::new(Field::new("a", DataType::Boolean, false))]);
// Can be constructed from an iterator of Field
std::iter::once(Field::new("a", DataType::Boolean, false)).collect::<Fields>();
// Can be constructed from an iterator of FieldRef
std::iter::once(Arc::new(Field::new("a", DataType::Boolean, false))).collect::<Fields>();
```

--------------------------------

### Create Primitive DataType

Source: https://docs.rs/arrow/latest/arrow/datatypes/enum.DataType.html

Example of instantiating a simple primitive data type.

```rust
// create a new 32-bit signed integer
let data_type = DataType::Int32;
```

--------------------------------

### BufferBuilder Advance and Reserve

Source: https://docs.rs/arrow/latest/arrow/array/struct.BufferBuilder.html?search=u32+-%3E+bool

Examples for manually advancing the buffer or reserving additional capacity.

```rust
let mut builder = BufferBuilder::<u8>::new(10);
builder.advance(2);

assert_eq!(builder.len(), 2);
```

```rust
let mut builder = BufferBuilder::<u8>::new(10);
builder.reserve(10);

assert!(builder.capacity() >= 20);
```

--------------------------------

### Get Last Chunk

Source: https://docs.rs/arrow/latest/arrow/array/builder/struct.OffsetBufferBuilder.html?search=std%3A%3Avec

Example usage of the last_chunk method on a slice.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[40, 30]), u.last_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.last_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.last_chunk::<0>());
```

--------------------------------

### Get First Chunk

Source: https://docs.rs/arrow/latest/arrow/array/builder/struct.OffsetBufferBuilder.html?search=std%3A%3Avec

Example usage of the first_chunk method on a slice.

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[10, 40]), u.first_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.first_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.first_chunk::<0>());
```

--------------------------------

### Initialize BufferBuilder with capacity

Source: https://docs.rs/arrow/latest/arrow/array/builder/struct.BufferBuilder.html?search=

Shows how to create a new builder and verify its initial capacity.

```rust
let mut builder = BufferBuilder::<u8>::new(10);

assert!(builder.capacity() >= 10);
```

--------------------------------

### Get Last Element

Source: https://docs.rs/arrow/latest/arrow/array/builder/struct.OffsetBufferBuilder.html?search=std%3A%3Avec

Example usage of the last method on a slice.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&30), v.last());

let w: &[i32] = &[];
assert_eq!(None, w.last());
```

--------------------------------

### Create and Populate a BinaryRunBuilder

Source: https://docs.rs/arrow/latest/arrow/array/builder/type.BinaryRunBuilder.html

Demonstrates initializing a builder, appending values and nulls, and accessing the resulting RunArray.

```rust
// Create a run-end encoded array with run-end indexes data type as `i16`.
// The encoded data is binary values.


let mut builder = BinaryRunBuilder::<Int16Type>::new();

// The builder builds the dictionary value by value
builder.append_value(b"abc");
builder.append_null();
builder.extend([Some(b"def"), Some(b"def"), Some(b"abc")]);
let array = builder.finish();

assert_eq!(array.run_ends().values(), &[1, 2, 4, 5]);

// Values are polymorphic and so require a downcast.
let av = array.values();
let ava: &BinaryArray = av.as_binary();

assert_eq!(ava.value(0), b"abc");
assert!(av.is_null(1));
assert_eq!(ava.value(2), b"def");
assert_eq!(ava.value(3), b"abc");
```

--------------------------------

### concat_elements_utf8_many Usage Example

Source: https://docs.rs/arrow/latest/arrow/compute/kernels/concat_elements/fn.concat_elements_utf8_many.html?search=

A conceptual example showing the elementwise concatenation of string arrays.

```text
e.g:
  ["a", "b"] + [None, "c"] + [None, "d"] = [None, "bcd"]
```

--------------------------------

### Build a RunArray with StringRunBuilder

Source: https://docs.rs/arrow/latest/arrow/array/builder/type.StringRunBuilder.html

Example demonstrating how to initialize a StringRunBuilder, append values and nulls, and finish the construction of a RunArray.

```rust
// Create a run-end encoded array with run-end indexes data type as `i16`.
// The encoded values are Strings.

let mut builder = StringRunBuilder::<Int16Type>::new();

// The builder builds the dictionary value by value
builder.append_value("abc");
builder.append_null();
builder.extend([Some("def"), Some("def"), Some("abc")]);
let array = builder.finish();

assert_eq!(array.run_ends().values(), &[1, 2, 4, 5]);

// Values are polymorphic and so require a downcast.
let av = array.values();
let ava: &StringArray = av.as_string::<i32>();

assert_eq!(ava.value(0), "abc");
assert!(av.is_null(1));
assert_eq!(ava.value(2), "def");
assert_eq!(ava.value(3), "abc");
```

--------------------------------

### Initialize SortOptions

Source: https://docs.rs/arrow/latest/arrow/compute/kernels/sort/struct.SortOptions.html

Demonstrates creating and configuring SortOptions using explicit initialization, builder APIs, and field setters.

```rust
// configure using explicit initialization
let options = SortOptions {
  descending: false,
  nulls_first: true,
};
// Default is ASC NULLs First
assert_eq!(options, SortOptions::default());
assert_eq!(options.to_string(), "ASC NULLS FIRST");

// Configure using builder APIs
let options = SortOptions::default()
 .desc()
 .nulls_first();
assert_eq!(options.to_string(), "DESC NULLS FIRST");

// configure using explicit field values
let options = SortOptions::default()
 .with_descending(false)
 .with_nulls_first(false);
assert_eq!(options.to_string(), "ASC NULLS LAST");
```

--------------------------------

### Mutable Chunking from Start

Source: https://docs.rs/arrow/latest/arrow/buffer/struct.MutableBuffer.html?search=

Splits a slice into N-element arrays starting from the beginning, returning the chunks and a remainder slice. Panics if N is zero.

```rust
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

let (chunks, remainder) = v.as_chunks_mut();
remainder[0] = 9;
for chunk in chunks {
    *chunk = [count; 2];
    count += 1;
}
assert_eq!(v, &[1, 1, 2, 2, 9]);
```

--------------------------------

### Create and finish a BufferBuilder

Source: https://docs.rs/arrow/latest/arrow/array/builder/struct.BufferBuilder.html?search=

Demonstrates initializing a builder, appending data, and finalizing it into a Buffer.

```rust
let mut builder = BufferBuilder::<u8>::new(100);
builder.append_slice(&[42, 43, 44]);
builder.append(45);
let buffer = builder.finish();
assert_eq!(unsafe { buffer.typed_data::<u8>() }, &[42, 43, 44, 45]);
```

--------------------------------

### as_array

Source: https://docs.rs/arrow/latest/arrow/array/builder/struct.OffsetBufferBuilder.html?search=std%3A%3Avec

Gets a reference to the underlying array.

```APIDOC
## pub fn as_array<const N: usize>(&self) -> Option<&[T; N]>

### Description
Gets a reference to the underlying array. If N is not exactly equal to the length of the slice, this method returns None.
```

--------------------------------

### substring(array: &dyn Array, start: i64, length: Option<u64>) -> Result<Arc<dyn Array>, ArrowError>

Source: https://docs.rs/arrow/latest/arrow/compute/kernels/substring/fn.substring.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns an ArrayRef containing substrings of all elements in the provided array. Note that start and length are measured in bytes, not characters.

```APIDOC
## Function: substring

### Description
Returns an `ArrayRef` with substrings of all the elements in the input `array`. The function operates on byte offsets rather than character counts.

### Signature
`pub fn substring(array: &dyn Array, start: i64, length: Option<u64>) -> Result<Arc<dyn Array>, ArrowError>`

### Parameters
- **array** (&dyn Array) - The input array containing string or binary data.
- **start** (i64) - The start index of the substrings. Positive values count from the start, negative values count from the end.
- **length** (Option<u64>) - The length of the substrings in bytes. If None, the substring extends to the end of the string.

### Errors
- Returns an error if the array type is not supported (e.g., not a String, Binary, or Dictionary array).
- Returns an error if the resulting substring offset falls on an invalid UTF-8 character boundary for string arrays.
```

--------------------------------

### Constructing and Populating a FixedSizeBinaryArray

Source: https://docs.rs/arrow/latest/arrow/array/builder/struct.FixedSizeBinaryBuilder.html

Example demonstrating how to initialize a builder, append values and nulls, and finalize the array.

```rust
let mut builder = FixedSizeBinaryBuilder::with_capacity(3, 5);
// [b"hello", null, b"arrow"]
builder.append_value(b"hello").unwrap();
builder.append_null();
builder.append_value(b"arrow").unwrap();

let array = builder.finish();
assert_eq!(array.value(0), b"hello");
assert!(array.is_null(1));
assert_eq!(array.value(2), b"arrow");
```

--------------------------------

### Splitting off last element

Source: https://docs.rs/arrow/latest/arrow/buffer/struct.MutableBuffer.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples for split_off_last and split_off_last_mut.

```rust
let mut slice: &[_] = &['a', 'b', 'c'];
let last = slice.split_off_last().unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(last, &'c');
```

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
let last = slice.split_off_last_mut().unwrap();
*last = 'd';
```

--------------------------------

### Constructing a BinaryViewArray

Source: https://docs.rs/arrow/latest/arrow/array/builder/type.BinaryViewBuilder.html

Demonstrates the basic workflow of initializing a builder, appending values and nulls, and finalizing the array.

```rust
use arrow_array::BinaryViewArray;
let mut builder = BinaryViewBuilder::new();
builder.append_value("hello");
builder.append_null();
builder.append_value("world");
let array = builder.finish();

let expected: Vec<Option<&[u8]>> = vec![Some(b"hello"), None, Some(b"world")];
let actual: Vec<_> = array.iter().collect();
assert_eq!(expected, actual);
```

--------------------------------

### Create Schema Instances

Source: https://docs.rs/arrow/latest/arrow/datatypes/struct.Schema.html?search=u32+-%3E+bool

Methods for initializing a new Schema with or without metadata.

```rust
let field_a = Field::new("a", DataType::Int64, false);
let field_b = Field::new("b", DataType::Boolean, false);

let schema = Schema::new(vec![field_a, field_b]);
```

```rust

let field_a = Field::new("a", DataType::Int64, false);
let field_b = Field::new("b", DataType::Boolean, false);

let mut metadata: HashMap<String, String> = HashMap::new();
metadata.insert("row_count".to_string(), "100".to_string());

let schema = Schema::new_with_metadata(vec![field_a, field_b], metadata);
```

--------------------------------

### Collect into UInt8DictionaryArray

Source: https://docs.rs/arrow/latest/arrow/array/array/type.UInt8DictionaryArray.html?search=

Example of creating a UInt8DictionaryArray from an iterator.

```rust
let array: UInt8DictionaryArray = vec!["a", "a", "b", "c"].into_iter().collect();
let values: Arc<dyn Array> = Arc::new(StringArray::from(vec!["a", "b", "c"]));
assert_eq!(array.keys(), &UInt8Array::from(vec![0, 0, 1, 2]));
assert_eq!(array.values(), &values);
```

--------------------------------

### columns

Source: https://docs.rs/arrow/latest/arrow/array/struct.RecordBatch.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Get a reference to all columns in the record batch.

```APIDOC
## pub fn columns(&self) -> &[Arc<dyn Array>]

### Description
Get a reference to all columns in the record batch.
```

--------------------------------

### Constructing an inline 128-bit key

Source: https://docs.rs/arrow/latest/arrow/array/array/struct.GenericByteViewArray.html?search=

Example demonstrating how the inline key construction differentiates between strings of different lengths that share the same content prefix.

```text
key("bar")   = 0x0000000000000000000062617200000003
key("bar\0") = 0x0000000000000000000062617200000004
⇒ key("bar") < key("bar\0")
```

--------------------------------

### Decimal128Array Construction

Source: https://docs.rs/arrow/latest/arrow/array/type.Decimal128Array.html?search=std%3A%3Avec

Examples of how to construct a Decimal128Array from vectors or iterators.

```APIDOC
## Construction

### Description
Create a new Decimal128Array from standard Rust collections.

### Examples
```rust
// Create from Vec<Option<i128>>
let arr = Decimal128Array::from(vec![Some(1), None, Some(2)]);

// Create from Vec<i128>
let arr = Decimal128Array::from(vec![1, 2, 3]);

// Create iter/collect
let arr: Decimal128Array = std::iter::repeat(42).take(10).collect();
```
```

--------------------------------

### Format RecordBatches with custom options

Source: https://docs.rs/arrow/latest/arrow/util/pretty/fn.pretty_format_batches_with_options.html

Demonstrates how to configure display options using FormatOptions and format the output as a string.

```rust
let options = FormatOptions::new()
  .with_null("<NULL>");
// Note, returned object implements `Display`
let pretty_table = pretty_format_batches_with_options(&[batch], &options).unwrap();
let table_str = format!("Batches:\n{pretty_table}");
assert_eq!(table_str,
r#"Batches:
+---+--------+
| a | b      |
+---+--------+
| 1 | a      |
| 2 | <NULL> |
+---+--------+"#);
```

--------------------------------

### Constructing a MapArray with MapBuilder

Source: https://docs.rs/arrow/latest/arrow/array/builder/struct.MapBuilder.html?search=

Example demonstrating how to initialize a MapBuilder, append key-value pairs, and finalize the array.

```rust
let string_builder = StringBuilder::new();
let int_builder = Int32Builder::with_capacity(4);

// Construct `[{"joe": 1}, {"blogs": 2, "foo": 4}, {}, null]`
let mut builder = MapBuilder::new(None, string_builder, int_builder);

builder.keys().append_value("joe");
builder.values().append_value(1);
builder.append(true).unwrap();

builder.keys().append_value("blogs");
builder.values().append_value(2);
builder.keys().append_value("foo");
builder.values().append_value(4);
builder.append(true).unwrap();
builder.append(true).unwrap();
builder.append(false).unwrap();

let array = builder.finish();
assert_eq!(array.value_offsets(), &[0, 1, 3, 3, 3]);
assert_eq!(array.values().as_ref(), &Int32Array::from(vec![1, 2, 4]));
assert_eq!(array.keys().as_ref(), &StringArray::from(vec!["joe", "blogs", "foo"]));
```

--------------------------------

### Int8Array Construction

Source: https://docs.rs/arrow/latest/arrow/array/array/type.Int8Array.html?search=

Examples of how to construct an Int8Array from vectors or iterators.

```APIDOC
## Construction

### Create from Vec<Option<i8>>
let arr = Int8Array::from(vec![Some(1), None, Some(2)]);

### Create from Vec<i8>
let arr = Int8Array::from(vec![1, 2, 3]);

### Create via iterator
let arr: Int8Array = std::iter::repeat(42).take(10).collect();
```

--------------------------------

### Collect into Int8DictionaryArray

Source: https://docs.rs/arrow/latest/arrow/array/array/type.Int8DictionaryArray.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example demonstrating how to collect an iterator into an Int8DictionaryArray.

```rust
let array: Int8DictionaryArray = vec!["a", "a", "b", "c"].into_iter().collect();
let values: Arc<dyn Array> = Arc::new(StringArray::from(vec!["a", "b", "c"]));
assert_eq!(array.keys(), &Int8Array::from(vec![0, 0, 1, 2]));
assert_eq!(array.values(), &values);
```

--------------------------------

### Construct Int64Array

Source: https://docs.rs/arrow/latest/arrow/array/array/type.Int64Array.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples of creating an Int64Array from vectors or iterators.

```rust
// Create from Vec<Option<i64>>
let arr = Int64Array::from(vec![Some(1), None, Some(2)]);
// Create from Vec<i64>
let arr = Int64Array::from(vec![1, 2, 3]);
// Create iter/collect
let arr: Int64Array = std::iter::repeat(42).take(10).collect();
```

--------------------------------

### Building a DictionaryArray

Source: https://docs.rs/arrow/latest/arrow/array/builder/struct.PrimitiveDictionaryBuilder.html?search=u32+-%3E+bool

Example demonstrating how to append values, handle nulls, and access the resulting dictionary array and its values.

```rust

let mut builder = PrimitiveDictionaryBuilder::<UInt8Type, UInt32Type>::new();
 builder.append(12345678).unwrap();
 builder.append_null();
 builder.append(22345678).unwrap();
 let array = builder.finish();

 assert_eq!(
     array.keys(),
     &UInt8Array::from(vec![Some(0), None, Some(1)])
 );

 // Values are polymorphic and so require a downcast.
 let av = array.values();
 let ava: &UInt32Array = av.as_any().downcast_ref::<UInt32Array>().unwrap();
 let avs: &[u32] = ava.values();

 assert!(!array.is_null(0));
 assert!(array.is_null(1));
 assert!(!array.is_null(2));

 assert_eq!(avs, &[12345678, 22345678]);
```

--------------------------------

### Int32Array Construction

Source: https://docs.rs/arrow/latest/arrow/array/array/type.Int32Array.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples of how to construct an Int32Array from vectors or iterators.

```APIDOC
## Construction

### Description
Create an Int32Array from standard Rust collections.

### Examples
```rust
// Create from Vec<Option<i32>>
let arr = Int32Array::from(vec![Some(1), None, Some(2)]);

// Create from Vec<i32>
let arr = Int32Array::from(vec![1, 2, 3]);

// Create iter/collect
let arr: Int32Array = std::iter::repeat(42).take(10).collect();
```
```

--------------------------------

### Create and use a RecordBatchIterator

Source: https://docs.rs/arrow/latest/arrow/array/struct.RecordBatchIterator.html

Demonstrates initializing a RecordBatchIterator from a vector of RecordBatch objects and verifying the schema and content.

```rust
let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2]));
let b: ArrayRef = Arc::new(StringArray::from(vec!["a", "b"]));

let record_batch = RecordBatch::try_from_iter(vec![
  ("a", a),
  ("b", b),
]).unwrap();

let batches: Vec<RecordBatch> = vec![record_batch.clone(), record_batch.clone()];

let mut reader = RecordBatchIterator::new(batches.into_iter().map(Ok), record_batch.schema());

assert_eq!(reader.schema(), record_batch.schema());
assert_eq!(reader.next().unwrap().unwrap(), record_batch);
```

--------------------------------

### Constructing Float32Array

Source: https://docs.rs/arrow/latest/arrow/array/array/type.Float32Array.html?search=

Examples of creating a Float32Array from vectors or iterators.

```rust
// Create from Vec<Option<f32>>
let arr = Float32Array::from(vec![Some(1.0), None, Some(2.0)]);
// Create from Vec<f32>
let arr = Float32Array::from(vec![1.0, 2.0, 3.0]);
// Create iter/collect
let arr: Float32Array = std::iter::repeat(42.0).take(10).collect();
```

--------------------------------

### Implementing a Custom Formatter Factory

Source: https://docs.rs/arrow/latest/arrow/util/display/trait.ArrayFormatterFactory.html

Demonstrates creating a custom formatter for a 'my_money' extension type. Requires the 'prettyprint' feature.

```rust
use std::fmt::Write;
use arrow_array::{cast::AsArray, Array, Int32Array};
use arrow_cast::display::{ArrayFormatter, ArrayFormatterFactory, DisplayIndex, FormatOptions, FormatResult};
use arrow_cast::pretty::pretty_format_batches_with_options;
use arrow_schema::{ArrowError, Field};

/// A custom formatter factory that can create a formatter for the special type `my_money`.
///
/// This struct could have access to some kind of extension type registry that can lookup the
/// correct formatter for an extension type on-demand.
#[derive(Debug)]
struct MyFormatters {}

impl ArrayFormatterFactory for MyFormatters {
    fn create_array_formatter<'formatter>(
        &self,
        array: &'formatter dyn Array,
        options: &FormatOptions<'formatter>,
        field: Option<&'formatter Field>,
    ) -> Result<Option<ArrayFormatter<'formatter>>, ArrowError> {
        // check if this is the money type
        if field
            .map(|f| f.extension_type_name() == Some("my_money"))
            .unwrap_or(false)
        {
            // We assume that my_money always is an Int32.
            let array = array.as_primitive();
            let display_index = Box::new(MyMoneyFormatter { array, options: options.clone() });
            return Ok(Some(ArrayFormatter::new(display_index, options.safe())));
        }

        Ok(None) // None indicates that the default formatter should be used.
    }
}

/// A formatter for the type `my_money` that wraps a specific array and has access to the
/// formatting options.
struct MyMoneyFormatter<'a> {
    array: &'a Int32Array,
    options: FormatOptions<'a>,
}

impl<'a> DisplayIndex for MyMoneyFormatter<'a> {
    fn write(&self, idx: usize, f: &mut dyn Write) -> FormatResult {
        match self.array.is_valid(idx) {
            true => write!(f, "{} €", self.array.value(idx))?,
            false => write!(f, "{}", self.options.null())?,
        }

        Ok(())
    }
}

// Usually, here you would provide your record batches.
let my_batches = vec![];

// Call the pretty printer with the custom formatter factory.
pretty_format_batches_with_options(
       &my_batches,
       &FormatOptions::new().with_formatter_factory(Some(&MyFormatters {}))
);
```

--------------------------------

### Decimal256Array Construction

Source: https://docs.rs/arrow/latest/arrow/array/array/type.Decimal256Array.html?search=std%3A%3Avec

Examples of how to construct a Decimal256Array from vectors or iterators.

```APIDOC
## Construction

```rust
use arrow_buffer::i256;
// Create from Vec<Option<i256>>
let arr = Decimal256Array::from(vec![Some(i256::from(1)), None, Some(i256::from(2))]);
// Create from Vec<i256>
let arr = Decimal256Array::from(vec![i256::from(1), i256::from(2), i256::from(3)]);
// Create iter/collect
let arr: Decimal256Array = std::iter::repeat(i256::from(42)).take(10).collect();
```
```

--------------------------------

### as_array

Source: https://docs.rs/arrow/latest/arrow/buffer/struct.MutableBuffer.html?search=

Gets a reference to the underlying array if the length matches.

```APIDOC
## pub fn as_array<const N: usize>(&self) -> Option<&[T; N]>

### Description
Gets a reference to the underlying array. Returns None if N is not equal to the length of the slice.

### Parameters
- **N** (usize) - The expected length of the array.

### Returns
- **Option<&[T; N]>** - The array reference if the length matches, otherwise None.
```

--------------------------------

### Partitioning columns in Rust

Source: https://docs.rs/arrow/latest/arrow/compute/fn.partition.html

Demonstrates partitioning a RecordBatch based on the first two columns to identify ranges of equal values.

```rust
let batch = RecordBatch::try_from_iter(vec![
    ("x", Arc::new(Int64Array::from(vec![1, 1, 1, 1, 2, 3])) as ArrayRef),
    ("y", Arc::new(Int64Array::from(vec![1, 2, 2, 2, 1, 1])) as ArrayRef),
    ("z", Arc::new(StringArray::from(vec!["A", "B", "C", "D", "E", "F"])) as ArrayRef),
]).unwrap();

// Partition on first two columns
let ranges = partition(&batch.columns()[..2]).unwrap().ranges();

let expected = vec![
    (0..1),
    (1..4),
    (4..5),
    (5..6),
];

assert_eq!(ranges, expected);
```

--------------------------------

### Timestamp Parsing Examples

Source: https://docs.rs/arrow/latest/arrow/compute/kernels/cast_utils/fn.string_to_timestamp_nanos.html

Demonstrates how different string formats are parsed into the same nanosecond timestamp value.

```rust
// Note all three of these timestamps are parsed as the same value
let a = string_to_timestamp_nanos("1997-01-31 09:26:56.123Z").unwrap();
let b = string_to_timestamp_nanos("1997-01-31T09:26:56.123").unwrap();
let c = string_to_timestamp_nanos("1997-01-31T14:26:56.123+05:00").unwrap();

assert_eq!(a, b);
assert_eq!(b, c);
```

--------------------------------

### Arc::weak_count

Source: https://docs.rs/arrow/latest/arrow/array/array/type.ArrayRef.html

Gets the number of Weak pointers to the allocation.

```APIDOC
## pub fn weak_count(this: &Arc<T, A>) -> usize

### Description
Gets the number of `Weak` pointers to this allocation.

### Parameters
- **this** (&Arc<T, A>) - Required - A reference to the Arc pointer.
```

--------------------------------

### Construct and populate a FixedSizeListBuilder

Source: https://docs.rs/arrow/latest/arrow/array/builder/struct.FixedSizeListBuilder.html?search=

Demonstrates initializing a builder with an Int32Builder and appending values to create a FixedSizeListArray.

```rust
use arrow_array::{builder::{Int32Builder, FixedSizeListBuilder}, Array, Int32Array};
let values_builder = Int32Builder::new();
let mut builder = FixedSizeListBuilder::new(values_builder, 3);

//  [[0, 1, 2], null, [3, null, 5], [6, 7, null]]
builder.values().append_value(0);
builder.values().append_value(1);
builder.values().append_value(2);
builder.append(true);
builder.values().append_null();
builder.values().append_null();
builder.values().append_null();
builder.append(false);
builder.values().append_value(3);
builder.values().append_null();
builder.values().append_value(5);
builder.append(true);
builder.values().append_value(6);
builder.values().append_value(7);
builder.values().append_null();
builder.append(true);
let list_array = builder.finish();
assert_eq!(
    *list_array.value(0),
    Int32Array::from(vec![Some(0), Some(1), Some(2)])
);
assert!(list_array.is_null(1));
assert_eq!(
    *list_array.value(2),
    Int32Array::from(vec![Some(3), None, Some(5)])
);
assert_eq!(
    *list_array.value(3),
    Int32Array::from(vec![Some(6), Some(7), None])
)
```

--------------------------------

### Decimal32Array Construction

Source: https://docs.rs/arrow/latest/arrow/array/type.Decimal32Array.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples of how to construct a Decimal32Array from various data sources.

```APIDOC
## Construction

```rust
// Create from Vec<Option<i32>>
let arr = Decimal32Array::from(vec![Some(1), None, Some(2)]);

// Create from Vec<i32>
let arr = Decimal32Array::from(vec![1, 2, 3]);

// Create iter/collect
let arr: Decimal32Array = std::iter::repeat(42).take(10).collect();
```
```

--------------------------------

### Build a FixedSizeBinaryDictionaryArray in Rust

Source: https://docs.rs/arrow/latest/arrow/array/builder/struct.FixedSizeBinaryDictionaryBuilder.html

Demonstrates initializing the builder, appending values including duplicates and nulls, and verifying the resulting dictionary array structure.

```rust
// Build 3 byte FixedBinaryArrays
let byte_width = 3;
let mut builder = FixedSizeBinaryDictionaryBuilder::<Int8Type>::new(3);
builder.append("abc").unwrap();
builder.append_null();
builder.append(b"def").unwrap();
builder.append(b"def").unwrap(); // duplicate value
// Result is a Dictionary Array
let array = builder.finish();
let dict_array = array.as_any().downcast_ref::<DictionaryArray<Int8Type>>().unwrap();
// The array represents "abc", null, "def", "def"
assert_eq!(array.keys().len(), 4);
// but there are only 2 unique values
assert_eq!(array.values().len(), 2);
let values = dict_array.values().as_any().downcast_ref::<FixedSizeBinaryArray>().unwrap();
assert_eq!(values.value(0), "abc".as_bytes());
assert_eq!(values.value(1), "def".as_bytes());
```

--------------------------------

### Exporting an Array

Source: https://docs.rs/arrow/latest/arrow/array/ffi/struct.FFI_ArrowArray.html?search=std%3A%3Avec

Example of creating an FFI_ArrowArray from an existing ArrayData instance.

```rust
fn export_array(array: &ArrayData) -> FFI_ArrowArray {
    FFI_ArrowArray::new(array)
}
```

--------------------------------

### Basic usage of GenericBinaryBuilder

Source: https://docs.rs/arrow/latest/arrow/array/builder/type.GenericBinaryBuilder.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates creating a builder, appending values, and finishing the array.

```rust
let mut builder = GenericBinaryBuilder::<i32>::new();

// Write data
builder.append_value("foo");

// Write second value
builder.append_value(&[0,1,2]);

let array = builder.finish();
// binary values
assert_eq!(array.value(0), b"foo");
assert_eq!(array.value(1), b"\x00\x01\x02");
```
Tokens:
Raw