Struct Map

pub struct Map { /* private fields */ }

Map is a collection of key-value pairs with a key type and a value type. It used in Literal::Map, to make it hashable, the order of key-value pairs is stored in a separate vector so that we can hash the map in a deterministic way. But it also means that the order of key-value pairs is matter for the hash value.

When converting to Arrow (e.g., for Iceberg), the map should be represented using the default field name “key_value”.

Example:

let key_value_field = Field::new(
    DEFAULT_MAP_FIELD_NAME,
    arrow_schema::DataType::Struct(vec![
        Arc::new(key_field.clone()),
        Arc::new(value_field.clone()),
    ].into()),
    false
);
'''

Implementations

impl Map

pub fn new() -> Self

Creates a new empty map.

pub fn len(&self) -> usize

Return the number of key-value pairs in the map.

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

pub fn insert( &mut self, key: Literal, value: Option<Literal>, ) -> Option<Option<Literal>>

Inserts a key-value pair into the map. If the map did not have this key present, None is returned. If the map did have this key present, the value is updated, and the old value is returned.

pub fn get(&self, key: &Literal) -> Option<&Option<Literal>>

Returns a reference to the value corresponding to the key. If the key is not present in the map, None is returned.

pub fn has_same_content(&self, other: &Map) -> bool

The order of map is matter, so this method used to compare two maps has same key-value pairs without considering the order.

Trait Implementations

impl Clone for Map

fn clone(&self) -> Map

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Map

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Map

fn default() -> Self

Returns the “default value” for a type.

impl<const N: usize> From<[(Literal, Option<Literal>); N]> for Map

fn from(value: [(Literal, Option<Literal>); N]) -> Self

Converts to this type from the input type.

impl FromIterator<(Literal, Option<Literal>)> for Map

fn from_iter<T: IntoIterator<Item = (Literal, Option<Literal>)>>( iter: T, ) -> Self

Creates a value from an iterator.

impl Hash for Map

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoIterator for Map

type Item = (Literal, Option<Literal>)

The type of the elements being iterated over.

type IntoIter = IntoIter<<Map as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for Map

fn eq(&self, other: &Map) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Map

impl StructuralPartialEq for Map