4698125137

Build Type

github

Committed by GitHub

Commit Message

Merge ef21858a9 into ca6ea5f58

Pull Request Pull Request #1432: chore: Add deb generation to release process

Run Details

34321 of 44357 relevant lines covered (77.37%)

16844.6 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>	821✔
14	where	821✔
15	D: Deserializer<'de>,	821✔
16	{	821✔
17	struct FilterExpressionVisitor {}	821✔
18	impl<'de> Visitor<'de> for FilterExpressionVisitor {	821✔
19	type Value = FilterExpression;	821✔
20		821✔
21	fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {	821✔
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>	821✔
25	where	815✔
26	A: MapAccess<'de>,	815✔
27	{	815✔
28	let mut expressions = vec![];	815✔
29	while let Some(key) = map.next_key::<String>()? {	1,973✔
30	if key == "$and" {	1,166✔
31	expressions.push(FilterExpression::And(map.next_value()?));	821✔
32	} else {	1,166✔
33	let operator_and_value = map.next_value::<OperatorAndValue>()?;	1,163✔
34	expressions.push(FilterExpression::Simple(	1,166✔
35	key,	1,157✔
36	operator_and_value.operator,	1,157✔
37	operator_and_value.value,	1,157✔
38	));	1,157✔
39	}	821✔
40	}	821✔
41	if expressions.len() == 1 {	821✔
42	Ok(expressions.remove(0))	821✔
43	} else {	821✔
44	Ok(FilterExpression::And(expressions))	821✔
45	}	821✔
46	}	821✔
47	}	821✔
48	deserializer.deserialize_map(FilterExpressionVisitor {})	821✔
49	}	821✔
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>	633✔
74	where	633✔
75	D: Deserializer<'de>,	633✔
76	{	633✔
77	struct SortOptionsVisitor {}	633✔
78	impl<'de> Visitor<'de> for SortOptionsVisitor {	633✔
79	type Value = SortOptions;	633✔
80		633✔
81	fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {	633✔
82	formatter.write_str("map from field name to sort direction")	6✔
83	}	6✔
84		633✔
85	fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>	633✔
86	where	627✔
87	A: MapAccess<'de>,	627✔
88	{	627✔
89	let mut sort_options = vec![];	627✔
90	while let Some((field_name, direction)) = map.next_entry()? {	1,246✔
91	sort_options.push(SortOption {	619✔
92	field_name,	619✔
93	direction,	619✔
94	});	619✔
95	}	619✔
96	Ok(SortOptions(sort_options))	633✔
97	}	633✔
98	}	633✔
99	deserializer.deserialize_map(SortOptionsVisitor {})	633✔
100	}	633✔
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>	922✔
118	where	922✔
119	D: Deserializer<'de>,	922✔
120	{	922✔
121	struct QueryExpressionVisitor {}	922✔
122	impl<'de> Visitor<'de> for QueryExpressionVisitor {	922✔
123	type Value = QueryExpression;	922✔
124		922✔
125	fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {	922✔
126	formatter.write_str("map of dozer query options")	×
127	}	×
128	fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>	922✔
129	where	921✔
130	A: MapAccess<'de>,	921✔
131	{	921✔
132	let mut filter = None;	921✔
133	let mut order_by = None;	921✔
134	let mut limit = None;	921✔
135	let mut skip = None;	921✔
136	while let Some(key) = map.next_key::<String>()? {	3,387✔
137	match key.as_str() {	2,467✔
138	"$filter" => {	2,467✔
139	filter = Some(map.next_value()?);	922✔
140	}	922✔
141	"$order_by" => {	1,707✔
142	order_by = Some(map.next_value()?);	922✔
143	}	922✔
144	"$limit" => {	1,097✔
145	limit = Some(map.next_value()?);	922✔
146	}	922✔
147	"$skip" => {	922✔
148	if skip.is_some() {	922✔
149	return Err(Error::custom("$skip cannot be used with $after"));	922✔
150	}	922✔
151	skip = Some(Skip::Skip(map.next_value()?));	367✔
152	}	922✔
153	"$after" => {	922✔
154	if skip.is_some() {	922✔
155	return Err(Error::custom("$after cannot be used with $skip"));	922✔
156	}	922✔
157	skip = Some(Skip::After(map.next_value()?));	231✔
158	}	922✔
159	_ => {}	922✔
160	}	922✔
161	}	922✔
162	Ok(QueryExpression {	922✔
163	filter,	921✔
164	order_by: order_by.unwrap_or_default(),	921✔
165	limit,	921✔
166	skip: skip.unwrap_or_default(),	921✔
167	})	921✔
168	}	922✔
169	}	922✔
170	deserializer.deserialize_map(QueryExpressionVisitor {})	922✔
171	}	922✔
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 / 4698125137

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