partiql-value 0.14.0

PartiQL Values
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use dyn_clone::DynClone;
use dyn_hash::DynHash;
use partiql_common::pretty::PrettyDoc;
use std::any::Any;
use std::borrow::Cow;
use std::cmp::Ordering;
use std::error::Error;

use crate::datum::{Datum, DatumCategoryOwned, DatumCategoryRef, DatumLower};
use crate::Value;
use pretty::{DocAllocator, DocBuilder};
use std::fmt::{Debug, Display};

pub type BoxedVariantError = Box<dyn Error>;

pub type BoxedVariantResult<T> = Result<T, BoxedVariantError>;
pub type BoxedVariantValueIntoIterator =
    Box<dyn Iterator<Item = BoxedVariantResult<DynBoxedVariant>>>;

pub type BoxedVariantValueIter<'a> =
    Box<dyn 'a + Iterator<Item = BoxedVariantResult<&'a DynBoxedVariant>>>;

pub trait DynBoxedVariantTypeFactory {
    fn to_dyn_type_tag(self) -> BoxedVariantTypeTag;
}

pub type BoxedVariantTypeTag = Box<dyn BoxedVariantType>;
pub trait BoxedVariantType: Debug + DynClone {
    fn construct(&self, bytes: Vec<u8>) -> BoxedVariantResult<DynBoxedVariant>;
    fn name(&self) -> &'static str;

    fn value_eq(&self, l: &DynBoxedVariant, r: &DynBoxedVariant) -> bool;

    fn value_eq_param(
        &self,
        l: &DynBoxedVariant,
        r: &DynBoxedVariant,
        nulls_eq: bool,
        nans_eq: bool,
    ) -> bool;
}

dyn_clone::clone_trait_object!(BoxedVariantType);

impl Eq for dyn BoxedVariantType {}
impl PartialEq for dyn BoxedVariantType {
    fn eq(&self, other: &Self) -> bool {
        self.name() == other.name()
    }
}
impl PartialOrd for dyn BoxedVariantType {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}
impl Ord for dyn BoxedVariantType {
    fn cmp(&self, other: &Self) -> Ordering {
        self.name().cmp(other.name())
    }
}

impl<T> DynBoxedVariantTypeFactory for T
where
    T: BoxedVariantType + 'static,
{
    fn to_dyn_type_tag(self) -> BoxedVariantTypeTag {
        Box::new(self)
    }
}

pub type DynBoxedVariant = Box<dyn BoxedVariant>;
#[cfg_attr(feature = "serde", typetag::serde)]
pub trait BoxedVariant:
    Display + Debug + DynHash + DynClone + Datum<Value> + DatumLower<Value>
{
    fn type_tag(&self) -> BoxedVariantTypeTag;

    fn as_any(&self) -> &dyn Any;
    fn into_dyn_iter(self: Box<Self>) -> BoxedVariantResult<BoxedVariantValueIntoIterator>;

    fn category(&self) -> DatumCategoryRef<'_>;

    fn into_category(self: Box<Self>) -> DatumCategoryOwned;
}

dyn_hash::hash_trait_object!(BoxedVariant);
dyn_clone::clone_trait_object!(BoxedVariant);

impl Eq for DynBoxedVariant {}
impl PartialEq for DynBoxedVariant {
    fn eq(&self, other: &Self) -> bool {
        self.type_tag() == other.type_tag() && self.type_tag().value_eq(self, other)
    }
}
impl PartialOrd for DynBoxedVariant {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}
impl Ord for DynBoxedVariant {
    fn cmp(&self, other: &Self) -> Ordering {
        let missing = |_| Cow::Owned(Value::Missing);
        self.type_tag().cmp(&other.type_tag()).then_with(|| {
            self.lower()
                .unwrap_or_else(missing)
                .cmp(&other.lower().unwrap_or_else(missing))
        })
    }
}

impl PrettyDoc for DynBoxedVariant {
    fn pretty_doc<'b, D, A>(&'b self, arena: &'b D) -> DocBuilder<'b, D, A>
    where
        D: DocAllocator<'b, A>,
        D::Doc: Clone,
        A: Clone,
    {
        // todo!("impl PrettyDoc for BoxedVariant")
        arena.text(format!("{self}"))
    }
}