4698406303

Build Type

github

Committed by GitHub

Commit Message

Merge daefffe87 into b6889464a

Pull Request Pull Request #1426: feat: implement python log bindings

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

34863 of 45840 relevant lines covered (76.05%)

10764.36 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.8

/dozer-cache/src/cache/expression/query_serde.rs

use dozer_types::serde::{
    de::{Deserialize, Deserializer, Error, MapAccess, Visitor},
    ser::{Serialize, SerializeMap, Serializer},
};

use super::{
    super::expression::{FilterExpression, Skip, SortOption},
    query_helper::{OperatorAndValue, OperatorAndValueBorrow},
    QueryExpression, SortOptions,
};

impl<'de> Deserialize<'de> for FilterExpression {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct FilterExpressionVisitor {}
        impl<'de> Visitor<'de> for FilterExpressionVisitor {
            type Value = FilterExpression;

            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("map from field name to value or operator value map")
            }
            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
            where
                A: MapAccess<'de>,
            {
                let mut expressions = vec![];
                while let Some(key) = map.next_key::<String>()? {
                    if key == "$and" {
                        expressions.push(FilterExpression::And(map.next_value()?));
                    } else {
                        let operator_and_value = map.next_value::<OperatorAndValue>()?;
                        expressions.push(FilterExpression::Simple(
                            key,
                            operator_and_value.operator,
                            operator_and_value.value,
                        ));
                    }
                }
                if expressions.len() == 1 {
                    Ok(expressions.remove(0))
                } else {
                    Ok(FilterExpression::And(expressions))
                }
            }
        }
        deserializer.deserialize_map(FilterExpressionVisitor {})
    }
}

impl Serialize for FilterExpression {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match self {
            FilterExpression::Simple(name, operator, value) => {
                let mut state = serializer.serialize_map(Some(1))?;
                state.serialize_entry(name, &OperatorAndValueBorrow { operator, value })?;
                state.end()
            }
            FilterExpression::And(expressions) => {
                let mut state = serializer.serialize_map(Some(1))?;
                state.serialize_entry("$and", &expressions)?;
                state.end()
            }
        }
    }
}

impl<'de> Deserialize<'de> for SortOptions {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct SortOptionsVisitor {}
        impl<'de> Visitor<'de> for SortOptionsVisitor {
            type Value = SortOptions;

            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("map from field name to sort direction")
            }

            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
            where
                A: MapAccess<'de>,
            {
                let mut sort_options = vec![];
                while let Some((field_name, direction)) = map.next_entry()? {
                    sort_options.push(SortOption {
                        field_name,
                        direction,
                    });
                }
                Ok(SortOptions(sort_options))
            }
        }
        deserializer.deserialize_map(SortOptionsVisitor {})
    }
}

impl Serialize for SortOptions {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut state = serializer.serialize_map(Some(self.0.len()))?;
        for sort_option in &self.0 {
            state.serialize_entry(&sort_option.field_name, &sort_option.direction)?;
        }
        state.end()
    }
}

impl<'de> Deserialize<'de> for QueryExpression {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct QueryExpressionVisitor {}
        impl<'de> Visitor<'de> for QueryExpressionVisitor {
            type Value = QueryExpression;

            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("map of dozer query options")
            }
            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
            where
                A: MapAccess<'de>,
            {
                let mut filter = None;
                let mut order_by = None;
                let mut limit = None;
                let mut skip = None;
                while let Some(key) = map.next_key::<String>()? {
                    match key.as_str() {
                        "$filter" => {
                            filter = Some(map.next_value()?);
                        }
                        "$order_by" => {
                            order_by = Some(map.next_value()?);
                        }
                        "$limit" => {
                            limit = Some(map.next_value()?);
                        }
                        "$skip" => {
                            if skip.is_some() {
                                return Err(Error::custom("$skip cannot be used with $after"));
                            }
                            skip = Some(Skip::Skip(map.next_value()?));
                        }
                        "$after" => {
                            if skip.is_some() {
                                return Err(Error::custom("$after cannot be used with $skip"));
                            }
                            skip = Some(Skip::After(map.next_value()?));
                        }
                        _ => {}
                    }
                }
                Ok(QueryExpression {
                    filter,
                    order_by: order_by.unwrap_or_default(),
                    limit,
                    skip: skip.unwrap_or_default(),
                })
            }
        }
        deserializer.deserialize_map(QueryExpressionVisitor {})
    }
}

