postgrest_parser/ast/
params.rs

1use super::{LogicCondition, OrderTerm, SelectItem};
2use serde::{Deserialize, Serialize};
3
4#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5pub struct ParsedParams {
6    pub select: Option<Vec<SelectItem>>,
7    pub filters: Vec<LogicCondition>,
8    pub order: Vec<OrderTerm>,
9    pub limit: Option<u64>,
10    pub offset: Option<u64>,
11}
12
13impl ParsedParams {
14    pub fn new() -> Self {
15        Self {
16            select: None,
17            filters: Vec::new(),
18            order: Vec::new(),
19            limit: None,
20            offset: None,
21        }
22    }
23
24    pub fn with_select(mut self, select: Vec<SelectItem>) -> Self {
25        self.select = Some(select);
26        self
27    }
28
29    pub fn with_filters(mut self, filters: Vec<LogicCondition>) -> Self {
30        self.filters = filters;
31        self
32    }
33
34    pub fn with_order(mut self, order: Vec<OrderTerm>) -> Self {
35        self.order = order;
36        self
37    }
38
39    pub fn with_limit(mut self, limit: u64) -> Self {
40        self.limit = Some(limit);
41        self
42    }
43
44    pub fn with_offset(mut self, offset: u64) -> Self {
45        self.offset = Some(offset);
46        self
47    }
48
49    pub fn is_empty(&self) -> bool {
50        self.select.is_none()
51            && self.filters.is_empty()
52            && self.order.is_empty()
53            && self.limit.is_none()
54            && self.offset.is_none()
55    }
56
57    pub fn has_filters(&self) -> bool {
58        !self.filters.is_empty()
59    }
60
61    pub fn has_select(&self) -> bool {
62        self.select.is_some()
63    }
64}
65
66impl Default for ParsedParams {
67    fn default() -> Self {
68        Self::new()
69    }
70}
71
72#[cfg(test)]
73mod tests {
74    use super::*;
75    use crate::ast::{Field, Filter, FilterOperator, FilterValue};
76
77    #[test]
78    fn test_parsed_params_new() {
79        let params = ParsedParams::new();
80        assert!(params.select.is_none());
81        assert!(params.filters.is_empty());
82        assert!(params.order.is_empty());
83        assert!(params.limit.is_none());
84        assert!(params.offset.is_none());
85    }
86
87    #[test]
88    fn test_parsed_params_with_select() {
89        let select = vec![SelectItem::field("id"), SelectItem::field("name")];
90        let params = ParsedParams::new().with_select(select);
91        assert!(params.has_select());
92        assert_eq!(params.select.as_ref().unwrap().len(), 2);
93    }
94
95    #[test]
96    fn test_parsed_params_with_limit() {
97        let params = ParsedParams::new().with_limit(100);
98        assert_eq!(params.limit, Some(100));
99    }
100
101    #[test]
102    fn test_parsed_params_with_offset() {
103        let params = ParsedParams::new().with_offset(20);
104        assert_eq!(params.offset, Some(20));
105    }
106
107    #[test]
108    fn test_parsed_params_is_empty() {
109        let params = ParsedParams::new();
110        assert!(params.is_empty());
111    }
112
113    #[test]
114    fn test_parsed_params_has_filters() {
115        let filter = LogicCondition::Filter(Filter::new(
116            Field::new("id"),
117            FilterOperator::Eq,
118            FilterValue::Single("1".to_string()),
119        ));
120        let params = ParsedParams::new().with_filters(vec![filter]);
121        assert!(params.has_filters());
122    }
123
124    #[test]
125    fn test_parsed_params_default() {
126        let params = ParsedParams::default();
127        assert!(params.is_empty());
128    }
129
130    #[test]
131    fn test_parsed_params_serialization() {
132        let params = ParsedParams::new().with_limit(10);
133        let json = serde_json::to_string(&params).unwrap();
134        assert!(json.contains("limit"));
135    }
136}
postgrest_parser/ast/params.rs

postgrest_parser/ast/
params.rs
