reddb_server/storage/query/parser/
graph.rs

1//! Graph query parsing (MATCH pattern)
2
3use super::super::ast::{
4    CompareOp, EdgeDirection, EdgePattern, FieldRef, GraphPattern, GraphQuery, NodePattern,
5    Projection, PropertyFilter, QueryExpr,
6};
7use super::super::lexer::Token;
8use super::error::ParseError;
9use super::Parser;
10
11impl<'a> Parser<'a> {
12    /// Parse MATCH ... RETURN query
13    pub fn parse_match_query(&mut self) -> Result<QueryExpr, ParseError> {
14        self.expect(Token::Match)?;
15
16        let pattern = self.parse_graph_pattern()?;
17
18        let filter = if self.consume(&Token::Where)? {
19            Some(self.parse_filter()?)
20        } else {
21            None
22        };
23
24        self.expect(Token::Return)?;
25        let return_ = self.parse_return_list()?;
26        let limit = self.parse_match_limit()?;
27
28        Ok(QueryExpr::Graph(GraphQuery {
29            alias: None,
30            pattern,
31            filter,
32            return_,
33            limit,
34        }))
35    }
36
37    fn parse_match_limit(&mut self) -> Result<Option<u64>, ParseError> {
38        if !self.consume(&Token::Limit)? && !self.consume_ident_ci("LIMIT")? {
39            return Ok(None);
40        }
41
42        let pos = self.position();
43        if matches!(self.current.token, Token::Minus | Token::Dash) {
44            return Err(ParseError::value_out_of_range(
45                "MATCH LIMIT",
46                "must be a non-negative integer",
47                pos,
48            ));
49        }
50
51        let raw = self.parse_integer()?;
52        if raw < 0 {
53            return Err(ParseError::value_out_of_range(
54                "MATCH LIMIT",
55                "must be a non-negative integer",
56                pos,
57            ));
58        }
59        Ok(Some(raw as u64))
60    }
61
62    /// Parse graph pattern: (a)-[r]->(b)
63    pub fn parse_graph_pattern(&mut self) -> Result<GraphPattern, ParseError> {
64        let mut pattern = GraphPattern::new();
65
66        // Parse first node
67        let first_node = self.parse_node_pattern()?;
68        pattern.nodes.push(first_node);
69
70        // Parse chain of edges and nodes
71        while self.peek() == &Token::Dash || self.peek() == &Token::ArrowLeft {
72            let (edge, next_node) =
73                self.parse_edge_and_node(pattern.nodes.last().unwrap().alias.clone())?;
74            pattern.edges.push(edge);
75            pattern.nodes.push(next_node);
76        }
77
78        Ok(pattern)
79    }
80
81    /// Parse node pattern: (alias:Type {props})
82    pub fn parse_node_pattern(&mut self) -> Result<NodePattern, ParseError> {
83        self.expect(Token::LParen)?;
84
85        let alias = self.expect_ident()?;
86
87        // Label filter is a free-form string; resolution against the
88        // graph's `LabelRegistry` happens at execution time, not here.
89        let node_label = if self.consume(&Token::Colon)? {
90            Some(self.expect_ident_or_keyword()?.to_lowercase())
91        } else {
92            None
93        };
94
95        let properties = if self.consume(&Token::LBrace)? {
96            self.parse_property_filters()?
97        } else {
98            Vec::new()
99        };
100
101        self.expect(Token::RParen)?;
102
103        Ok(NodePattern {
104            alias,
105            node_label,
106            properties,
107        })
108    }
109
110    /// Parse edge and next node: -[r:TYPE*min..max]->(b)
111    fn parse_edge_and_node(
112        &mut self,
113        from_alias: String,
114    ) -> Result<(EdgePattern, NodePattern), ParseError> {
115        // Determine direction
116        let incoming = self.consume(&Token::ArrowLeft)?;
117        if !incoming {
118            self.expect(Token::Dash)?;
119        }
120
121        // Parse edge pattern
122        self.expect(Token::LBracket)?;
123
124        let alias = if let Token::Ident(name) = self.peek() {
125            let name = name.clone();
126            self.advance()?;
127            Some(name)
128        } else {
129            None
130        };
131
132        let edge_label = if self.consume(&Token::Colon)? {
133            Some(self.expect_ident_or_keyword()?.to_lowercase())
134        } else {
135            None
136        };
137
138        // Variable length: *min..max
139        let (min_hops, max_hops) = if self.consume(&Token::Star)? {
140            if let Token::Integer(_) = self.peek() {
141                let min = self.parse_integer()? as u32;
142                if self.consume(&Token::DotDot)? {
143                    let max = self.parse_integer()? as u32;
144                    (min, max)
145                } else {
146                    (min, min)
147                }
148            } else {
149                (1, u32::MAX) // * means any length
150            }
151        } else {
152            (1, 1) // Default: exactly 1 hop
153        };
154
155        self.expect(Token::RBracket)?;
156
157        // Determine final direction
158        let direction = if incoming {
159            self.expect(Token::Dash)?;
160            EdgeDirection::Incoming
161        } else if self.consume(&Token::Arrow)? {
162            EdgeDirection::Outgoing
163        } else {
164            self.expect(Token::Dash)?;
165            EdgeDirection::Both
166        };
167
168        // Parse next node
169        let next_node = self.parse_node_pattern()?;
170
171        let edge = EdgePattern {
172            alias,
173            from: from_alias,
174            to: next_node.alias.clone(),
175            edge_label,
176            direction,
177            min_hops,
178            max_hops,
179        };
180
181        Ok((edge, next_node))
182    }
183
184    /// Parse property filters in braces: {name: 'value', age: 25}
185    pub fn parse_property_filters(&mut self) -> Result<Vec<PropertyFilter>, ParseError> {
186        let mut filters = Vec::new();
187
188        loop {
189            let name = self.expect_ident()?;
190            self.expect(Token::Colon)?;
191            let value = self.parse_value()?;
192
193            filters.push(PropertyFilter {
194                name,
195                op: CompareOp::Eq,
196                value,
197            });
198
199            if !self.consume(&Token::Comma)? {
200                break;
201            }
202        }
203
204        self.expect(Token::RBrace)?;
205        Ok(filters)
206    }
207
208    /// Parse RETURN list
209    pub fn parse_return_list(&mut self) -> Result<Vec<Projection>, ParseError> {
210        let mut projections = Vec::new();
211        loop {
212            let proj = self.parse_graph_projection()?;
213            projections.push(proj);
214
215            if !self.consume(&Token::Comma)? {
216                break;
217            }
218        }
219        Ok(projections)
220    }
221
222    /// Parse a graph projection (can be node alias, node.property, etc.)
223    fn parse_graph_projection(&mut self) -> Result<Projection, ParseError> {
224        let first = self.expect_ident()?;
225
226        let field = if self.consume(&Token::Dot)? {
227            let prop = self.expect_ident()?;
228            FieldRef::NodeProperty {
229                alias: first,
230                property: prop,
231            }
232        } else {
233            // Just the alias, refers to the whole node
234            FieldRef::NodeId { alias: first }
235        };
236
237        let alias = if self.consume(&Token::As)? {
238            Some(self.expect_ident()?)
239        } else {
240            None
241        };
242
243        Ok(Projection::Field(field, alias))
244    }
245
246    /// Normalize a parsed node-type token to its label-string form. The
247    /// pentest-flavoured aliases (`VULN`, `TECH`, `CERT`) are kept so
248    /// existing query strings continue to parse, but the result is just
249    /// the canonical lowercase label and is no longer constrained to a
250    /// closed enum.
251    pub fn parse_node_label(&self, name: &str) -> Result<String, ParseError> {
252        let canonical = match name.to_uppercase().as_str() {
253            "HOST" => "host",
254            "SERVICE" => "service",
255            "CREDENTIAL" => "credential",
256            "VULNERABILITY" | "VULN" => "vulnerability",
257            "ENDPOINT" => "endpoint",
258            "TECHNOLOGY" | "TECH" => "technology",
259            "USER" => "user",
260            "DOMAIN" => "domain",
261            "CERTIFICATE" | "CERT" => "certificate",
262            // Forward unknown labels verbatim (lowercased) — the registry
263            // resolves them at execution time, or a later validation
264            // pass can reject them.
265            other => return Ok(other.to_lowercase()),
266        };
267        Ok(canonical.to_string())
268    }
269
270    /// Edge label counterpart to [`parse_node_label`].
271    pub fn parse_edge_label(&self, name: &str) -> Result<String, ParseError> {
272        let canonical = match name.to_uppercase().as_str() {
273            "HAS_SERVICE" => "has_service",
274            "HAS_ENDPOINT" => "has_endpoint",
275            "USES_TECH" | "USES_TECHNOLOGY" => "uses_tech",
276            "AUTH_ACCESS" | "AUTH" => "auth_access",
277            "AFFECTED_BY" => "affected_by",
278            "CONTAINS" => "contains",
279            "CONNECTS_TO" | "CONNECTS" => "connects_to",
280            "RELATED_TO" | "RELATED" => "related_to",
281            "HAS_USER" => "has_user",
282            "HAS_CERT" | "HAS_CERTIFICATE" => "has_cert",
283            other => return Ok(other.to_lowercase()),
284        };
285        Ok(canonical.to_string())
286    }
287}
reddb_server/storage/query/parser/graph.rs

reddb_server/storage/query/parser/
graph.rs