impl Serialize for QueryExpression {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut state = serializer.serialize_map(Some(4))?;
        if let Some(filter) = &self.filter {
            state.serialize_entry("$filter", filter)?;
        }
        if !self.order_by.0.is_empty() {
            state.serialize_entry("$order_by", &self.order_by)?;
        }
        if let Some(limit) = self.limit {
            state.serialize_entry("$limit", &limit)?;
        }
        match self.skip {
            Skip::Skip(skip) => {
                if skip > 0 {
                    state.serialize_entry("$skip", &skip)?;
                }
            }
            Skip::After(after) => {
                state.serialize_entry("$after", &after)?;
            }
        }
        state.end()
    }
}

1	use dozer_types::serde::{
2	de::{Deserialize, Deserializer, Error, MapAccess, Visitor},
3	ser::{Serialize, SerializeMap, Serializer},
4	};
5
6	use super::{
7	super::expression::{FilterExpression, Skip, SortOption},
8	query_helper::{OperatorAndValue, OperatorAndValueBorrow},
9	QueryExpression, SortOptions,
10	};
11
12	impl<'de> Deserialize<'de> for FilterExpression {
13	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>	66✔
14	where	66✔
15	D: Deserializer<'de>,	66✔
16	{	66✔
17	struct FilterExpressionVisitor {}	66✔
18	impl<'de> Visitor<'de> for FilterExpressionVisitor {	66✔
19	type Value = FilterExpression;	66✔
20		66✔
21	fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {	66✔
22	formatter.write_str("map from field name to value or operator value map")	6✔
23	}	6✔
24	fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>	66✔
25	where	60✔
26	A: MapAccess<'de>,	60✔
27	{	60✔
28	let mut expressions = vec![];	60✔
29	while let Some(key) = map.next_key::<String>()? {	118✔
30	if key == "$and" {	66✔
31	expressions.push(FilterExpression::And(map.next_value()?));	66✔
32	} else {	66✔
33	let operator_and_value = map.next_value::<OperatorAndValue>()?;	63✔
34	expressions.push(FilterExpression::Simple(	66✔
35	key,	57✔
36	operator_and_value.operator,	57✔
37	operator_and_value.value,	57✔
38	));	57✔
39	}	66✔
40	}	66✔
41	if expressions.len() == 1 {	66✔
42	Ok(expressions.remove(0))	66✔
43	} else {	66✔
44	Ok(FilterExpression::And(expressions))	66✔
45	}	66✔
46	}	66✔
47	}	66✔
48	deserializer.deserialize_map(FilterExpressionVisitor {})	66✔
49	}	66✔
50	}
51
52	impl Serialize for FilterExpression {
53	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>	22✔
54	where	22✔
55	S: Serializer,	22✔
56	{	22✔
57	match self {	22✔
58	FilterExpression::Simple(name, operator, value) => {	20✔
59	let mut state = serializer.serialize_map(Some(1))?;	20✔
60	state.serialize_entry(name, &OperatorAndValueBorrow { operator, value })?;	20✔
61	state.end()	20✔
62	}
63	FilterExpression::And(expressions) => {	2✔
64	let mut state = serializer.serialize_map(Some(1))?;	2✔
65	state.serialize_entry("$and", &expressions)?;	2✔
66	state.end()	2✔
67	}
68	}
69	}	22✔
70	}
71
72	impl<'de> Deserialize<'de> for SortOptions {
73	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>	23✔
74	where	23✔
75	D: Deserializer<'de>,	23✔
76	{	23✔
77	struct SortOptionsVisitor {}	23✔
78	impl<'de> Visitor<'de> for SortOptionsVisitor {	23✔
79	type Value = SortOptions;	23✔
80		23✔
81	fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {	23✔
82	formatter.write_str("map from field name to sort direction")	6✔
83	}	6✔
84		23✔
85	fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>	23✔
86	where	17✔
87	A: MapAccess<'de>,	17✔
88	{	17✔
89	let mut sort_options = vec![];	17✔
90	while let Some((field_name, direction)) = map.next_entry()? {	26✔
91	sort_options.push(SortOption {	9✔
92	field_name,	9✔
93	direction,	9✔
94	});	9✔
95	}	9✔
96	Ok(SortOptions(sort_options))	23✔
97	}	23✔
98	}	23✔
99	deserializer.deserialize_map(SortOptionsVisitor {})	23✔
100	}	23✔
101	}
102
103	impl Serialize for SortOptions {
104	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>	6✔
105	where	6✔
106	S: Serializer,	6✔
107	{	6✔
108	let mut state = serializer.serialize_map(Some(self.0.len()))?;	6✔
109	for sort_option in &self.0 {	13✔
110	state.serialize_entry(&sort_option.field_name, &sort_option.direction)?;	7✔
111	}
112	state.end()	6✔
113	}	6✔
114	}
115
116	impl<'de> Deserialize<'de> for QueryExpression {
117	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>	47✔
118	where	47✔
119	D: Deserializer<'de>,	47✔
120	{	47✔
121	struct QueryExpressionVisitor {}	47✔
122	impl<'de> Visitor<'de> for QueryExpressionVisitor {	47✔
123	type Value = QueryExpression;	47✔
124		47✔
125	fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {	47✔
126	formatter.write_str("map of dozer query options")	×
127	}	×
128	fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>	47✔
129	where	47✔
130	A: MapAccess<'de>,	47✔
131	{	47✔
132	let mut filter = None;	47✔
133	let mut order_by = None;	47✔
134	let mut limit = None;	47✔
135	let mut skip = None;	47✔
136	while let Some(key) = map.next_key::<String>()? {	98✔
137	match key.as_str() {	52✔
138	"$filter" => {	52✔
139	filter = Some(map.next_value()?);	47✔
140	}	47✔
141	"$order_by" => {	47✔
142	order_by = Some(map.next_value()?);	47✔
143	}	47✔
144	"$limit" => {	47✔
145	limit = Some(map.next_value()?);	47✔
146	}	47✔
147	"$skip" => {	47✔
148	if skip.is_some() {	47✔
149	return Err(Error::custom("$skip cannot be used with $after"));	47✔
150	}	47✔
151	skip = Some(Skip::Skip(map.next_value()?));	2✔
152	}	47✔
153	"$after" => {	47✔
154	if skip.is_some() {	47✔
155	return Err(Error::custom("$after cannot be used with $skip"));	47✔
156	}	47✔
157	skip = Some(Skip::After(map.next_value()?));	1✔
158	}	47✔
159	_ => {}	47✔
160	}	47✔
161	}	47✔
162	Ok(QueryExpression {	47✔
163	filter,	46✔
164	order_by: order_by.unwrap_or_default(),	46✔
165	limit,	46✔
166	skip: skip.unwrap_or_default(),	46✔
167	})	46✔
168	}	47✔
169	}	47✔
170	deserializer.deserialize_map(QueryExpressionVisitor {})	47✔
171	}	47✔
172	}
173
174	impl Serialize for QueryExpression {
175	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>	15✔
176	where	15✔
177	S: Serializer,	15✔
178	{	15✔
179	let mut state = serializer.serialize_map(Some(4))?;	15✔
180	if let Some(filter) = &self.filter {	15✔
181	state.serialize_entry("$filter", filter)?;	4✔
182	}	11✔
183	if !self.order_by.0.is_empty() {	15✔
184	state.serialize_entry("$order_by", &self.order_by)?;	1✔
185	}	14✔
186	if let Some(limit) = self.limit {	15✔
187	state.serialize_entry("$limit", &limit)?;	4✔
188	}	11✔
189	match self.skip {	15✔
190	Skip::Skip(skip) => {	13✔
191	if skip > 0 {	13✔
192	state.serialize_entry("$skip", &skip)?;	2✔
193	}	11✔
194	}
195	Skip::After(after) => {	2✔
196	state.serialize_entry("$after", &after)?;	2✔
197	}
198	}
199	state.end()	15✔
200	}	15✔
201	}

getdozer / dozer / 4698406303

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous