Type Alias arrow_array::builder::StringDictionaryBuilder

source ·

pub type StringDictionaryBuilder<K> = GenericByteDictionaryBuilder<K, GenericStringType<i32>>;

Expand description

Builder for DictionaryArray of StringArray

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


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

// The builder builds the dictionary value by value
builder.append("abc").unwrap();
builder.append_null();
builder.append("def").unwrap();
builder.append("def").unwrap();
builder.append("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: &StringArray = av.as_any().downcast_ref::<StringArray>().unwrap();

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

Aliased Type§

struct StringDictionaryBuilder<K> { /* private fields */ }

Implementations§

source §

impl<K, T> GenericByteDictionaryBuilder<K, T>where K: ArrowDictionaryKeyType, T: ByteArrayType,

source

pub fn new() -> Self

Creates a new GenericByteDictionaryBuilder

source

pub fn with_capacity( keys_capacity: usize, value_capacity: usize, data_capacity: usize ) -> Self

Creates a new GenericByteDictionaryBuilder with the provided capacities

keys_capacity: the number of keys, i.e. length of array to build value_capacity: the number of distinct dictionary values, i.e. size of dictionary data_capacity: the total number of bytes of all distinct bytes in the dictionary

source

pub fn new_with_dictionary( keys_capacity: usize, dictionary_values: &GenericByteArray<T> ) -> Result<Self, ArrowError>

Creates a new GenericByteDictionaryBuilder from a keys capacity and a dictionary which is initialized with the given values. The indices of those dictionary values are used as keys.

Example


let dictionary_values = StringArray::from(vec![None, Some("abc"), Some("def")]);

let mut builder = StringDictionaryBuilder::new_with_dictionary(3, &dictionary_values).unwrap();
builder.append("def").unwrap();
builder.append_null();
builder.append("abc").unwrap();

let dictionary_array = builder.finish();

let keys = dictionary_array.keys();

assert_eq!(keys, &Int16Array::from(vec![Some(2), None, Some(1)]));

source §

impl<K, T> GenericByteDictionaryBuilder<K, T>where K: ArrowDictionaryKeyType, T: ByteArrayType,

source

pub fn append( &mut self, value: impl AsRef<T::Native> ) -> Result<K::Native, ArrowError>

Append a value to the array. Return an existing index if already present in the values array or a new index if the value is appended to the values array.

Returns an error if the new index would overflow the key type.

source