Struct PartiqlMetadata 

pub struct PartiqlMetadata<T>
where
    T: Eq + Clone + Hash + Borrow<str>,
{ /* private fields */ }

Provides a mean to store meta-data for PartiQL objects.

Examples

use partiql_common::metadata::{PartiqlMetadata, PartiqlMetaValue};

let foo_val = PartiqlMetaValue::String("foo".to_string());
let i64_val = PartiqlMetaValue::Int64(2);///
let expected_vec_val = vec![foo_val, i64_val];

let expected_bool_val = true;///
let expected_int_val = 2;///
let expected_float_val = 2.5;///
let expected_str_val = "foo";///

let mut expected_map = PartiqlMetadata::new();///
expected_map.insert("bool value", expected_bool_val.into());///
expected_map.insert("integer value", expected_int_val.into());///

let mut metas = PartiqlMetadata::new();///
metas.insert("vec value", expected_vec_val.clone().into());
metas.insert("bool value", expected_bool_val.into());///
metas.insert("integer value", expected_int_val.into());///
metas.insert("float value", expected_float_val.into());///
metas.insert("string value", expected_str_val.into());///
metas.insert("map value", expected_map.clone().into());///

let vec_val = metas.vec_value("vec value").expect("vec meta value");///
let bool_val = metas.bool_value("bool value").expect("bool meta value");///
let int_val = metas.i32_value("integer value").expect("i32 meta value");///
let float_val = metas.f64_value("float value").expect("f64 meta value");///
let string_val = metas.string_value("string value").expect("string meta value");///
let map_val = metas.map_value("map value").expect("map meta value");///

assert_eq!(vec_val, expected_vec_val.clone());///
assert_eq!(bool_val, expected_bool_val.clone());///
assert_eq!(int_val, expected_int_val.clone());///
assert_eq!(float_val, expected_float_val.clone());///
assert_eq!(string_val, expected_str_val);///
assert_eq!(map_val, expected_map.clone());

Implementations

impl<T> PartiqlMetadata<T>

where T: Eq + Clone + Hash + Borrow<str>,

pub fn new() -> Self

pub fn insert(&mut self, key: T, value: PartiqlMetaValue<T>)

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

pub fn get_mut(&mut self, key: &T) -> Option<&mut PartiqlMetaValue<T>>

pub fn contains_key(&self, key: &T) -> bool

pub fn keys(&self) -> impl Iterator<Item = &T>

pub fn values(&self) -> impl Iterator<Item = &PartiqlMetaValue<T>>

pub fn values_mut(&mut self) -> impl Iterator<Item = &mut PartiqlMetaValue<T>>

pub fn entry(&mut self, key: T) -> Entry<'_, T, PartiqlMetaValue<T>>

pub fn clear(&mut self)

pub fn remove(&mut self, key: &T) -> Option<PartiqlMetaValue<T>>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn iter(&self) -> impl Iterator<Item = (&T, &PartiqlMetaValue<T>)>

pub fn iter_mut( &mut self, ) -> impl Iterator<Item = (&T, &mut PartiqlMetaValue<T>)>

pub fn vec_value(&self, key: &str) -> Option<Vec<PartiqlMetaValue<T>>>

pub fn bool_value(&self, key: &str) -> Option<bool>

pub fn f32_value(&self, key: &str) -> Option<f32>

pub fn f64_value(&self, key: &str) -> Option<f64>

pub fn decimal_value(&self, key: &str) -> Option<Decimal>

pub fn i32_value(&self, key: &str) -> Option<i32>

pub fn i64_value(&self, key: &str) -> Option<i64>

pub fn map_value(&self, key: &str) -> Option<PartiqlMetadata<T>>

pub fn string_value(&self, key: &str) -> Option<String>

Trait Implementations

impl<T> Clone for PartiqlMetadata<T>

where T: Eq + Clone + Hash + Borrow<str> + Clone,

fn clone(&self) -> PartiqlMetadata<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for PartiqlMetadata<T>

where T: Eq + Clone + Hash + Borrow<str> + Debug,

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

Formats the value using the given formatter.

impl<T> Default for PartiqlMetadata<T>

where T: Eq + Clone + Hash + Borrow<str>,

fn default() -> Self

Returns the “default value” for a type.

impl<T> From<PartiqlMetadata<T>> for PartiqlMetaValue<T>

where T: Eq + Clone + Hash + Borrow<str>,

fn from(value: PartiqlMetadata<T>) -> Self

Converts to this type from the input type.

impl<T> FromIterator<(T, PartiqlMetaValue<T>)> for PartiqlMetadata<T>

where T: Eq + Clone + Hash + Borrow<str>,

fn from_iter<I: IntoIterator<Item = (T, PartiqlMetaValue<T>)>>(iter: I) -> Self

Creates a value from an iterator.

impl<T> IntoIterator for PartiqlMetadata<T>

where T: Eq + Clone + Hash + Borrow<str>,

type Item = (T, PartiqlMetaValue<T>)

The type of the elements being iterated over.

type IntoIter = IntoIter<T, PartiqlMetaValue<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> PartialEq for PartiqlMetadata<T>

where T: Eq + Clone + Hash + Borrow<str> + PartialEq,

fn eq(&self, other: &PartiqlMetadata<T>) -> 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<T> StructuralPartialEq for PartiqlMetadata<T>

where T: Eq + Clone + Hash + Borrow<str>,