Skip to main content

radiate_core/stats/expression/
query.rs

1use super::Expr;
2use radiate_utils::SmallStr;
3#[cfg(feature = "serde")]
4use serde::{Deserialize, Serialize, ser::SerializeStruct};
5
6#[derive(Clone, Debug, PartialEq)]
7pub struct MetricQuery {
8    pub name: SmallStr,
9    pub expr: Expr,
10}
11
12impl MetricQuery {
13    pub fn new(name: impl Into<SmallStr>, expr: Expr) -> Self {
14        Self {
15            name: name.into(),
16            expr: expr.compile(),
17        }
18    }
19
20    pub fn pair(&mut self) -> (&str, &mut Expr) {
21        (self.name.as_str(), &mut self.expr)
22    }
23
24    pub fn expr(&self) -> &Expr {
25        &self.expr
26    }
27
28    pub fn expr_mut(&mut self) -> &mut Expr {
29        &mut self.expr
30    }
31
32    pub fn name(&self) -> &str {
33        self.name.as_str()
34    }
35}
36
37impl<T: Into<SmallStr>> From<(T, Expr)> for MetricQuery {
38    fn from((name, expr): (T, Expr)) -> Self {
39        Self::new(name, expr)
40    }
41}
42
43#[cfg(feature = "serde")]
44impl Serialize for MetricQuery {
45    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
46    where
47        S: serde::Serializer,
48    {
49        let mut state = serializer.serialize_struct("MetricQuery", 2)?;
50        state.serialize_field("name", &self.name)?;
51        state.serialize_field("expr", &self.expr)?;
52        state.end()
53    }
54}
55
56#[cfg(feature = "serde")]
57impl<'de> Deserialize<'de> for MetricQuery {
58    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
59    where
60        D: serde::Deserializer<'de>,
61    {
62        #[derive(Deserialize)]
63        struct NamedExprData {
64            name: String,
65            expr: Expr,
66        }
67
68        let data = NamedExprData::deserialize(deserializer)?;
69        Ok(MetricQuery::new(
70            radiate_utils::intern!(data.name),
71            data.expr,
72        ))
73    }
74}