1use crate::ast::*;
2use crate::error::{Error, Result};
3use crate::lexer::Lexer;
4use crate::token::{Token, TokenKind};
5
6type EdgeTypeTail = (
7 Direction,
8 Option<Identifier>,
9 Option<Identifier>,
10 Vec<PropertyTypeDefinition>,
11);
12type PatternElementBody = (
13 Option<Identifier>,
14 bool,
15 Vec<Identifier>,
16 Option<LabelExpression>,
17 Option<MapLiteral>,
18 Option<Expr>,
19);
20type InsertElementBody = (
21 Option<Identifier>,
22 Vec<Identifier>,
23 Option<LabelExpression>,
24 Option<MapLiteral>,
25);
26
27pub fn parse(input: &str) -> Result<Program> {
28 Parser::new(input).parse_program()
29}
30
31#[derive(Clone, Debug)]
32pub struct Parser {
33 tokens: Vec<Token>,
34 pos: usize,
35 lexer_error: Option<Error>,
36 stop_in_as_delimiter: bool,
37 depth: u32,
38}
39
40const MAX_PARSE_DEPTH: u32 = 32;
43const MAX_EXPR_CHAIN: u32 = 128;
44
45#[derive(Clone, Copy, Debug, PartialEq, Eq)]
46enum GraphTypeElementContext {
47 GraphTypeSpecificationBody,
48 ClosedReferenceValueType,
49}
50
51#[derive(Clone, Copy, Debug, PartialEq, Eq)]
52enum LiteralKind {
53 Date,
54 Time,
55 DateTime,
56 Duration,
57}
58
59#[derive(Clone, Copy, Debug, PartialEq, Eq)]
60enum SqlIntervalFieldKind {
61 Year,
62 Month,
63 Day,
64 Hour,
65 Minute,
66 Second,
67}
68
69#[derive(Clone, Copy, Debug, PartialEq, Eq)]
70enum SimplifiedPrefix {
71 Minus,
72 ArrowLeft,
73 Tilde,
74 LtTilde,
75}
76
77#[derive(Clone, Copy, Debug, PartialEq, Eq)]
78enum InsertElementKind {
79 Node,
80 Edge,
81}
82
83#[derive(Clone, Debug)]
84struct SimplifiedRelationshipBody {
85 labels: Vec<Identifier>,
86 label_expression: LabelExpression,
87 direction_override: Option<Direction>,
88 quantifier: Option<PathPatternQuantifier>,
89}
90
91#[derive(Clone, Debug)]
92enum SimplifiedPathPatternExpression {
93 Linear(Vec<RelationshipPattern>),
94 Alternation {
95 alternation: PathPatternAlternation,
96 alternatives: Vec<Vec<RelationshipPattern>>,
97 },
98}
99
100impl Parser {
101 pub fn new(input: &str) -> Self {
102 let mut tokens = Vec::new();
103 let mut lexer_error = None;
104 for token in Lexer::new(input) {
105 match token {
106 Ok(token) => tokens.push(token),
107 Err(err) => {
108 lexer_error = Some(err);
109 break;
110 }
111 }
112 }
113 tokens.push(Token::new(TokenKind::Eof, "", input.len()));
114 Self {
115 tokens,
116 pos: 0,
117 lexer_error,
118 stop_in_as_delimiter: false,
119 depth: 0,
120 }
121 }
122
123 pub fn parse_program(mut self) -> Result<Program> {
124 if let Some(err) = self.lexer_error.take() {
125 return Err(err);
126 }
127 self.parse_program_body(TokenKind::Eof)
128 }
129
130 fn parse_program_body(&mut self, terminator: TokenKind) -> Result<Program> {
131 let at_schema = self.parse_optional_program_at_schema_clause()?;
132 let mut definitions = Vec::new();
133 let mut statements = Vec::new();
134 self.eat_many(TokenKind::Semicolon);
135 while self.starts_binding_variable_definition() {
136 let offset = self.peek().offset;
137 let definition = self.parse_binding_variable_definition()?;
138 self.push_binding_variable_definition(&mut definitions, definition, offset)?;
139 self.eat_many(TokenKind::Semicolon);
140 }
141 while !self.at(terminator) {
142 let statement = self.parse_statement()?;
143 let can_continue_without_semicolon =
144 self.can_continue_program_without_semicolon(&statement, terminator);
145 statements.push(statement);
146 while self.eat(TokenKind::Next).is_some() {
147 statements.push(Statement::Next(self.parse_next_statement()?));
148 }
149 if !matches!(self.peek_kind(), TokenKind::Semicolon) && !self.at(terminator) {
150 if can_continue_without_semicolon {
151 continue;
152 }
153 return Err(
154 self.error_expected(vec![TokenKind::Semicolon, terminator], self.peek_kind())
155 );
156 }
157 self.eat_many(TokenKind::Semicolon);
158 }
159 Ok(Program {
160 at_schema,
161 definitions,
162 statements,
163 })
164 }
165
166 fn can_continue_program_without_semicolon(
167 &self,
168 previous: &Statement,
169 terminator: TokenKind,
170 ) -> bool {
171 if terminator != TokenKind::Eof {
172 return false;
173 }
174
175 match previous {
176 Statement::StartTransaction(_) => {
177 starts_transaction_procedure(self.peek_kind())
178 || self.starts_session_close_command()
179 }
180 Statement::Query(_)
181 | Statement::Call(_)
182 | Statement::Insert(_)
183 | Statement::Delete(_)
184 | Statement::Set(_)
185 | Statement::Remove(_)
186 | Statement::LinearCatalog(_)
187 | Statement::CreateGraph(_)
188 | Statement::DropGraph(_)
189 | Statement::CreateGraphType(_)
190 | Statement::DropGraphType(_)
191 | Statement::CreateSchema(_)
192 | Statement::DropSchema(_) => {
193 matches!(self.peek_kind(), TokenKind::Commit | TokenKind::Rollback)
194 || self.starts_session_close_command()
195 }
196 Statement::Commit(_) | Statement::Rollback(_) => self.starts_session_close_command(),
197 Statement::SessionSet(_) | Statement::SessionReset(_) => {
198 self.starts_session_activity_command() || self.starts_session_close_command()
199 }
200 _ => false,
201 }
202 }
203
204 fn starts_session_activity_command(&self) -> bool {
205 self.peek_kind() == TokenKind::Session
206 && matches!(self.peek_n_kind(1), Some(TokenKind::Set | TokenKind::Reset))
207 }
208
209 fn starts_session_close_command(&self) -> bool {
210 self.peek_kind() == TokenKind::Session && self.peek_n_kind(1) == Some(TokenKind::Close)
211 }
212
213 fn parse_optional_program_at_schema_clause(&mut self) -> Result<Option<SchemaReference>> {
214 if !self.at(TokenKind::At) {
215 return Ok(None);
216 }
217
218 let mut trial = self.clone();
219 let at_schema = trial.parse_optional_at_schema_clause()?;
220 trial.eat_many(TokenKind::Semicolon);
221 if trial.starts_binding_variable_definition() {
222 *self = trial;
223 Ok(at_schema)
224 } else {
225 Ok(None)
226 }
227 }
228
229 fn starts_binding_variable_definition(&self) -> bool {
230 matches!(
231 self.peek_kind(),
232 TokenKind::Value | TokenKind::Graph | TokenKind::Table
233 ) || (self.peek_n_kind(0) == Some(TokenKind::Binding)
234 && self.peek_n_kind(1) == Some(TokenKind::Table))
235 || (self.peek_n_kind(0) == Some(TokenKind::Property)
236 && self.peek_n_kind(1) == Some(TokenKind::Graph))
237 }
238
239 fn parse_binding_variable_definition(&mut self) -> Result<BindingVariableDefinition> {
240 if self.at(TokenKind::Value) {
241 return Ok(BindingVariableDefinition::Value(
242 self.parse_value_variable_definition()?,
243 ));
244 }
245 if self.at(TokenKind::Binding) || self.at(TokenKind::Table) {
246 return Ok(BindingVariableDefinition::BindingTable(
247 self.parse_binding_table_variable_definition()?,
248 ));
249 }
250 Ok(BindingVariableDefinition::Graph(
251 self.parse_graph_variable_definition()?,
252 ))
253 }
254
255 fn push_binding_variable_definition(
256 &self,
257 definitions: &mut Vec<BindingVariableDefinition>,
258 definition: BindingVariableDefinition,
259 offset: usize,
260 ) -> Result<()> {
261 let name = binding_variable_definition_name(&definition);
262 if definitions.iter().any(|existing| {
263 binding_variable_definition_name(existing)
264 .value
265 .eq_ignore_ascii_case(&name.value)
266 }) {
267 return Err(Error::Message {
268 offset,
269 message: format!("duplicate binding variable '{}'", name.value),
270 });
271 }
272 definitions.push(definition);
273 Ok(())
274 }
275
276 fn parse_graph_variable_definition(&mut self) -> Result<GraphVariableDefinition> {
277 let property_graph = if self.eat(TokenKind::Property).is_some() {
278 self.expect(TokenKind::Graph)?;
279 true
280 } else {
281 self.expect(TokenKind::Graph)?;
282 false
283 };
284 let name = self.parse_identifier()?;
285 let (typed, value_type) = self.parse_optional_definition_value_type()?;
286 self.expect(TokenKind::Eq)?;
287 Ok(GraphVariableDefinition {
288 property_graph,
289 name,
290 typed,
291 value_type,
292 initializer: self.parse_graph_expression()?,
293 })
294 }
295
296 fn parse_binding_table_variable_definition(
297 &mut self,
298 ) -> Result<BindingTableVariableDefinition> {
299 let binding = self.eat(TokenKind::Binding).is_some();
300 self.expect(TokenKind::Table)?;
301 let name = self.parse_identifier()?;
302 let (typed, value_type) = self.parse_optional_definition_value_type()?;
303 self.expect(TokenKind::Eq)?;
304 Ok(BindingTableVariableDefinition {
305 binding,
306 name,
307 typed,
308 value_type,
309 initializer: self.parse_binding_table_expression()?,
310 })
311 }
312
313 fn parse_value_variable_definition(&mut self) -> Result<ValueVariableDefinition> {
314 self.expect(TokenKind::Value)?;
315 let name = self.parse_identifier()?;
316 let (typed, value_type) = self.parse_optional_definition_value_type()?;
317 self.expect(TokenKind::Eq)?;
318 Ok(ValueVariableDefinition {
319 name,
320 typed,
321 value_type,
322 initializer: self.parse_expr()?,
323 })
324 }
325
326 fn parse_optional_definition_value_type(&mut self) -> Result<(bool, Option<ValueType>)> {
327 if self.at(TokenKind::Eq) {
328 return Ok((false, None));
329 }
330 let typed = self.parse_optional_typed_marker()?;
331 Ok((typed, Some(self.parse_value_type()?)))
332 }
333
334 fn parse_next_statement(&mut self) -> Result<NextStatement> {
335 let yield_clause = if self.eat(TokenKind::Yield).is_some() {
336 Some(self.parse_yield_clause_body(true)?)
337 } else {
338 None
339 };
340 Ok(NextStatement {
341 yield_clause,
342 statement: Box::new(self.parse_statement()?),
343 })
344 }
345
346 fn parse_statement(&mut self) -> Result<Statement> {
347 match self.peek_kind() {
348 TokenKind::At => Ok(Statement::Query(self.parse_query_statement()?)),
349 TokenKind::Use
350 | TokenKind::Match
351 | TokenKind::Filter
352 | TokenKind::Let
353 | TokenKind::For
354 | TokenKind::Order
355 | TokenKind::Offset
356 | TokenKind::Skip
357 | TokenKind::Limit
358 | TokenKind::LBrace
359 | TokenKind::Return
360 | TokenKind::Select
361 | TokenKind::Finish => Ok(Statement::Query(self.parse_query_statement()?)),
362 TokenKind::Optional if self.peek_n_kind(1) == Some(TokenKind::Call) => {
363 self.parse_call_statement_or_query()
364 }
365 TokenKind::Optional => Ok(Statement::Query(self.parse_query_statement()?)),
366 TokenKind::Call => self.parse_call_statement_or_catalog_or_query(),
367 TokenKind::Start => Ok(Statement::StartTransaction(
368 self.parse_start_transaction_statement()?,
369 )),
370 TokenKind::Commit => Ok(Statement::Commit(self.parse_commit_statement()?)),
371 TokenKind::Rollback => Ok(Statement::Rollback(self.parse_rollback_statement()?)),
372 TokenKind::Insert => self.parse_data_modifying_statement_or_query(),
373 TokenKind::Delete | TokenKind::Detach | TokenKind::Nodetach => {
374 self.parse_data_modifying_statement_or_query()
375 }
376 TokenKind::Set => self.parse_data_modifying_statement_or_query(),
377 TokenKind::Session => self.parse_session_prefixed_command(),
378 TokenKind::Remove => self.parse_data_modifying_statement_or_query(),
379 TokenKind::Create | TokenKind::Drop => {
380 self.parse_catalog_modifying_statement_or_linear()
381 }
382 kind => Err(self.error_expected(
383 vec![
384 TokenKind::Use,
385 TokenKind::At,
386 TokenKind::Match,
387 TokenKind::Optional,
388 TokenKind::Filter,
389 TokenKind::Let,
390 TokenKind::For,
391 TokenKind::Order,
392 TokenKind::Offset,
393 TokenKind::Skip,
394 TokenKind::Limit,
395 TokenKind::Call,
396 TokenKind::Return,
397 TokenKind::Select,
398 TokenKind::Finish,
399 TokenKind::Start,
400 TokenKind::Commit,
401 TokenKind::Rollback,
402 TokenKind::Insert,
403 TokenKind::Delete,
404 TokenKind::Set,
405 TokenKind::Session,
406 TokenKind::Reset,
407 TokenKind::Close,
408 TokenKind::Remove,
409 TokenKind::Create,
410 TokenKind::Drop,
411 ],
412 kind,
413 )),
414 }
415 }
416
417 fn parse_catalog_modifying_statement_or_linear(&mut self) -> Result<Statement> {
418 let mut statements = vec![self.parse_simple_catalog_modifying_statement()?];
419 while self.starts_simple_catalog_modifying_statement() {
420 statements.push(self.parse_simple_catalog_modifying_statement()?);
421 }
422
423 if statements.len() == 1 {
424 Ok(statements.remove(0))
425 } else {
426 Ok(Statement::LinearCatalog(statements))
427 }
428 }
429
430 fn parse_simple_catalog_modifying_statement(&mut self) -> Result<Statement> {
431 match self.peek_kind() {
432 TokenKind::Create => self.parse_create_statement(),
433 TokenKind::Drop => self.parse_drop_statement(),
434 TokenKind::Call => Ok(Statement::Call(CallStatement {
435 call: self.parse_call_clause()?,
436 })),
437 kind => Err(self.error_expected(
438 vec![TokenKind::Create, TokenKind::Drop, TokenKind::Call],
439 kind,
440 )),
441 }
442 }
443
444 fn starts_simple_catalog_modifying_statement(&self) -> bool {
445 match self.peek_kind() {
446 TokenKind::Create => matches!(
447 self.peek_n_kind(1),
448 Some(TokenKind::Or | TokenKind::Property | TokenKind::Graph | TokenKind::Schema)
449 ),
450 TokenKind::Drop => matches!(
451 self.peek_n_kind(1),
452 Some(TokenKind::Property | TokenKind::Graph | TokenKind::Schema)
453 ),
454 TokenKind::Call => true,
455 _ => false,
456 }
457 }
458
459 fn parse_query_statement(&mut self) -> Result<QueryStatement> {
460 let at_schema = self.parse_optional_at_schema_clause()?;
461 let use_graph = if self.at(TokenKind::Use) {
462 Some(self.parse_use_graph_clause()?)
463 } else {
464 None
465 };
466 let body = self.parse_query_body()?;
467 let mut set_operations = Vec::new();
468 let mut query_conjunction = None;
469 while matches!(
470 self.peek_kind(),
471 TokenKind::Union | TokenKind::Except | TokenKind::Intersect | TokenKind::Otherwise
472 ) {
473 let operator_offset = self.peek().offset;
474 let (operator, quantifier) = self.parse_query_conjunction()?;
475 if let Some(expected) = query_conjunction {
476 if operator != expected {
477 return Err(Error::Message {
478 offset: operator_offset,
479 message: "mixed query conjunctions are not allowed".to_owned(),
480 });
481 }
482 } else {
483 query_conjunction = Some(operator);
484 }
485 let body = self.parse_query_body()?;
486 set_operations.push(QuerySetOperation {
487 operator,
488 quantifier,
489 body,
490 });
491 }
492 Ok(QueryStatement {
493 at_schema,
494 use_graph,
495 body,
496 set_operations,
497 })
498 }
499
500 fn parse_query_conjunction(&mut self) -> Result<(QuerySetOperator, Option<SetQuantifier>)> {
501 if self.eat(TokenKind::Otherwise).is_some() {
502 return Ok((QuerySetOperator::Otherwise, None));
503 }
504
505 let operator = if self.eat(TokenKind::Union).is_some() {
506 QuerySetOperator::Union
507 } else if self.eat(TokenKind::Except).is_some() {
508 QuerySetOperator::Except
509 } else if self.eat(TokenKind::Intersect).is_some() {
510 QuerySetOperator::Intersect
511 } else {
512 return Err(self.error_expected(
513 vec![
514 TokenKind::Union,
515 TokenKind::Except,
516 TokenKind::Intersect,
517 TokenKind::Otherwise,
518 ],
519 self.peek_kind(),
520 ));
521 };
522
523 let quantifier = if self.eat(TokenKind::All).is_some() {
524 Some(SetQuantifier::All)
525 } else {
526 self.eat(TokenKind::Distinct);
527 Some(SetQuantifier::Distinct)
528 };
529
530 Ok((operator, quantifier))
531 }
532
533 fn parse_optional_at_schema_clause(&mut self) -> Result<Option<SchemaReference>> {
534 if self.eat(TokenKind::At).is_none() {
535 return Ok(None);
536 }
537 self.expect(TokenKind::Schema)?;
538 Ok(Some(self.parse_schema_reference()?))
539 }
540
541 fn parse_call_statement_or_query(&mut self) -> Result<Statement> {
542 let mut trial = self.clone();
543 let call = trial.parse_call_clause()?;
544 if is_statement_follow(trial.peek_kind()) {
545 *self = trial;
546 Ok(Statement::Call(CallStatement { call }))
547 } else {
548 Ok(Statement::Query(self.parse_query_statement()?))
549 }
550 }
551
552 fn parse_call_statement_or_catalog_or_query(&mut self) -> Result<Statement> {
553 let mut trial = self.clone();
554 let call = trial.parse_call_clause()?;
555 if is_statement_follow(trial.peek_kind()) {
556 *self = trial;
557 return Ok(Statement::Call(CallStatement { call }));
558 }
559
560 if trial.starts_simple_catalog_modifying_statement() {
561 *self = trial;
562 let mut statements = vec![Statement::Call(CallStatement { call })];
563 while self.starts_simple_catalog_modifying_statement() {
564 statements.push(self.parse_simple_catalog_modifying_statement()?);
565 }
566 return Ok(Statement::LinearCatalog(statements));
567 }
568
569 Ok(Statement::Query(self.parse_query_statement()?))
570 }
571
572 fn parse_data_modifying_statement_or_query(&mut self) -> Result<Statement> {
573 let mut trial = self.clone();
574 let statement = match trial.peek_kind() {
575 TokenKind::Insert => Statement::Insert(trial.parse_insert_statement()?),
576 TokenKind::Delete | TokenKind::Detach | TokenKind::Nodetach => {
577 Statement::Delete(trial.parse_delete_statement()?)
578 }
579 TokenKind::Set => Statement::Set(trial.parse_set_statement()?),
580 TokenKind::Remove => Statement::Remove(trial.parse_remove_statement()?),
581 kind => {
582 return Err(trial.error_expected(
583 vec![
584 TokenKind::Insert,
585 TokenKind::Delete,
586 TokenKind::Detach,
587 TokenKind::Nodetach,
588 TokenKind::Set,
589 TokenKind::Remove,
590 ],
591 kind,
592 ));
593 }
594 };
595 if is_statement_follow(trial.peek_kind()) {
596 *self = trial;
597 Ok(statement)
598 } else {
599 Ok(Statement::Query(self.parse_query_statement()?))
600 }
601 }
602
603 fn parse_query_body(&mut self) -> Result<QueryBody> {
604 let mut clauses = Vec::new();
605 while matches!(
606 self.peek_kind(),
607 TokenKind::Use
608 | TokenKind::Optional
609 | TokenKind::Match
610 | TokenKind::Filter
611 | TokenKind::Let
612 | TokenKind::For
613 | TokenKind::Call
614 | TokenKind::Insert
615 | TokenKind::Delete
616 | TokenKind::Detach
617 | TokenKind::Nodetach
618 | TokenKind::Set
619 | TokenKind::Remove
620 | TokenKind::Order
621 | TokenKind::Offset
622 | TokenKind::Skip
623 | TokenKind::Limit
624 | TokenKind::LBrace
625 ) {
626 match self.peek_kind() {
627 TokenKind::Use => {
628 clauses.push(QueryClause::UseGraph(self.parse_use_graph_clause()?));
629 }
630 TokenKind::LBrace => {
631 clauses.push(QueryClause::NestedQuery(Box::new(
632 self.parse_nested_query_specification()?,
633 )));
634 }
635 TokenKind::Optional | TokenKind::Match => {
636 if self.at(TokenKind::Optional) && self.peek_n_kind(1) == Some(TokenKind::Call)
637 {
638 clauses.push(QueryClause::Call(self.parse_call_clause()?));
639 } else {
640 clauses.push(self.parse_match_query_clause()?);
641 }
642 }
643 TokenKind::Filter => {
644 clauses.push(QueryClause::Filter(self.parse_filter_clause()?));
645 }
646 TokenKind::Let => {
647 clauses.push(QueryClause::Let(self.parse_let_clause()?));
648 }
649 TokenKind::For => {
650 clauses.push(QueryClause::For(self.parse_for_clause()?));
651 }
652 TokenKind::Call => {
653 clauses.push(QueryClause::Call(self.parse_call_clause()?));
654 }
655 TokenKind::Insert => {
656 clauses.push(QueryClause::Insert(self.parse_insert_statement()?));
657 }
658 TokenKind::Delete | TokenKind::Detach | TokenKind::Nodetach => {
659 clauses.push(QueryClause::Delete(self.parse_delete_statement()?));
660 }
661 TokenKind::Set => {
662 clauses.push(QueryClause::Set(self.parse_set_statement()?));
663 }
664 TokenKind::Remove => {
665 clauses.push(QueryClause::Remove(self.parse_remove_statement()?));
666 }
667 TokenKind::Order | TokenKind::Offset | TokenKind::Skip | TokenKind::Limit => {
668 clauses.push(QueryClause::OrderByPage(self.parse_order_by_page_clause()?));
669 }
670 _ => unreachable!(),
671 }
672 }
673 if clauses.is_empty()
674 && !matches!(
675 self.peek_kind(),
676 TokenKind::Return | TokenKind::Select | TokenKind::Finish
677 )
678 {
679 return Err(self.error_expected(
680 vec![
681 TokenKind::Match,
682 TokenKind::Optional,
683 TokenKind::Filter,
684 TokenKind::Let,
685 TokenKind::For,
686 TokenKind::Call,
687 TokenKind::Insert,
688 TokenKind::Delete,
689 TokenKind::Detach,
690 TokenKind::Nodetach,
691 TokenKind::Set,
692 TokenKind::Remove,
693 TokenKind::Order,
694 TokenKind::Offset,
695 TokenKind::Skip,
696 TokenKind::Limit,
697 TokenKind::Use,
698 TokenKind::LBrace,
699 TokenKind::Return,
700 TokenKind::Select,
701 TokenKind::Finish,
702 ],
703 self.peek_kind(),
704 ));
705 }
706
707 let result_clause = if !matches!(
708 self.peek_kind(),
709 TokenKind::Return | TokenKind::Select | TokenKind::Finish
710 ) && (clauses.iter().any(is_data_modifying_query_clause)
711 || clauses.iter().any(is_nested_query_clause))
712 && matches!(
713 self.peek_kind(),
714 TokenKind::Semicolon
715 | TokenKind::Eof
716 | TokenKind::Next
717 | TokenKind::RBrace
718 | TokenKind::Union
719 | TokenKind::Except
720 | TokenKind::Intersect
721 | TokenKind::Otherwise
722 ) {
723 let inherit = clauses.last().is_some_and(is_nested_query_clause)
726 && !clauses.iter().any(is_data_modifying_query_clause);
727 ResultClause {
728 kind: if inherit {
729 ResultKind::Return
730 } else {
731 ResultKind::Finish
732 },
733 quantifier: None,
734 distinct: false,
735 items: if inherit {
736 vec![ResultItem {
737 expr: Expr::Wildcard,
738 alias: None,
739 }]
740 } else {
741 Vec::new()
742 },
743 }
744 } else {
745 self.parse_result_clause()?
746 };
747 if result_clause.kind == ResultKind::Finish {
748 return Ok(QueryBody {
749 clauses,
750 result_clause,
751 select_from: Vec::new(),
752 select_query: None,
753 select_where: None,
754 group_by: Vec::new(),
755 empty_grouping_set: false,
756 having: None,
757 order_by: Vec::new(),
758 offset: None,
759 limit: None,
760 });
761 }
762 if result_clause.kind == ResultKind::Return
763 && result_clause_has_wildcard(&result_clause)
764 && !query_clauses_have_non_unit_working_table(&clauses)
765 {
766 return Err(Error::Message {
767 offset: self.peek().offset,
768 message: "RETURN * requires a non-unit incoming working table".to_owned(),
769 });
770 }
771 let (select_from, select_query) =
772 if result_clause.kind == ResultKind::Select && self.eat(TokenKind::From).is_some() {
773 self.parse_select_from_clause()?
774 } else {
775 (Vec::new(), None)
776 };
777 if result_clause.kind == ResultKind::Select
778 && result_clause_has_wildcard(&result_clause)
779 && select_from.is_empty()
780 && select_query.is_none()
781 {
782 return Err(Error::Message {
783 offset: self.peek().offset,
784 message: "SELECT * requires a FROM clause".to_owned(),
785 });
786 }
787 let select_where =
788 if result_clause.kind == ResultKind::Select && self.eat(TokenKind::Where).is_some() {
789 Some(self.parse_expr()?)
790 } else {
791 None
792 };
793 let mut group_by = Vec::new();
794 let mut empty_grouping_set = false;
795 if self.eat(TokenKind::Group).is_some() {
796 self.expect(TokenKind::By)?;
797 if self.eat(TokenKind::LParen).is_some() {
798 self.expect(TokenKind::RParen)?;
799 empty_grouping_set = true;
800 } else {
801 loop {
802 group_by.push(self.parse_grouping_element()?);
803 if self.eat(TokenKind::Comma).is_none() {
804 break;
805 }
806 }
807 }
808 }
809 if result_clause_has_wildcard(&result_clause)
810 && (!group_by.is_empty() || empty_grouping_set)
811 {
812 return Err(Error::Message {
813 offset: self.peek().offset,
814 message: "asterisk result cannot contain GROUP BY".to_owned(),
815 });
816 }
817 let having = if self.at(TokenKind::Having) {
818 if result_clause.kind != ResultKind::Select {
819 return Err(Error::Message {
820 offset: self.peek().offset,
821 message: "HAVING is only valid in SELECT statements".to_owned(),
822 });
823 }
824 self.expect(TokenKind::Having)?;
825 Some(self.parse_expr()?)
826 } else {
827 None
828 };
829 let page = if matches!(
830 self.peek_kind(),
831 TokenKind::Order | TokenKind::Offset | TokenKind::Skip | TokenKind::Limit
832 ) {
833 self.parse_order_by_page_clause()?
834 } else {
835 OrderByPageClause {
836 order_by: Vec::new(),
837 offset: None,
838 limit: None,
839 }
840 };
841 Ok(QueryBody {
842 clauses,
843 result_clause,
844 select_from,
845 select_query,
846 select_where,
847 group_by,
848 empty_grouping_set,
849 having,
850 order_by: page.order_by,
851 offset: page.offset,
852 limit: page.limit,
853 })
854 }
855
856 fn parse_order_by_page_clause(&mut self) -> Result<OrderByPageClause> {
857 let order_by = if self.eat(TokenKind::Order).is_some() {
858 self.expect(TokenKind::By)?;
859 self.parse_order_by_list()?
860 } else {
861 Vec::new()
862 };
863 let offset = if self.eat(TokenKind::Offset).is_some() || self.eat(TokenKind::Skip).is_some()
864 {
865 Some(self.parse_unsigned_integer_specification()?)
866 } else {
867 None
868 };
869 let limit = if self.eat(TokenKind::Limit).is_some() {
870 Some(self.parse_unsigned_integer_specification()?)
871 } else {
872 None
873 };
874 if order_by.is_empty() && offset.is_none() && limit.is_none() {
875 return Err(self.error_expected(
876 vec![
877 TokenKind::Order,
878 TokenKind::Offset,
879 TokenKind::Skip,
880 TokenKind::Limit,
881 ],
882 self.peek_kind(),
883 ));
884 }
885 Ok(OrderByPageClause {
886 order_by,
887 offset,
888 limit,
889 })
890 }
891
892 fn parse_order_by_list(&mut self) -> Result<Vec<OrderByItem>> {
893 let mut order_by = Vec::new();
894 loop {
895 let expr = self.parse_expr()?;
896 let direction =
897 if self.eat(TokenKind::Asc).is_some() || self.eat(TokenKind::Ascending).is_some() {
898 Some(SortDirection::Asc)
899 } else if self.eat(TokenKind::Desc).is_some()
900 || self.eat(TokenKind::Descending).is_some()
901 {
902 Some(SortDirection::Desc)
903 } else {
904 None
905 };
906 let null_ordering = if self.eat(TokenKind::Nulls).is_some() {
907 if self.eat(TokenKind::First).is_some() {
908 Some(NullOrdering::First)
909 } else if self.eat(TokenKind::Last).is_some() {
910 Some(NullOrdering::Last)
911 } else {
912 return Err(self.error_expected(
913 vec![TokenKind::First, TokenKind::Last],
914 self.peek_kind(),
915 ));
916 }
917 } else {
918 None
919 };
920 order_by.push(OrderByItem {
921 expr,
922 direction,
923 null_ordering,
924 });
925 if self.eat(TokenKind::Comma).is_none() {
926 break;
927 }
928 }
929 Ok(order_by)
930 }
931
932 fn parse_grouping_element(&mut self) -> Result<Expr> {
933 let offset = self.peek().offset;
934 let identifier = self.parse_identifier()?;
935 if matches!(
936 self.peek_kind(),
937 TokenKind::Dot
938 | TokenKind::Plus
939 | TokenKind::Minus
940 | TokenKind::Star
941 | TokenKind::Slash
942 | TokenKind::Percent
943 | TokenKind::LParen
944 | TokenKind::LBracket
945 ) {
946 return Err(Error::Message {
947 offset,
948 message: "GROUP BY elements must be binding variable references".to_owned(),
949 });
950 }
951 Ok(Expr::Identifier(identifier))
952 }
953
954 fn parse_select_from_clause(
955 &mut self,
956 ) -> Result<(Vec<SelectGraphMatch>, Option<SelectQuerySpecification>)> {
957 if self.at(TokenKind::LBrace) {
958 return Ok((
959 Vec::new(),
960 Some(SelectQuerySpecification {
961 graph: None,
962 query: Box::new(self.parse_nested_query_specification()?),
963 }),
964 ));
965 }
966
967 let graph = self.parse_graph_expression()?;
968 if self.at(TokenKind::LBrace) {
969 return Ok((
970 Vec::new(),
971 Some(SelectQuerySpecification {
972 graph: Some(graph),
973 query: Box::new(self.parse_nested_query_specification()?),
974 }),
975 ));
976 }
977
978 let match_clause = self.parse_match_clause()?;
979 let mut items = vec![SelectGraphMatch {
980 graph,
981 match_clause,
982 }];
983 while self.eat(TokenKind::Comma).is_some() {
984 let graph = self.parse_graph_expression()?;
985 let match_clause = self.parse_match_clause()?;
986 items.push(SelectGraphMatch {
987 graph,
988 match_clause,
989 });
990 }
991 Ok((items, None))
992 }
993
994 fn parse_nested_query_specification(&mut self) -> Result<QueryStatement> {
995 self.enter()?;
996 let query = self.parse_braced_query();
997 self.exit();
998 query
999 }
1000
1001 fn parse_braced_query(&mut self) -> Result<QueryStatement> {
1002 self.expect(TokenKind::LBrace)?;
1003 let query = self.parse_query_statement()?;
1004 self.expect(TokenKind::RBrace)?;
1005 Ok(query)
1006 }
1007
1008 fn parse_use_graph_clause(&mut self) -> Result<GraphExpression> {
1009 self.expect(TokenKind::Use)?;
1010 if self.eat(TokenKind::Property).is_some() {
1011 self.expect(TokenKind::Graph)?;
1012 } else {
1013 self.eat(TokenKind::Graph);
1014 }
1015 self.parse_graph_expression()
1016 }
1017
1018 fn parse_filter_clause(&mut self) -> Result<FilterClause> {
1019 self.expect(TokenKind::Filter)?;
1020 self.eat(TokenKind::Where);
1021 Ok(FilterClause {
1022 predicate: self.parse_expr()?,
1023 })
1024 }
1025
1026 fn parse_let_clause(&mut self) -> Result<LetClause> {
1027 self.expect(TokenKind::Let)?;
1028 let mut items = Vec::new();
1029 loop {
1030 let item_offset = self.peek().offset;
1031 let item = self.parse_let_item()?;
1032 self.push_let_item(&mut items, item, item_offset)?;
1033 if self.eat(TokenKind::Comma).is_none() {
1034 break;
1035 }
1036 }
1037 Ok(LetClause { items })
1038 }
1039
1040 fn parse_let_item(&mut self) -> Result<LetItem> {
1041 self.parse_let_item_with_in_delimiter(false)
1042 }
1043
1044 fn parse_let_item_with_in_delimiter(&mut self, stop_at_in: bool) -> Result<LetItem> {
1045 if self.eat(TokenKind::Value).is_some() {
1046 let name = self.parse_identifier()?;
1047 let (typed, value_type) = self.parse_optional_definition_value_type()?;
1048 self.expect(TokenKind::Eq)?;
1049 return Ok(LetItem {
1050 name,
1051 typed,
1052 value_type,
1053 value: self.parse_expr_for_let_item(stop_at_in)?,
1054 });
1055 }
1056 let name = self.parse_identifier()?;
1057 self.expect(TokenKind::Eq)?;
1058 Ok(LetItem {
1059 name,
1060 typed: false,
1061 value_type: None,
1062 value: self.parse_expr_for_let_item(stop_at_in)?,
1063 })
1064 }
1065
1066 fn parse_expr_for_let_item(&mut self, stop_at_in: bool) -> Result<Expr> {
1067 if !stop_at_in {
1068 return self.parse_expr();
1069 }
1070 let previous = self.stop_in_as_delimiter;
1071 self.stop_in_as_delimiter = true;
1072 let result = self.parse_expr();
1073 self.stop_in_as_delimiter = previous;
1074 result
1075 }
1076
1077 fn parse_for_clause(&mut self) -> Result<ForClause> {
1078 self.expect(TokenKind::For)?;
1079 let variable = self.parse_identifier()?;
1080 self.expect(TokenKind::In)?;
1081 let source = self.parse_expr()?;
1082 let ordinality_or_offset = if self.eat(TokenKind::With).is_some() {
1083 let kind = if self.eat(TokenKind::Ordinality).is_some() {
1084 ForOrdinalityOrOffsetKind::Ordinality
1085 } else if self.eat(TokenKind::Offset).is_some() {
1086 ForOrdinalityOrOffsetKind::Offset
1087 } else {
1088 return Err(self.error_expected(
1089 vec![TokenKind::Ordinality, TokenKind::Offset],
1090 self.peek_kind(),
1091 ));
1092 };
1093 let variable_offset = self.peek().offset;
1094 let ordinality_variable = self.parse_identifier()?;
1095 if ordinality_variable
1096 .value
1097 .eq_ignore_ascii_case(&variable.value)
1098 {
1099 return Err(Error::Message {
1100 offset: variable_offset,
1101 message: format!(
1102 "for ordinality or offset variable '{}' duplicates item alias",
1103 ordinality_variable.value
1104 ),
1105 });
1106 }
1107 Some(ForOrdinalityOrOffset {
1108 kind,
1109 variable: ordinality_variable,
1110 })
1111 } else {
1112 None
1113 };
1114 Ok(ForClause {
1115 variable,
1116 source,
1117 ordinality_or_offset,
1118 })
1119 }
1120
1121 fn parse_call_clause(&mut self) -> Result<CallClause> {
1122 let optional = self.eat(TokenKind::Optional).is_some();
1123 self.expect(TokenKind::Call)?;
1124 let call = if matches!(self.peek_kind(), TokenKind::LBrace | TokenKind::LParen) {
1125 ProcedureCall::Inline(self.parse_inline_procedure_call()?)
1126 } else {
1127 let procedure = self.parse_procedure_reference()?;
1128 self.expect(TokenKind::LParen)?;
1129 let args = self.parse_procedure_argument_list()?;
1130 let yield_clause = if self.eat(TokenKind::Yield).is_some() {
1131 Some(self.parse_yield_clause_body(true)?)
1132 } else {
1133 None
1134 };
1135 return Ok(CallClause {
1136 optional,
1137 call: ProcedureCall::Named { procedure, args },
1138 yield_clause,
1139 });
1140 };
1141 Ok(CallClause {
1142 optional,
1143 call,
1144 yield_clause: None,
1145 })
1146 }
1147
1148 fn parse_procedure_argument_list(&mut self) -> Result<Vec<Expr>> {
1149 let mut args = Vec::new();
1150 if !self.at(TokenKind::RParen) {
1151 loop {
1152 args.push(self.parse_expr()?);
1153 if self.eat(TokenKind::Comma).is_none() {
1154 break;
1155 }
1156 }
1157 }
1158 self.expect(TokenKind::RParen)?;
1159 Ok(args)
1160 }
1161
1162 fn parse_inline_procedure_call(&mut self) -> Result<InlineProcedureCall> {
1163 let variable_scope = if self.at(TokenKind::LParen) {
1164 Some(self.parse_variable_scope_clause()?)
1165 } else {
1166 None
1167 };
1168 self.expect(TokenKind::LBrace)?;
1169 let body = self.parse_program_body(TokenKind::RBrace)?;
1170 if body.statements.is_empty() {
1171 return Err(self.error_expected(
1172 vec![
1173 TokenKind::Use,
1174 TokenKind::At,
1175 TokenKind::Match,
1176 TokenKind::Optional,
1177 TokenKind::Filter,
1178 TokenKind::Let,
1179 TokenKind::For,
1180 TokenKind::Call,
1181 TokenKind::Return,
1182 TokenKind::Select,
1183 TokenKind::Finish,
1184 TokenKind::Start,
1185 TokenKind::Commit,
1186 TokenKind::Rollback,
1187 TokenKind::Insert,
1188 TokenKind::Delete,
1189 TokenKind::Set,
1190 TokenKind::Session,
1191 TokenKind::Reset,
1192 TokenKind::Close,
1193 TokenKind::Remove,
1194 TokenKind::Create,
1195 TokenKind::Drop,
1196 ],
1197 self.peek_kind(),
1198 ));
1199 }
1200 self.expect(TokenKind::RBrace)?;
1201 Ok(InlineProcedureCall {
1202 variable_scope,
1203 body: Box::new(body),
1204 })
1205 }
1206
1207 fn parse_variable_scope_clause(&mut self) -> Result<Vec<Identifier>> {
1208 self.expect(TokenKind::LParen)?;
1209 let mut variables = Vec::new();
1210 if !self.at(TokenKind::RParen) {
1211 loop {
1212 let offset = self.peek().offset;
1213 let variable = self.parse_identifier()?;
1214 if variables.iter().any(|existing: &Identifier| {
1215 existing.value.eq_ignore_ascii_case(&variable.value)
1216 }) {
1217 return Err(Error::Message {
1218 offset,
1219 message: format!(
1220 "duplicate variable '{}' in variable scope",
1221 variable.value
1222 ),
1223 });
1224 }
1225 variables.push(variable);
1226 if self.eat(TokenKind::Comma).is_none() {
1227 break;
1228 }
1229 }
1230 }
1231 self.expect(TokenKind::RParen)?;
1232 Ok(variables)
1233 }
1234
1235 fn parse_match_query_clause(&mut self) -> Result<QueryClause> {
1236 if self.at(TokenKind::Optional)
1237 && matches!(
1238 self.peek_n_kind(1),
1239 Some(TokenKind::LBrace | TokenKind::LParen)
1240 )
1241 {
1242 self.expect(TokenKind::Optional)?;
1243 let closing = if self.eat(TokenKind::LBrace).is_some() {
1244 TokenKind::RBrace
1245 } else {
1246 self.expect(TokenKind::LParen)?;
1247 TokenKind::RParen
1248 };
1249 let matches = self.parse_match_statement_block(closing)?;
1250 self.expect(closing)?;
1251 return Ok(QueryClause::OptionalMatchBlock(matches));
1252 }
1253 Ok(QueryClause::Match(self.parse_match_clause()?))
1254 }
1255
1256 fn parse_match_clause(&mut self) -> Result<MatchClause> {
1257 let optional = self.eat(TokenKind::Optional).is_some();
1258 self.expect(TokenKind::Match)?;
1259 let mode = self.parse_optional_match_mode()?;
1260 let patterns = self.parse_pattern_list()?;
1261 let keep = if self.eat(TokenKind::Keep).is_some() {
1262 Some(self.parse_required_path_pattern_prefix()?)
1263 } else {
1264 None
1265 };
1266 let where_clause = if self.eat(TokenKind::Where).is_some() {
1267 Some(self.parse_expr()?)
1268 } else {
1269 None
1270 };
1271 let yield_clause = if self.eat(TokenKind::Yield).is_some() {
1272 Some(self.parse_yield_clause_body(false)?)
1273 } else {
1274 None
1275 };
1276 if let Some(yield_clause) = &yield_clause {
1277 validate_graph_pattern_yield_clause(&patterns, yield_clause, self.peek().offset)?;
1278 }
1279 Ok(MatchClause {
1280 optional,
1281 mode,
1282 patterns,
1283 keep,
1284 where_clause,
1285 yield_clause,
1286 })
1287 }
1288
1289 fn parse_optional_match_mode(&mut self) -> Result<Option<MatchMode>> {
1290 if self.eat(TokenKind::Repeatable).is_some() {
1291 let bindings = if self.eat(TokenKind::Element).is_some() {
1292 self.eat(TokenKind::Bindings).is_some()
1293 } else if self.eat(TokenKind::Elements).is_some() {
1294 false
1295 } else {
1296 return Err(self.error_expected(
1297 vec![TokenKind::Element, TokenKind::Elements],
1298 self.peek_kind(),
1299 ));
1300 };
1301 return Ok(Some(MatchMode::RepeatableElements { bindings }));
1302 }
1303
1304 if self.eat(TokenKind::Different).is_some() {
1305 let bindings = if self.eat(TokenKind::Edge).is_some()
1306 || self.eat(TokenKind::Relationship).is_some()
1307 {
1308 self.eat(TokenKind::Bindings).is_some()
1309 } else if self.eat(TokenKind::Edges).is_some()
1310 || self.eat(TokenKind::Relationships).is_some()
1311 {
1312 false
1313 } else {
1314 return Err(self.error_expected(
1315 vec![
1316 TokenKind::Edge,
1317 TokenKind::Relationship,
1318 TokenKind::Edges,
1319 TokenKind::Relationships,
1320 ],
1321 self.peek_kind(),
1322 ));
1323 };
1324 return Ok(Some(MatchMode::DifferentEdges { bindings }));
1325 }
1326
1327 Ok(None)
1328 }
1329
1330 fn parse_yield_clause_body(&mut self, allow_aliases: bool) -> Result<YieldClause> {
1331 let mut items = Vec::new();
1332 let mut output_names = Vec::new();
1333 loop {
1334 let name_offset = self.peek().offset;
1335 let name = self.parse_identifier()?;
1336 let alias = if allow_aliases && self.eat(TokenKind::As).is_some() {
1337 let alias_offset = self.peek().offset;
1338 let alias = self.parse_identifier()?;
1339 if output_names.iter().any(|output_name: &Identifier| {
1340 output_name.value.eq_ignore_ascii_case(&alias.value)
1341 }) {
1342 return Err(Error::Message {
1343 offset: alias_offset,
1344 message: format!("duplicate yield output '{}'", alias.value),
1345 });
1346 }
1347 output_names.push(alias.clone());
1348 Some(alias)
1349 } else {
1350 if output_names.iter().any(|output_name: &Identifier| {
1351 output_name.value.eq_ignore_ascii_case(&name.value)
1352 }) {
1353 return Err(Error::Message {
1354 offset: name_offset,
1355 message: format!("duplicate yield output '{}'", name.value),
1356 });
1357 }
1358 output_names.push(name.clone());
1359 None
1360 };
1361 items.push(YieldItem::Item { name, alias });
1362 if self.eat(TokenKind::Comma).is_none() {
1363 break;
1364 }
1365 }
1366 Ok(YieldClause { items })
1367 }
1368
1369 fn parse_result_clause(&mut self) -> Result<ResultClause> {
1370 let kind = if self.eat(TokenKind::Return).is_some() {
1371 ResultKind::Return
1372 } else if self.eat(TokenKind::Select).is_some() {
1373 ResultKind::Select
1374 } else if self.eat(TokenKind::Finish).is_some() {
1375 return Ok(ResultClause {
1376 kind: ResultKind::Finish,
1377 quantifier: None,
1378 distinct: false,
1379 items: Vec::new(),
1380 });
1381 } else {
1382 return Err(self.error_expected(
1383 vec![TokenKind::Return, TokenKind::Select, TokenKind::Finish],
1384 self.peek_kind(),
1385 ));
1386 };
1387 if kind == ResultKind::Return && self.at(TokenKind::No) {
1388 let offset = self.peek().offset;
1389 self.bump();
1390 return Err(Error::Message {
1391 offset,
1392 message: "RETURN NO BINDINGS is not user-visible standard GQL syntax".to_owned(),
1393 });
1394 }
1395 let quantifier = if self.eat(TokenKind::Distinct).is_some() {
1396 Some(SetQuantifier::Distinct)
1397 } else {
1398 self.eat(TokenKind::All);
1399 Some(SetQuantifier::All)
1400 };
1401 let distinct = quantifier == Some(SetQuantifier::Distinct);
1402 let mut items = Vec::new();
1403 let mut output_names = Vec::new();
1404 loop {
1405 let item_offset = self.peek().offset;
1406 let expr = self.parse_expr()?;
1407 let alias = if self.eat(TokenKind::As).is_some() {
1408 Some(self.parse_identifier()?)
1409 } else if let Expr::Identifier(identifier) = &expr {
1410 Some(identifier.clone())
1411 } else {
1412 None
1413 };
1414 if alias.is_none() && !matches!(expr, Expr::Identifier(_) | Expr::Wildcard) {
1415 return Err(Error::Message {
1416 offset: self.peek().offset,
1417 message: "non-binding result item requires AS alias".to_owned(),
1418 });
1419 }
1420 if let Some(output_name) = &alias {
1421 if output_names.iter().any(|existing: &Identifier| {
1422 existing.value.eq_ignore_ascii_case(&output_name.value)
1423 }) {
1424 return Err(Error::Message {
1425 offset: item_offset,
1426 message: format!("duplicate result output '{}'", output_name.value),
1427 });
1428 }
1429 output_names.push(output_name.clone());
1430 }
1431 items.push(ResultItem { expr, alias });
1432 if self.eat(TokenKind::Comma).is_none() {
1433 break;
1434 }
1435 }
1436 Ok(ResultClause {
1437 kind,
1438 quantifier,
1439 distinct,
1440 items,
1441 })
1442 }
1443
1444 fn parse_insert_statement(&mut self) -> Result<InsertStatement> {
1445 self.expect(TokenKind::Insert)?;
1446 let patterns = self.parse_insert_pattern_list()?;
1447 validate_insert_graph_pattern_variables(&patterns, self.peek().offset)?;
1448 Ok(InsertStatement { patterns })
1449 }
1450
1451 fn parse_session_set_command(&mut self) -> Result<SessionSetCommand> {
1452 self.expect(TokenKind::Set)?;
1453 let target = if self.eat(TokenKind::Schema).is_some() {
1454 SessionSetTarget::Schema(self.parse_schema_reference()?)
1455 } else if self.eat(TokenKind::Graph).is_some() {
1456 if self.starts_session_set_graph_parameter() {
1457 SessionSetTarget::GraphParameter(self.parse_session_set_graph_parameter(false)?)
1458 } else {
1459 SessionSetTarget::Graph(self.parse_graph_expression()?)
1460 }
1461 } else if self.eat(TokenKind::Property).is_some() {
1462 self.expect(TokenKind::Graph)?;
1463 if self.starts_session_set_graph_parameter() {
1464 SessionSetTarget::GraphParameter(self.parse_session_set_graph_parameter(true)?)
1465 } else {
1466 SessionSetTarget::Graph(self.parse_graph_expression()?)
1467 }
1468 } else if self.at(TokenKind::Binding) || self.at(TokenKind::Table) {
1469 let binding = self.eat(TokenKind::Binding).is_some();
1470 self.expect(TokenKind::Table)?;
1471 SessionSetTarget::BindingTableParameter(
1472 self.parse_session_set_binding_table_parameter(binding)?,
1473 )
1474 } else if self.eat(TokenKind::Time).is_some() {
1475 self.expect(TokenKind::Zone)?;
1476 let value = if self.is_character_string_token(self.peek_kind()) {
1477 self.parse_character_string_literal_expr()?
1478 } else {
1479 self.parse_expr()?
1480 };
1481 SessionSetTarget::TimeZone(value)
1482 } else if self.eat(TokenKind::Value).is_some() {
1483 SessionSetTarget::ValueParameter(self.parse_session_set_value_parameter()?)
1484 } else {
1485 return Err(self.error_expected(
1486 vec![
1487 TokenKind::Schema,
1488 TokenKind::Graph,
1489 TokenKind::Property,
1490 TokenKind::Binding,
1491 TokenKind::Table,
1492 TokenKind::Time,
1493 TokenKind::Value,
1494 ],
1495 self.peek_kind(),
1496 ));
1497 };
1498 Ok(SessionSetCommand { target })
1499 }
1500
1501 fn starts_session_set_graph_parameter(&self) -> bool {
1502 let mut trial = self.clone();
1503 trial
1504 .parse_session_set_graph_parameter(false)
1505 .is_ok_and(|_| is_statement_follow(trial.peek_kind()))
1506 }
1507
1508 fn parse_session_set_graph_parameter(
1509 &mut self,
1510 property_graph: bool,
1511 ) -> Result<SessionSetGraphParameter> {
1512 let if_not_exists = self.parse_if_not_exists()?;
1513 let name = self.parse_parameter_name()?;
1514 let (typed, value_type) = self.parse_optional_definition_value_type()?;
1515 self.expect(TokenKind::Eq)?;
1516 Ok(SessionSetGraphParameter {
1517 property_graph,
1518 if_not_exists,
1519 name,
1520 typed,
1521 value_type,
1522 initializer: self.parse_graph_expression()?,
1523 })
1524 }
1525
1526 fn parse_session_set_binding_table_parameter(
1527 &mut self,
1528 binding: bool,
1529 ) -> Result<SessionSetBindingTableParameter> {
1530 let if_not_exists = self.parse_if_not_exists()?;
1531 let name = self.parse_parameter_name()?;
1532 let (typed, value_type) = self.parse_optional_definition_value_type()?;
1533 self.expect(TokenKind::Eq)?;
1534 Ok(SessionSetBindingTableParameter {
1535 binding,
1536 if_not_exists,
1537 name,
1538 typed,
1539 value_type,
1540 initializer: self.parse_binding_table_expression()?,
1541 })
1542 }
1543
1544 fn parse_session_set_value_parameter(&mut self) -> Result<SessionSetValueParameter> {
1545 let if_not_exists = self.parse_if_not_exists()?;
1546 let name = self.parse_parameter_name()?;
1547 let (typed, value_type) = if self.at(TokenKind::Eq) {
1548 (false, None)
1549 } else {
1550 let typed = self.parse_optional_typed_marker()?;
1551 let value_type = self.parse_value_type()?;
1552 (typed, Some(value_type))
1553 };
1554 self.expect(TokenKind::Eq)?;
1555 let initializer = self.parse_expr()?;
1556 Ok(SessionSetValueParameter {
1557 if_not_exists,
1558 name,
1559 typed,
1560 value_type,
1561 initializer,
1562 })
1563 }
1564
1565 fn parse_parameter_name(&mut self) -> Result<String> {
1566 if self.at(TokenKind::Parameter) {
1567 let token = self.bump();
1568 Ok(parameter_name(&token.text))
1569 } else {
1570 Ok(self.parse_identifier()?.value)
1571 }
1572 }
1573
1574 fn parse_session_prefixed_command(&mut self) -> Result<Statement> {
1575 self.expect(TokenKind::Session)?;
1576 match self.peek_kind() {
1577 TokenKind::Set => Ok(Statement::SessionSet(self.parse_session_set_command()?)),
1578 TokenKind::Reset => Ok(Statement::SessionReset(self.parse_session_reset_command()?)),
1579 TokenKind::Close => {
1580 self.bump();
1581 Ok(Statement::SessionClose(SessionCloseCommand))
1582 }
1583 kind => Err(self.error_expected(
1584 vec![TokenKind::Set, TokenKind::Reset, TokenKind::Close],
1585 kind,
1586 )),
1587 }
1588 }
1589
1590 fn parse_session_reset_command(&mut self) -> Result<SessionResetCommand> {
1591 self.expect(TokenKind::Reset)?;
1592 let target = if matches!(self.peek_kind(), TokenKind::Semicolon | TokenKind::Eof) {
1593 SessionResetTarget::AllCharacteristics
1594 } else if self.eat(TokenKind::All).is_some() {
1595 if self.eat(TokenKind::Parameters).is_some() {
1596 SessionResetTarget::AllParameters
1597 } else if self.eat(TokenKind::Characteristics).is_some() {
1598 SessionResetTarget::AllCharacteristics
1599 } else {
1600 return Err(self.error_expected(
1601 vec![TokenKind::Parameters, TokenKind::Characteristics],
1602 self.peek_kind(),
1603 ));
1604 }
1605 } else if self.eat(TokenKind::Parameters).is_some() {
1606 SessionResetTarget::AllParameters
1607 } else if self.eat(TokenKind::Characteristics).is_some() {
1608 SessionResetTarget::AllCharacteristics
1609 } else if self.eat(TokenKind::Schema).is_some() {
1610 SessionResetTarget::Schema
1611 } else if self.eat(TokenKind::Property).is_some() {
1612 self.expect(TokenKind::Graph)?;
1613 SessionResetTarget::Graph
1614 } else if self.eat(TokenKind::Graph).is_some() {
1615 SessionResetTarget::Graph
1616 } else if self.eat(TokenKind::Time).is_some() {
1617 self.expect(TokenKind::Zone)?;
1618 SessionResetTarget::TimeZone
1619 } else if self.eat(TokenKind::ParameterKeyword).is_some()
1620 || matches!(self.peek_kind(), TokenKind::Parameter)
1621 {
1622 SessionResetTarget::Parameter(self.parse_parameter_name()?)
1623 } else {
1624 return Err(self.error_expected(
1625 vec![
1626 TokenKind::All,
1627 TokenKind::Parameters,
1628 TokenKind::Characteristics,
1629 TokenKind::Schema,
1630 TokenKind::Property,
1631 TokenKind::Graph,
1632 TokenKind::Time,
1633 TokenKind::ParameterKeyword,
1634 TokenKind::Parameter,
1635 ],
1636 self.peek_kind(),
1637 ));
1638 };
1639 Ok(SessionResetCommand { target })
1640 }
1641
1642 fn parse_start_transaction_statement(&mut self) -> Result<StartTransactionStatement> {
1643 self.expect(TokenKind::Start)?;
1644 self.expect(TokenKind::Transaction)?;
1645 let mut access_mode = None;
1646
1647 if self.at(TokenKind::Isolation) {
1648 return Err(Error::Message {
1649 offset: self.peek().offset,
1650 message: "ISOLATION LEVEL is not a GQL transaction characteristic".to_owned(),
1651 });
1652 }
1653
1654 if self.eat(TokenKind::Read).is_some() {
1655 access_mode = if self.eat(TokenKind::Only).is_some() {
1656 Some(TransactionAccessMode::ReadOnly)
1657 } else {
1658 self.expect(TokenKind::Write)?;
1659 Some(TransactionAccessMode::ReadWrite)
1660 };
1661 if self.eat(TokenKind::Comma).is_some() {
1662 if self.at(TokenKind::Read) {
1663 return Err(Error::Message {
1664 offset: self.peek().offset,
1665 message: "transaction characteristics must contain exactly one access mode"
1666 .to_owned(),
1667 });
1668 }
1669 if self.at(TokenKind::Isolation) {
1670 return Err(Error::Message {
1671 offset: self.peek().offset,
1672 message: "ISOLATION LEVEL is not a GQL transaction characteristic"
1673 .to_owned(),
1674 });
1675 }
1676 return Err(Error::Message {
1677 offset: self.peek().offset,
1678 message: "implementation-defined transaction modes are not supported"
1679 .to_owned(),
1680 });
1681 }
1682 }
1683
1684 Ok(StartTransactionStatement {
1685 access_mode,
1686 isolation_level: None,
1687 })
1688 }
1689
1690 fn parse_commit_statement(&mut self) -> Result<CommitStatement> {
1691 self.expect(TokenKind::Commit)?;
1692 Ok(CommitStatement)
1693 }
1694
1695 fn parse_rollback_statement(&mut self) -> Result<RollbackStatement> {
1696 self.expect(TokenKind::Rollback)?;
1697 Ok(RollbackStatement)
1698 }
1699
1700 fn parse_delete_statement(&mut self) -> Result<DeleteStatement> {
1701 let detach = if self.eat(TokenKind::Detach).is_some() {
1702 self.expect(TokenKind::Delete)?;
1703 true
1704 } else {
1705 self.eat(TokenKind::Nodetach);
1706 self.expect(TokenKind::Delete)?;
1707 false
1708 };
1709 let mut items = Vec::new();
1710 loop {
1711 items.push(self.parse_expr()?);
1712 if self.eat(TokenKind::Comma).is_none() {
1713 break;
1714 }
1715 }
1716 Ok(DeleteStatement { detach, items })
1717 }
1718
1719 fn parse_set_statement(&mut self) -> Result<SetStatement> {
1720 self.expect(TokenKind::Set)?;
1721 let mut items = Vec::new();
1722 loop {
1723 let offset = self.peek().offset;
1724 let item = self.parse_set_item()?;
1725 validate_set_item_conflicts(&items, &item, offset)?;
1726 items.push(item);
1727 if self.eat(TokenKind::Comma).is_none() {
1728 break;
1729 }
1730 }
1731 Ok(SetStatement { items })
1732 }
1733
1734 fn parse_set_item(&mut self) -> Result<SetItem> {
1735 let variable = self.parse_identifier()?;
1736 if self.eat(TokenKind::Dot).is_some() {
1737 let property = self.parse_identifier()?;
1738 self.expect(TokenKind::Eq)?;
1739 return Ok(SetItem::Property {
1740 target: Expr::Property {
1741 base: Box::new(Expr::Identifier(variable)),
1742 key: property,
1743 },
1744 value: self.parse_expr()?,
1745 });
1746 }
1747 if self.eat(TokenKind::Eq).is_some() {
1748 return Ok(SetItem::AllProperties {
1749 variable,
1750 properties: self.parse_map_literal()?,
1751 });
1752 }
1753 if self.eat(TokenKind::Colon).is_some() || self.eat(TokenKind::Is).is_some() {
1754 return Ok(SetItem::Label {
1755 variable,
1756 label: self.parse_identifier()?,
1757 });
1758 }
1759 Err(self.error_expected(
1760 vec![
1761 TokenKind::Dot,
1762 TokenKind::Eq,
1763 TokenKind::Colon,
1764 TokenKind::Is,
1765 ],
1766 self.peek_kind(),
1767 ))
1768 }
1769
1770 fn parse_remove_statement(&mut self) -> Result<RemoveStatement> {
1771 self.expect(TokenKind::Remove)?;
1772 let mut items = Vec::new();
1773 loop {
1774 let variable = self.parse_identifier()?;
1775 let item = if self.eat(TokenKind::Dot).is_some() {
1776 let property = self.parse_identifier()?;
1777 RemoveItem::Property(Expr::Property {
1778 base: Box::new(Expr::Identifier(variable)),
1779 key: property,
1780 })
1781 } else if self.eat(TokenKind::Colon).is_some() || self.eat(TokenKind::Is).is_some() {
1782 RemoveItem::Label {
1783 variable,
1784 label: self.parse_identifier()?,
1785 }
1786 } else {
1787 return Err(self.error_expected(
1788 vec![TokenKind::Dot, TokenKind::Colon, TokenKind::Is],
1789 self.peek_kind(),
1790 ));
1791 };
1792 items.push(item);
1793 if self.eat(TokenKind::Comma).is_none() {
1794 break;
1795 }
1796 }
1797 Ok(RemoveStatement { items })
1798 }
1799
1800 fn parse_create_statement(&mut self) -> Result<Statement> {
1801 self.expect(TokenKind::Create)?;
1802 let or_replace = if self.eat(TokenKind::Or).is_some() {
1803 self.expect(TokenKind::Replace)?;
1804 true
1805 } else {
1806 false
1807 };
1808 let property_graph = self.eat(TokenKind::Property).is_some();
1809 match self.peek_kind() {
1810 TokenKind::Graph => {
1811 self.bump();
1812 if self.eat(TokenKind::Type).is_some() {
1813 let if_not_exists = if or_replace {
1814 false
1815 } else {
1816 self.parse_if_not_exists()?
1817 };
1818 let name = self.parse_graph_type_name()?;
1819 let source = self.parse_create_graph_type_source()?;
1820 Ok(Statement::CreateGraphType(CreateGraphTypeStatement {
1821 if_not_exists,
1822 or_replace,
1823 property_graph,
1824 name,
1825 source,
1826 }))
1827 } else {
1828 let if_not_exists = if or_replace {
1829 false
1830 } else {
1831 self.parse_if_not_exists()?
1832 };
1833 let name = self.parse_graph_name()?;
1834 let graph_type = Some(self.parse_required_create_graph_type()?);
1835 let source = self.parse_optional_graph_source()?;
1836 Ok(Statement::CreateGraph(CreateGraphStatement {
1837 if_not_exists,
1838 or_replace,
1839 property_graph,
1840 name,
1841 graph_type,
1842 source,
1843 }))
1844 }
1845 }
1846 TokenKind::Schema => {
1847 if or_replace || property_graph {
1848 return Err(self.error_expected(vec![TokenKind::Graph], self.peek_kind()));
1849 }
1850 self.bump();
1851 let if_not_exists = self.parse_if_not_exists()?;
1852 let name = self.parse_schema_name()?;
1853 Ok(Statement::CreateSchema(CreateSchemaStatement {
1854 if_not_exists,
1855 name,
1856 }))
1857 }
1858 kind => Err(self.error_expected(vec![TokenKind::Graph, TokenKind::Schema], kind)),
1859 }
1860 }
1861
1862 fn parse_drop_statement(&mut self) -> Result<Statement> {
1863 self.expect(TokenKind::Drop)?;
1864 let property_graph = self.eat(TokenKind::Property).is_some();
1865 match self.peek_kind() {
1866 TokenKind::Graph => {
1867 self.bump();
1868 if self.eat(TokenKind::Type).is_some() {
1869 let if_exists = self.parse_if_exists()?;
1870 let name = self.parse_graph_type_name()?;
1871 Ok(Statement::DropGraphType(DropGraphTypeStatement {
1872 if_exists,
1873 property_graph,
1874 name,
1875 }))
1876 } else {
1877 let if_exists = self.parse_if_exists()?;
1878 let name = self.parse_graph_name()?;
1879 Ok(Statement::DropGraph(DropGraphStatement {
1880 if_exists,
1881 property_graph,
1882 name,
1883 }))
1884 }
1885 }
1886 TokenKind::Schema => {
1887 if property_graph {
1888 return Err(self.error_expected(vec![TokenKind::Graph], self.peek_kind()));
1889 }
1890 self.bump();
1891 let if_exists = self.parse_if_exists()?;
1892 let name = self.parse_schema_name()?;
1893 Ok(Statement::DropSchema(DropSchemaStatement {
1894 if_exists,
1895 name,
1896 }))
1897 }
1898 kind => Err(self.error_expected(vec![TokenKind::Graph, TokenKind::Schema], kind)),
1899 }
1900 }
1901
1902 fn parse_if_not_exists(&mut self) -> Result<bool> {
1903 if self.eat(TokenKind::If).is_some() {
1904 self.expect(TokenKind::Not)?;
1905 self.expect(TokenKind::Exists)?;
1906 Ok(true)
1907 } else {
1908 Ok(false)
1909 }
1910 }
1911
1912 fn parse_if_exists(&mut self) -> Result<bool> {
1913 if self.eat(TokenKind::If).is_some() {
1914 self.expect(TokenKind::Exists)?;
1915 Ok(true)
1916 } else {
1917 Ok(false)
1918 }
1919 }
1920
1921 fn parse_graph_name(&mut self) -> Result<GraphName> {
1922 let (absolute, current_schema, home_schema, parent_levels, parts) =
1923 self.parse_catalog_name_parts()?;
1924 Ok(GraphName {
1925 absolute,
1926 current_schema,
1927 home_schema,
1928 parent_levels,
1929 parts,
1930 })
1931 }
1932
1933 fn parse_graph_expression(&mut self) -> Result<GraphExpression> {
1934 if self.eat(TokenKind::Variable).is_some() {
1935 return Ok(GraphExpression::Variable(Box::new(self.parse_expr()?)));
1936 }
1937 if self.at(TokenKind::LParen) {
1938 return Ok(GraphExpression::Variable(Box::new(self.parse_expr()?)));
1939 }
1940 if self.starts_parameter_property_reference() {
1941 return Ok(GraphExpression::Variable(Box::new(self.parse_expr()?)));
1942 }
1943 if self.at(TokenKind::Parameter) {
1944 let token = self.bump();
1945 return Ok(GraphExpression::Parameter(parameter_name(&token.text)));
1946 }
1947 if self.eat(TokenKind::CurrentGraph).is_some() {
1948 return Ok(GraphExpression::CurrentGraph);
1949 }
1950 if self.eat(TokenKind::CurrentPropertyGraph).is_some() {
1951 return Ok(GraphExpression::CurrentPropertyGraph);
1952 }
1953 if self.eat(TokenKind::HomeGraph).is_some() {
1954 return Ok(GraphExpression::HomeGraph);
1955 }
1956 if self.eat(TokenKind::HomePropertyGraph).is_some() {
1957 return Ok(GraphExpression::HomePropertyGraph);
1958 }
1959 if self.starts_object_expression_primary_special_case(self.peek_kind()) {
1960 return Ok(GraphExpression::Variable(Box::new(self.parse_expr()?)));
1961 }
1962 Ok(GraphExpression::Name(self.parse_graph_name()?))
1963 }
1964
1965 fn parse_binding_table_name(&mut self) -> Result<BindingTableName> {
1966 let (absolute, current_schema, home_schema, parent_levels, parts) =
1967 self.parse_catalog_name_parts()?;
1968 Ok(BindingTableName {
1969 absolute,
1970 current_schema,
1971 home_schema,
1972 parent_levels,
1973 parts,
1974 })
1975 }
1976
1977 fn parse_binding_table_expression(&mut self) -> Result<BindingTableExpression> {
1978 if self.at(TokenKind::LBrace) {
1979 let mut trial = self.clone();
1980 if let Ok(query) = trial.parse_nested_query_specification() {
1981 *self = trial;
1982 return Ok(BindingTableExpression::NestedQuery(Box::new(query)));
1983 }
1984 }
1985 if self.eat(TokenKind::Variable).is_some() {
1986 return Ok(BindingTableExpression::Variable(Box::new(
1987 self.parse_expr()?,
1988 )));
1989 }
1990 if self.at(TokenKind::LParen) {
1991 return Ok(BindingTableExpression::Variable(Box::new(
1992 self.parse_expr()?,
1993 )));
1994 }
1995 if self.starts_parameter_property_reference() {
1996 return Ok(BindingTableExpression::Variable(Box::new(
1997 self.parse_expr()?,
1998 )));
1999 }
2000 if self.at(TokenKind::Parameter) {
2001 let token = self.bump();
2002 return Ok(BindingTableExpression::Parameter(parameter_name(
2003 &token.text,
2004 )));
2005 }
2006 if self.starts_object_expression_primary_special_case(self.peek_kind()) {
2007 return Ok(BindingTableExpression::Variable(Box::new(
2008 self.parse_expr()?,
2009 )));
2010 }
2011 Ok(BindingTableExpression::Name(
2012 self.parse_binding_table_name()?,
2013 ))
2014 }
2015
2016 fn parse_graph_type_name(&mut self) -> Result<GraphTypeName> {
2017 let (absolute, current_schema, home_schema, parent_levels, parts) =
2018 self.parse_catalog_name_parts()?;
2019 Ok(GraphTypeName {
2020 absolute,
2021 current_schema,
2022 home_schema,
2023 parent_levels,
2024 parts,
2025 })
2026 }
2027
2028 fn parse_schema_name(&mut self) -> Result<SchemaName> {
2029 let (absolute, current_schema, home_schema, parent_levels, parts) =
2030 self.parse_catalog_name_parts()?;
2031 Ok(SchemaName {
2032 absolute,
2033 current_schema,
2034 home_schema,
2035 parent_levels,
2036 parts,
2037 })
2038 }
2039
2040 fn parse_schema_reference(&mut self) -> Result<SchemaReference> {
2041 if self.at(TokenKind::Parameter) {
2042 let token = self.bump();
2043 return Ok(SchemaReference::Parameter(parameter_name(&token.text)));
2044 }
2045 if self.eat(TokenKind::CurrentSchema).is_some() {
2046 return Ok(SchemaReference::CurrentSchema);
2047 }
2048 if self.eat(TokenKind::HomeSchema).is_some() {
2049 return Ok(SchemaReference::HomeSchema);
2050 }
2051 if self.eat(TokenKind::Slash).is_some() {
2052 if is_schema_reference_follow(self.peek_kind()) || !is_identifier_like(self.peek_kind())
2053 {
2054 return Ok(SchemaReference::Root);
2055 }
2056 return Ok(SchemaReference::Absolute(self.parse_schema_name()?));
2057 }
2058 if self.eat(TokenKind::Dot).is_some() {
2059 if self.eat(TokenKind::Dot).is_none() {
2060 return Ok(SchemaReference::CurrentSchema);
2061 }
2062 let mut levels = 1;
2063 loop {
2064 self.expect(TokenKind::Slash)?;
2065 if self.eat(TokenKind::Dot).is_some() {
2066 self.expect(TokenKind::Dot)?;
2067 levels += 1;
2068 } else {
2069 let name = self.parse_schema_name()?;
2070 return Ok(SchemaReference::Parent { levels, name });
2071 }
2072 }
2073 }
2074 Ok(SchemaReference::Name(self.parse_schema_name()?))
2075 }
2076
2077 fn parse_procedure_name(&mut self) -> Result<ProcedureName> {
2078 let (absolute, current_schema, home_schema, parent_levels, parts) =
2079 self.parse_catalog_name_parts()?;
2080 Ok(ProcedureName {
2081 absolute,
2082 current_schema,
2083 home_schema,
2084 parent_levels,
2085 parts,
2086 })
2087 }
2088
2089 fn parse_procedure_reference(&mut self) -> Result<ProcedureReference> {
2090 if self.at(TokenKind::Parameter) {
2091 let token = self.bump();
2092 return Ok(ProcedureReference::Parameter(parameter_name(&token.text)));
2093 }
2094 Ok(ProcedureReference::Name(self.parse_procedure_name()?))
2095 }
2096
2097 fn parse_catalog_name_parts(&mut self) -> Result<(bool, bool, bool, usize, Vec<Identifier>)> {
2098 let absolute = self.eat(TokenKind::Slash).is_some();
2099 let mut current_schema = false;
2100 let mut home_schema = false;
2101 let mut parent_levels = 0;
2102
2103 if !absolute {
2104 if self.eat(TokenKind::CurrentSchema).is_some() {
2105 self.expect(TokenKind::Slash)?;
2106 current_schema = true;
2107 } else if self.eat(TokenKind::HomeSchema).is_some() {
2108 self.expect(TokenKind::Slash)?;
2109 home_schema = true;
2110 } else if self.eat(TokenKind::Dot).is_some() {
2111 if self.eat(TokenKind::Dot).is_some() {
2112 parent_levels = 1;
2113 loop {
2114 self.expect(TokenKind::Slash)?;
2115 if self.eat(TokenKind::Dot).is_some() {
2116 self.expect(TokenKind::Dot)?;
2117 parent_levels += 1;
2118 } else {
2119 break;
2120 }
2121 }
2122 } else {
2123 self.expect(TokenKind::Slash)?;
2124 current_schema = true;
2125 }
2126 }
2127 }
2128
2129 let mut parts = vec![self.parse_identifier()?];
2130 while matches!(self.peek_kind(), TokenKind::Dot | TokenKind::Slash) {
2131 self.bump();
2132 parts.push(self.parse_identifier()?);
2133 }
2134 Ok((absolute, current_schema, home_schema, parent_levels, parts))
2135 }
2136
2137 fn starts_parameter_property_reference(&self) -> bool {
2138 self.at(TokenKind::Parameter) && self.peek_n_kind(1) == Some(TokenKind::Dot)
2139 }
2140
2141 fn parse_required_create_graph_type(&mut self) -> Result<CreateGraphType> {
2142 if let Some(graph_type) = self.parse_optional_create_graph_type()? {
2143 return Ok(graph_type);
2144 }
2145
2146 Err(self.error_expected(
2147 vec![
2148 TokenKind::Any,
2149 TokenKind::Like,
2150 TokenKind::Typed,
2151 TokenKind::DoubleColon,
2152 TokenKind::Property,
2153 TokenKind::Graph,
2154 TokenKind::LBrace,
2155 TokenKind::Parameter,
2156 TokenKind::Slash,
2157 TokenKind::Dot,
2158 TokenKind::Identifier,
2159 ],
2160 self.peek_kind(),
2161 ))
2162 }
2163
2164 fn parse_optional_create_graph_type(&mut self) -> Result<Option<CreateGraphType>> {
2165 if matches!(
2166 self.peek_kind(),
2167 TokenKind::As | TokenKind::Semicolon | TokenKind::Eof
2168 ) {
2169 return Ok(None);
2170 }
2171
2172 if self.eat(TokenKind::Like).is_some() {
2173 return Ok(Some(CreateGraphType::Like(self.parse_graph_expression()?)));
2174 }
2175
2176 let typed = self.parse_optional_typed_marker()?;
2177
2178 if self.eat(TokenKind::Any).is_some() {
2179 let property_graph = self.parse_optional_property_graph_prefix()?;
2180 return Ok(Some(CreateGraphType::Any {
2181 typed,
2182 property_graph,
2183 }));
2184 }
2185
2186 if self.at(TokenKind::Property) || self.at(TokenKind::Graph) || self.at(TokenKind::LBrace) {
2187 let property_graph = self.parse_optional_property_graph_prefix()?;
2188 self.eat(TokenKind::Type);
2189 let body = self.parse_nested_graph_type_body()?;
2190 return Ok(Some(CreateGraphType::Nested {
2191 typed,
2192 property_graph,
2193 body,
2194 }));
2195 }
2196
2197 if typed
2198 || matches!(self.peek_kind(), TokenKind::Parameter)
2199 || matches!(self.peek_kind(), TokenKind::Slash)
2200 || matches!(self.peek_kind(), TokenKind::Dot)
2201 || is_identifier_like(self.peek_kind())
2202 {
2203 let name = self.parse_graph_type_reference()?;
2204 return Ok(Some(CreateGraphType::Named { typed, name }));
2205 }
2206
2207 Ok(None)
2208 }
2209
2210 fn parse_optional_graph_source(&mut self) -> Result<Option<GraphExpression>> {
2211 if self.eat(TokenKind::As).is_none() {
2212 return Ok(None);
2213 }
2214 self.expect(TokenKind::Copy)?;
2215 self.expect(TokenKind::Of)?;
2216 Ok(Some(self.parse_graph_expression()?))
2217 }
2218
2219 fn parse_optional_typed_marker(&mut self) -> Result<bool> {
2220 if self.eat(TokenKind::DoubleColon).is_some() {
2221 self.eat(TokenKind::Typed);
2222 return Ok(true);
2223 }
2224 if self.eat(TokenKind::Typed).is_some() {
2225 return Ok(true);
2226 }
2227 Ok(false)
2228 }
2229
2230 fn parse_optional_property_graph_prefix(&mut self) -> Result<bool> {
2231 if self.eat(TokenKind::Property).is_some() {
2232 self.expect(TokenKind::Graph)?;
2233 return Ok(true);
2234 }
2235 self.eat(TokenKind::Graph);
2236 Ok(false)
2237 }
2238
2239 fn parse_create_graph_type_source(&mut self) -> Result<CreateGraphTypeSource> {
2240 if self.eat(TokenKind::As).is_some() {
2241 if self.eat(TokenKind::Copy).is_some() {
2242 self.expect(TokenKind::Of)?;
2243 return self.parse_copy_of_graph_type_source();
2244 }
2245
2246 return Ok(CreateGraphTypeSource::Nested(
2247 self.parse_nested_graph_type_body()?,
2248 ));
2249 }
2250
2251 if self.eat(TokenKind::Copy).is_some() {
2252 self.expect(TokenKind::Of)?;
2253 return self.parse_copy_of_graph_type_source();
2254 }
2255
2256 if self.eat(TokenKind::Like).is_some() {
2257 return Ok(CreateGraphTypeSource::Like(self.parse_graph_expression()?));
2258 }
2259
2260 Ok(CreateGraphTypeSource::Nested(
2261 self.parse_nested_graph_type_body()?,
2262 ))
2263 }
2264
2265 fn parse_copy_of_graph_type_source(&mut self) -> Result<CreateGraphTypeSource> {
2266 if self.at(TokenKind::String) {
2267 let token = self.bump();
2268 if !token.text.contains(':') {
2269 return Err(Error::Message {
2270 offset: token.offset,
2271 message: "external object reference must contain ':'".to_owned(),
2272 });
2273 }
2274 return Ok(CreateGraphTypeSource::CopyOfExternal(token.text));
2275 }
2276 Ok(CreateGraphTypeSource::CopyOf(
2277 self.parse_graph_type_reference()?,
2278 ))
2279 }
2280
2281 fn parse_graph_type_reference(&mut self) -> Result<GraphTypeReference> {
2282 if self.at(TokenKind::Parameter) {
2283 let token = self.bump();
2284 return Ok(GraphTypeReference::Parameter(parameter_name(&token.text)));
2285 }
2286 Ok(GraphTypeReference::Name(self.parse_graph_type_name()?))
2287 }
2288
2289 fn parse_nested_graph_type_body(&mut self) -> Result<GraphTypeBody> {
2290 self.expect(TokenKind::LBrace)?;
2291 let mut elements = Vec::new();
2292 if !self.at(TokenKind::RBrace) {
2293 loop {
2294 let offset = self.peek().offset;
2295 let element = self.parse_graph_type_element(
2296 GraphTypeElementContext::GraphTypeSpecificationBody,
2297 )?;
2298 validate_graph_type_element_name(&elements, &element, offset)?;
2299 elements.push(element);
2300 if self.eat(TokenKind::Comma).is_none() {
2301 break;
2302 }
2303 }
2304 }
2305 validate_graph_type_endpoint_node_types(&elements, self.peek().offset)?;
2306 self.expect(TokenKind::RBrace)?;
2307 Ok(GraphTypeBody { elements })
2308 }
2309
2310 fn parse_graph_type_element(
2311 &mut self,
2312 context: GraphTypeElementContext,
2313 ) -> Result<GraphTypeElement> {
2314 let offset = self.peek().offset;
2315 let edge_kind = self.parse_optional_edge_kind_before_synonym();
2316 if self.eat_node_synonym() {
2317 let name = if self.starts_node_type_filler() {
2318 Identifier::new("")
2319 } else {
2320 self.parse_type_phrase_name()?
2321 };
2322 let labels = self.parse_optional_type_label_list()?;
2323 let properties = self.parse_optional_property_type_set()?;
2324 Ok(GraphTypeElement::Node(NodeTypeDefinition {
2325 name,
2326 labels,
2327 properties,
2328 }))
2329 } else if edge_kind.is_some() || self.eat_edge_synonym() {
2330 if edge_kind.is_some() {
2331 self.expect_edge_synonym()?;
2332 }
2333 let name = if self.starts_node_type_filler() {
2334 Identifier::new("")
2335 } else {
2336 self.parse_type_phrase_name()?
2337 };
2338 validate_graph_type_body_edge_phrase(context, edge_kind, &name, offset)?;
2339 let labels = self.parse_optional_type_label_list()?;
2340 let (direction, source, destination, properties) =
2341 self.parse_edge_type_tail(edge_kind.unwrap_or(Direction::Right), edge_kind)?;
2342 Ok(GraphTypeElement::Edge(EdgeTypeDefinition {
2343 name,
2344 direction,
2345 labels,
2346 source,
2347 destination,
2348 properties,
2349 }))
2350 } else if self.eat(TokenKind::LParen).is_some() {
2351 let name = if self.at(TokenKind::RParen) || self.starts_node_type_filler() {
2352 None
2353 } else {
2354 Some(self.parse_identifier()?)
2355 };
2356 if self.eat(TokenKind::RParen).is_some() {
2357 if self.starts_full_edge_type_arc() {
2358 return self.parse_full_edge_type_pattern_after_left_node(name);
2359 }
2360 return Ok(GraphTypeElement::Node(NodeTypeDefinition {
2361 name: name.unwrap_or_else(|| Identifier::new("")),
2362 labels: Vec::new(),
2363 properties: Vec::new(),
2364 }));
2365 }
2366 let labels = self.parse_optional_type_label_list()?;
2367 let properties = self.parse_optional_property_type_set()?;
2368 self.expect(TokenKind::RParen)?;
2369 if self.starts_full_edge_type_arc() {
2370 return self.parse_full_edge_type_pattern_after_left_node(name);
2371 }
2372 Ok(GraphTypeElement::Node(NodeTypeDefinition {
2373 name: name.unwrap_or_else(|| Identifier::new("")),
2374 labels,
2375 properties,
2376 }))
2377 } else {
2378 Err(self.error_expected(
2379 vec![
2380 TokenKind::Node,
2381 TokenKind::Vertex,
2382 TokenKind::Edge,
2383 TokenKind::Relationship,
2384 TokenKind::LParen,
2385 ],
2386 self.peek_kind(),
2387 ))
2388 }
2389 }
2390
2391 fn eat_node_synonym(&mut self) -> bool {
2392 self.eat(TokenKind::Node).is_some() || self.eat(TokenKind::Vertex).is_some()
2393 }
2394
2395 fn eat_edge_synonym(&mut self) -> bool {
2396 self.eat(TokenKind::Edge).is_some() || self.eat(TokenKind::Relationship).is_some()
2397 }
2398
2399 fn expect_edge_synonym(&mut self) -> Result<()> {
2400 if self.eat_edge_synonym() {
2401 Ok(())
2402 } else {
2403 Err(self.error_expected(
2404 vec![TokenKind::Edge, TokenKind::Relationship],
2405 self.peek_kind(),
2406 ))
2407 }
2408 }
2409
2410 fn at_node_synonym(&self) -> bool {
2411 matches!(self.peek_kind(), TokenKind::Node | TokenKind::Vertex)
2412 }
2413
2414 fn at_edge_synonym(&self) -> bool {
2415 matches!(self.peek_kind(), TokenKind::Edge | TokenKind::Relationship)
2416 }
2417
2418 fn parse_optional_edge_kind_before_synonym(&mut self) -> Option<Direction> {
2419 if self
2420 .peek_n_kind(1)
2421 .is_none_or(|kind| !is_edge_synonym_kind(kind))
2422 {
2423 return None;
2424 }
2425 if self.eat(TokenKind::Directed).is_some() {
2426 Some(Direction::Right)
2427 } else if self.eat(TokenKind::Undirected).is_some() {
2428 Some(Direction::Undirected)
2429 } else {
2430 None
2431 }
2432 }
2433
2434 fn at_edge_kind_before_synonym(&self) -> bool {
2435 matches!(
2436 self.peek_kind(),
2437 TokenKind::Directed | TokenKind::Undirected
2438 ) && self.peek_n_kind(1).is_some_and(is_edge_synonym_kind)
2439 }
2440
2441 fn starts_node_type_filler(&self) -> bool {
2442 match self.peek_kind() {
2443 TokenKind::Label | TokenKind::Labels => {
2444 self.peek_n_kind(1).is_some_and(is_identifier_like)
2445 }
2446 TokenKind::Colon | TokenKind::Is | TokenKind::LBrace => true,
2447 _ => false,
2448 }
2449 }
2450
2451 fn parse_type_phrase_name(&mut self) -> Result<Identifier> {
2452 if self.at(TokenKind::Type)
2453 && self
2454 .peek_n_kind(1)
2455 .is_some_and(is_type_name_after_type_marker)
2456 {
2457 self.bump();
2458 }
2459 self.parse_identifier()
2460 }
2461
2462 fn starts_full_edge_type_arc(&self) -> bool {
2463 matches!(
2464 self.peek_kind(),
2465 TokenKind::Minus | TokenKind::ArrowRight | TokenKind::ArrowLeft | TokenKind::Tilde
2466 )
2467 }
2468
2469 fn parse_full_edge_type_pattern_after_left_node(
2470 &mut self,
2471 left_node: Option<Identifier>,
2472 ) -> Result<GraphTypeElement> {
2473 if self.eat(TokenKind::ArrowRight).is_some() {
2474 let destination = self.parse_parenthesized_node_type_reference()?;
2475 return Ok(GraphTypeElement::Edge(EdgeTypeDefinition {
2476 name: Identifier::new(""),
2477 direction: Direction::Right,
2478 labels: Vec::new(),
2479 source: left_node,
2480 destination,
2481 properties: Vec::new(),
2482 }));
2483 }
2484
2485 if self.eat(TokenKind::Minus).is_some() {
2486 self.expect(TokenKind::LBracket)?;
2487 let (name, labels, properties) = self.parse_named_arc_type_filler()?;
2488 self.expect(TokenKind::RBracket)?;
2489 self.expect(TokenKind::ArrowRight)?;
2490 let destination = self.parse_parenthesized_node_type_reference()?;
2491 return Ok(GraphTypeElement::Edge(EdgeTypeDefinition {
2492 name,
2493 direction: Direction::Right,
2494 labels,
2495 source: left_node,
2496 destination,
2497 properties,
2498 }));
2499 }
2500
2501 if self.eat(TokenKind::Tilde).is_some() {
2502 if self.at(TokenKind::LParen) {
2503 let destination = self.parse_parenthesized_node_type_reference()?;
2504 return Ok(GraphTypeElement::Edge(EdgeTypeDefinition {
2505 name: Identifier::new(""),
2506 direction: Direction::Undirected,
2507 labels: Vec::new(),
2508 source: left_node,
2509 destination,
2510 properties: Vec::new(),
2511 }));
2512 }
2513 self.expect(TokenKind::LBracket)?;
2514 let (name, labels, properties) = self.parse_named_arc_type_filler()?;
2515 self.expect(TokenKind::RBracket)?;
2516 self.expect(TokenKind::Tilde)?;
2517 let destination = self.parse_parenthesized_node_type_reference()?;
2518 return Ok(GraphTypeElement::Edge(EdgeTypeDefinition {
2519 name,
2520 direction: Direction::Undirected,
2521 labels,
2522 source: left_node,
2523 destination,
2524 properties,
2525 }));
2526 }
2527
2528 self.expect(TokenKind::ArrowLeft)?;
2529 if self.at(TokenKind::LParen) {
2530 let source = self.parse_parenthesized_node_type_reference()?;
2531 return Ok(GraphTypeElement::Edge(EdgeTypeDefinition {
2532 name: Identifier::new(""),
2533 direction: Direction::Right,
2534 labels: Vec::new(),
2535 source,
2536 destination: left_node,
2537 properties: Vec::new(),
2538 }));
2539 }
2540 self.expect(TokenKind::LBracket)?;
2541 let (name, labels, properties) = self.parse_named_arc_type_filler()?;
2542 self.expect(TokenKind::RBracket)?;
2543 self.expect(TokenKind::Minus)?;
2544 let source = self.parse_parenthesized_node_type_reference()?;
2545 Ok(GraphTypeElement::Edge(EdgeTypeDefinition {
2546 name,
2547 direction: Direction::Right,
2548 labels,
2549 source,
2550 destination: left_node,
2551 properties,
2552 }))
2553 }
2554
2555 fn parse_named_arc_type_filler(
2556 &mut self,
2557 ) -> Result<(Identifier, Vec<Identifier>, Vec<PropertyTypeDefinition>)> {
2558 let name = if self.at(TokenKind::RBracket) || self.starts_node_type_filler() {
2559 Identifier::new("")
2560 } else {
2561 self.parse_identifier()?
2562 };
2563 let labels = self.parse_optional_type_label_list()?;
2564 let properties = self.parse_optional_property_type_set()?;
2565 Ok((name, labels, properties))
2566 }
2567
2568 fn parse_edge_type_tail(
2569 &mut self,
2570 default_direction: Direction,
2571 explicit_edge_kind: Option<Direction>,
2572 ) -> Result<EdgeTypeTail> {
2573 let mut properties = self.parse_optional_property_type_set()?;
2574 let (direction, source, destination) = if self.eat(TokenKind::Connecting).is_some() {
2575 let (direction, source, destination) =
2576 self.parse_endpoint_pair_definition(default_direction, explicit_edge_kind)?;
2577 (direction, source, destination)
2578 } else {
2579 let source = if self.eat(TokenKind::From).is_some() {
2580 Some(self.parse_identifier()?)
2581 } else {
2582 None
2583 };
2584 let destination = if self.eat(TokenKind::To).is_some() {
2585 Some(self.parse_identifier()?)
2586 } else {
2587 None
2588 };
2589 (default_direction, source, destination)
2590 };
2591 if properties.is_empty() {
2592 properties = self.parse_optional_property_type_set()?;
2593 }
2594 Ok((direction, source, destination, properties))
2595 }
2596
2597 fn parse_endpoint_pair_definition(
2598 &mut self,
2599 default_direction: Direction,
2600 explicit_edge_kind: Option<Direction>,
2601 ) -> Result<(Direction, Option<Identifier>, Option<Identifier>)> {
2602 self.expect(TokenKind::LParen)?;
2603 let first = self.parse_identifier()?;
2604 if self.eat(TokenKind::RParen).is_some() {
2605 let left_node = Some(first);
2606 if self.at(TokenKind::ArrowRight) {
2607 let offset = self.bump().offset;
2608 validate_endpoint_pair_shape(explicit_edge_kind, Direction::Right, offset)?;
2609 return Ok((
2610 Direction::Right,
2611 left_node,
2612 self.parse_parenthesized_node_type_reference()?,
2613 ));
2614 }
2615 if self.at(TokenKind::ArrowLeft) {
2616 let offset = self.bump().offset;
2617 validate_endpoint_pair_shape(explicit_edge_kind, Direction::Right, offset)?;
2618 return Ok((
2619 Direction::Right,
2620 self.parse_parenthesized_node_type_reference()?,
2621 left_node,
2622 ));
2623 }
2624 if self.at(TokenKind::Tilde) {
2625 let offset = self.bump().offset;
2626 validate_endpoint_pair_shape(explicit_edge_kind, Direction::Undirected, offset)?;
2627 return Ok((
2628 Direction::Undirected,
2629 left_node,
2630 self.parse_parenthesized_node_type_reference()?,
2631 ));
2632 }
2633 return Err(self.error_expected(
2634 vec![
2635 TokenKind::To,
2636 TokenKind::ArrowRight,
2637 TokenKind::ArrowLeft,
2638 TokenKind::Tilde,
2639 ],
2640 self.peek_kind(),
2641 ));
2642 }
2643 let (direction, source, destination) = if self.eat(TokenKind::To).is_some() {
2644 (
2645 default_direction,
2646 Some(first),
2647 Some(self.parse_identifier()?),
2648 )
2649 } else if self.at(TokenKind::ArrowRight) {
2650 let offset = self.bump().offset;
2651 validate_endpoint_pair_shape(explicit_edge_kind, Direction::Right, offset)?;
2652 (
2653 Direction::Right,
2654 Some(first),
2655 Some(self.parse_identifier()?),
2656 )
2657 } else if self.at(TokenKind::Tilde) {
2658 let offset = self.bump().offset;
2659 validate_endpoint_pair_shape(explicit_edge_kind, Direction::Undirected, offset)?;
2660 (
2661 Direction::Undirected,
2662 Some(first),
2663 Some(self.parse_identifier()?),
2664 )
2665 } else if self.at(TokenKind::ArrowLeft) {
2666 let offset = self.bump().offset;
2667 validate_endpoint_pair_shape(explicit_edge_kind, Direction::Right, offset)?;
2668 (
2669 Direction::Right,
2670 Some(self.parse_identifier()?),
2671 Some(first),
2672 )
2673 } else {
2674 return Err(self.error_expected(
2675 vec![
2676 TokenKind::To,
2677 TokenKind::ArrowRight,
2678 TokenKind::ArrowLeft,
2679 TokenKind::Tilde,
2680 ],
2681 self.peek_kind(),
2682 ));
2683 };
2684 self.expect(TokenKind::RParen)?;
2685 Ok((direction, source, destination))
2686 }
2687
2688 fn parse_parenthesized_node_type_reference(&mut self) -> Result<Option<Identifier>> {
2689 self.expect(TokenKind::LParen)?;
2690 let name = if self.at(TokenKind::RParen) || self.starts_node_type_filler() {
2691 None
2692 } else {
2693 Some(self.parse_identifier()?)
2694 };
2695 if name.is_none() {
2696 self.parse_optional_type_label_list()?;
2697 self.parse_optional_property_type_set()?;
2698 }
2699 self.expect(TokenKind::RParen)?;
2700 Ok(name)
2701 }
2702
2703 fn parse_optional_type_label_list(&mut self) -> Result<Vec<Identifier>> {
2704 let mut labels = Vec::new();
2705 if self.eat(TokenKind::Label).is_some() {
2706 let label = self.parse_identifier()?;
2707 push_identifier_if_absent(&mut labels, Some(&label));
2708 return Ok(labels);
2709 }
2710 if self.eat(TokenKind::Labels).is_some() {
2711 let label = self.parse_identifier()?;
2712 push_identifier_if_absent(&mut labels, Some(&label));
2713 while self.eat(TokenKind::Ampersand).is_some() {
2714 let label = self.parse_identifier()?;
2715 push_identifier_if_absent(&mut labels, Some(&label));
2716 }
2717 return Ok(labels);
2718 }
2719 while self.eat(TokenKind::Colon).is_some() || self.eat(TokenKind::Is).is_some() {
2720 let label = self.parse_identifier()?;
2721 push_identifier_if_absent(&mut labels, Some(&label));
2722 while self.eat(TokenKind::Ampersand).is_some() {
2723 let label = self.parse_identifier()?;
2724 push_identifier_if_absent(&mut labels, Some(&label));
2725 }
2726 }
2727 Ok(labels)
2728 }
2729
2730 fn parse_optional_property_type_set(&mut self) -> Result<Vec<PropertyTypeDefinition>> {
2731 let mut properties = Vec::new();
2732 if self.eat(TokenKind::LBrace).is_none() {
2733 return Ok(properties);
2734 }
2735 if !self.at(TokenKind::RBrace) {
2736 loop {
2737 let offset = self.peek().offset;
2738 let name = self.parse_identifier()?;
2739 if properties.iter().any(|property: &PropertyTypeDefinition| {
2740 property.name.value.eq_ignore_ascii_case(&name.value)
2741 }) {
2742 return Err(Error::Message {
2743 offset,
2744 message: format!("duplicate property '{}'", name.value),
2745 });
2746 }
2747 self.parse_optional_typed_marker()?;
2748 let value_type = self.parse_value_type()?;
2749 properties.push(PropertyTypeDefinition { name, value_type });
2750 if self.eat(TokenKind::Comma).is_none() {
2751 break;
2752 }
2753 }
2754 }
2755 self.expect(TokenKind::RBrace)?;
2756 Ok(properties)
2757 }
2758
2759 fn parse_value_type(&mut self) -> Result<ValueType> {
2760 let first = self.parse_value_type_component()?;
2761 if self.eat(TokenKind::Pipe).is_none() {
2762 return Ok(first);
2763 }
2764
2765 let mut components = vec![first, self.parse_value_type_component()?];
2766 while self.eat(TokenKind::Pipe).is_some() {
2767 components.push(self.parse_value_type_component()?);
2768 }
2769 validate_dynamic_union_component_nullability(&components, self.peek().offset)?;
2770 Ok(ValueType::DynamicUnion(components))
2771 }
2772
2773 fn parse_value_type_component(&mut self) -> Result<ValueType> {
2774 let mut value_type = self.parse_value_type_base()?;
2775 if self.eat(TokenKind::Not).is_some() {
2776 self.expect(TokenKind::Null)?;
2777 value_type = ValueType::NotNull(Box::new(value_type));
2778 }
2779 if self.at(TokenKind::Group)
2780 && matches!(
2781 self.peek_n_kind(1),
2782 Some(TokenKind::List | TokenKind::Array)
2783 )
2784 {
2785 return Err(Error::Message {
2786 offset: self.peek().offset,
2787 message: "GROUP list value type names are not user-visible standard GQL syntax"
2788 .to_owned(),
2789 });
2790 }
2791 while self.peek_list_value_type_name().is_some() {
2792 let offset = self.peek().offset;
2793 let (kind, group) = self.parse_list_value_type_name()?;
2794 let max_length = self.parse_optional_list_max_length()?;
2795 value_type = Self::wrap_list_value_type(value_type, kind, group, max_length, offset)?;
2796 if self.eat(TokenKind::Not).is_some() {
2797 self.expect(TokenKind::Null)?;
2798 value_type = ValueType::NotNull(Box::new(value_type));
2799 }
2800 if self.at(TokenKind::Group)
2801 && matches!(
2802 self.peek_n_kind(1),
2803 Some(TokenKind::List | TokenKind::Array)
2804 )
2805 {
2806 return Err(Error::Message {
2807 offset: self.peek().offset,
2808 message: "GROUP list value type names are not user-visible standard GQL syntax"
2809 .to_owned(),
2810 });
2811 }
2812 }
2813 Ok(value_type)
2814 }
2815
2816 fn parse_value_type_base(&mut self) -> Result<ValueType> {
2817 if self.at(TokenKind::Group)
2818 && matches!(
2819 self.peek_n_kind(1),
2820 Some(TokenKind::List | TokenKind::Array)
2821 )
2822 {
2823 return Err(Error::Message {
2824 offset: self.peek().offset,
2825 message: "GROUP list value type names are not user-visible standard GQL syntax"
2826 .to_owned(),
2827 });
2828 }
2829
2830 if self.eat(TokenKind::Any).is_some() {
2831 if self.eat(TokenKind::Property).is_some() {
2832 if self.eat(TokenKind::Graph).is_some() {
2833 return Ok(ValueType::GraphReference {
2834 property_graph: true,
2835 body: None,
2836 });
2837 }
2838 self.expect(TokenKind::Value)?;
2839 return Ok(ValueType::PropertyValue);
2840 }
2841 if self.eat(TokenKind::Graph).is_some() {
2842 return Ok(ValueType::GraphReference {
2843 property_graph: false,
2844 body: None,
2845 });
2846 }
2847 if self.eat_node_synonym() {
2848 return Ok(ValueType::NodeReference { definition: None });
2849 }
2850 if self.eat_edge_synonym() {
2851 return Ok(ValueType::EdgeReference { definition: None });
2852 }
2853 if self.eat(TokenKind::Record).is_some() {
2854 return Ok(ValueType::AnyRecord);
2855 }
2856 self.eat(TokenKind::Value);
2857 if self.eat(TokenKind::Lt).is_some() {
2858 let components = self.parse_component_type_list()?;
2859 self.expect(TokenKind::Gt)?;
2860 return Ok(ValueType::DynamicUnion(components));
2861 }
2862 return Ok(ValueType::AnyDynamic);
2863 }
2864
2865 if self.at(TokenKind::Property) && self.peek_n_kind(1) == Some(TokenKind::Value) {
2866 self.expect(TokenKind::Property)?;
2867 self.expect(TokenKind::Value)?;
2868 return Ok(ValueType::PropertyValue);
2869 }
2870
2871 if self.at(TokenKind::Binding) && self.peek_n_kind(1) == Some(TokenKind::Table) {
2872 self.expect(TokenKind::Binding)?;
2873 self.expect(TokenKind::Table)?;
2874 let fields = self.parse_field_type_specification()?;
2875 return Ok(ValueType::BindingTable {
2876 binding: true,
2877 fields,
2878 });
2879 }
2880
2881 if self.at(TokenKind::Table) && self.peek_n_kind(1) == Some(TokenKind::LBrace) {
2882 self.expect(TokenKind::Table)?;
2883 let fields = self.parse_field_type_specification()?;
2884 return Ok(ValueType::BindingTable {
2885 binding: false,
2886 fields,
2887 });
2888 }
2889
2890 if self.at(TokenKind::Property) && self.peek_n_kind(1) == Some(TokenKind::Graph) {
2891 self.expect(TokenKind::Property)?;
2892 self.expect(TokenKind::Graph)?;
2893 let body = self.parse_nested_graph_type_body()?;
2894 return Ok(ValueType::GraphReference {
2895 property_graph: true,
2896 body: Some(body),
2897 });
2898 }
2899
2900 if self.at(TokenKind::Graph) && self.peek_n_kind(1) == Some(TokenKind::LBrace) {
2901 self.expect(TokenKind::Graph)?;
2902 let body = self.parse_nested_graph_type_body()?;
2903 return Ok(ValueType::GraphReference {
2904 property_graph: false,
2905 body: Some(body),
2906 });
2907 }
2908
2909 if self.at_node_synonym() {
2910 return Ok(ValueType::NodeReference {
2911 definition: self.parse_optional_node_type_definition()?,
2912 });
2913 }
2914
2915 if self.at_edge_kind_before_synonym() {
2916 let offset = self.peek().offset;
2917 let direction = self
2918 .parse_optional_edge_kind_before_synonym()
2919 .unwrap_or(Direction::Right);
2920 let definition = self
2921 .parse_optional_edge_type_definition_with_direction(direction, Some(direction))?;
2922 if let Some(definition) = &definition {
2923 validate_closed_edge_reference_definition(definition, offset)?;
2924 }
2925 return Ok(ValueType::EdgeReference { definition });
2926 }
2927
2928 if self.at_edge_synonym() {
2929 let offset = self.peek().offset;
2930 let definition = self.parse_optional_edge_type_definition()?;
2931 if let Some(definition) = &definition {
2932 validate_closed_edge_reference_definition(definition, offset)?;
2933 }
2934 return Ok(ValueType::EdgeReference { definition });
2935 }
2936
2937 if self.at(TokenKind::LParen) {
2938 return match self
2939 .parse_graph_type_element(GraphTypeElementContext::ClosedReferenceValueType)?
2940 {
2941 GraphTypeElement::Node(definition) => Ok(ValueType::NodeReference {
2942 definition: Some(definition),
2943 }),
2944 GraphTypeElement::Edge(definition) => {
2945 validate_closed_edge_reference_definition(&definition, self.peek().offset)?;
2946 Ok(ValueType::EdgeReference {
2947 definition: Some(definition),
2948 })
2949 }
2950 };
2951 }
2952
2953 if self.at(TokenKind::Path) {
2954 self.bump();
2955 return Ok(ValueType::Path);
2956 }
2957
2958 if self.peek_list_value_type_name().is_some() {
2959 let offset = self.peek().offset;
2960 let (kind, group) = self.parse_list_value_type_name()?;
2961 self.expect(TokenKind::Lt)?;
2962 let inner = self.parse_value_type()?;
2963 self.expect(TokenKind::Gt)?;
2964 let max_length = self.parse_optional_list_max_length()?;
2965 return Self::wrap_list_value_type(inner, kind, group, max_length, offset);
2966 }
2967
2968 if self.eat(TokenKind::Record).is_some() {
2969 if self.at(TokenKind::LBrace) {
2970 return Ok(ValueType::Record(self.parse_field_type_specification()?));
2971 }
2972 return Ok(ValueType::AnyRecord);
2973 }
2974
2975 if self.at(TokenKind::LBrace) {
2976 return Ok(ValueType::Record(self.parse_field_type_specification()?));
2977 }
2978
2979 if let Some(kind) = self.peek_character_string_type_kind() {
2980 self.bump();
2981 return self.parse_character_string_type(kind);
2982 }
2983
2984 if let Some(kind) = self.peek_boolean_type_kind() {
2985 self.bump();
2986 return Ok(ValueType::Boolean { kind });
2987 }
2988
2989 if let Some((kind, word_count)) = self.peek_temporal_type_kind() {
2990 for _ in 0..word_count {
2991 self.bump();
2992 }
2993 return Ok(ValueType::Temporal { kind });
2994 }
2995
2996 if let Some(kind) = self.peek_byte_string_type_kind() {
2997 self.bump();
2998 return self.parse_byte_string_type(kind);
2999 }
3000
3001 if let Some(kind) = self.peek_exact_numeric_type_kind() {
3002 self.bump();
3003 return self.parse_exact_numeric_type(kind);
3004 }
3005
3006 if self.at(TokenKind::Identifier)
3007 && matches!(
3008 self.peek().text.to_ascii_uppercase().as_str(),
3009 "SIGNED" | "UNSIGNED"
3010 )
3011 {
3012 return self.parse_signed_or_unsigned_integer_type();
3013 }
3014
3015 if self.peek_integer_numeric_type_start() {
3016 return self.parse_integer_numeric_type(None);
3017 }
3018
3019 if let Some(kind) = self.peek_approximate_numeric_type_kind() {
3020 let token = self.bump();
3021 return self.parse_approximate_numeric_type(kind, token.text);
3022 }
3023
3024 let name = self.parse_value_type_name()?;
3025 let mut parameters = Vec::new();
3026 if self.eat(TokenKind::LParen).is_some() {
3027 if !self.at(TokenKind::RParen) {
3028 loop {
3029 parameters.push(self.parse_u64_literal()?);
3030 if self.eat(TokenKind::Comma).is_none() {
3031 break;
3032 }
3033 }
3034 }
3035 self.expect(TokenKind::RParen)?;
3036 }
3037 Ok(ValueType::Named { name, parameters })
3038 }
3039
3040 fn peek_character_string_type_kind(&self) -> Option<CharacterStringTypeKind> {
3041 let text = self.peek().text.to_ascii_uppercase();
3042 match text.as_str() {
3043 "STRING" => Some(CharacterStringTypeKind::String),
3044 "VARCHAR" => Some(CharacterStringTypeKind::Varchar),
3045 _ => None,
3046 }
3047 }
3048
3049 fn parse_character_string_type(&mut self, kind: CharacterStringTypeKind) -> Result<ValueType> {
3050 let max_length = if self.eat(TokenKind::LParen).is_some() {
3051 let max_length = self.parse_positive_u64_literal("character string max length")?;
3052 self.expect(TokenKind::RParen)?;
3053 Some(max_length)
3054 } else {
3055 None
3056 };
3057 Ok(ValueType::CharacterString { kind, max_length })
3058 }
3059
3060 fn peek_boolean_type_kind(&self) -> Option<BooleanTypeKind> {
3061 let text = self.peek().text.to_ascii_uppercase();
3062 match text.as_str() {
3063 "BOOL" => Some(BooleanTypeKind::Bool),
3064 "BOOLEAN" => Some(BooleanTypeKind::Boolean),
3065 _ => None,
3066 }
3067 }
3068
3069 fn peek_temporal_type_kind(&self) -> Option<(TemporalTypeKind, usize)> {
3070 if self.peek_type_words(&["ZONED", "DATETIME"]) {
3071 return Some((TemporalTypeKind::ZonedDateTime, 2));
3072 }
3073 if self.peek_type_words(&["TIMESTAMP", "WITH", "TIME", "ZONE"]) {
3074 return Some((TemporalTypeKind::ZonedDateTime, 4));
3075 }
3076 if self.peek_type_words(&["LOCAL", "DATETIME"]) {
3077 return Some((TemporalTypeKind::LocalDateTime, 2));
3078 }
3079 if self.peek_type_words(&["TIMESTAMP", "WITHOUT", "TIME", "ZONE"]) {
3080 return Some((TemporalTypeKind::LocalDateTime, 4));
3081 }
3082 if self.peek_type_words(&["TIMESTAMP"]) {
3083 return Some((TemporalTypeKind::LocalDateTime, 1));
3084 }
3085 if self.at(TokenKind::Date) {
3086 return Some((TemporalTypeKind::Date, 1));
3087 }
3088 if self.peek_type_words(&["ZONED", "TIME"]) {
3089 return Some((TemporalTypeKind::ZonedTime, 2));
3090 }
3091 if self.peek_type_words(&["TIME", "WITH", "TIME", "ZONE"]) {
3092 return Some((TemporalTypeKind::ZonedTime, 4));
3093 }
3094 if self.peek_type_words(&["LOCAL", "TIME"]) {
3095 return Some((TemporalTypeKind::LocalTime, 2));
3096 }
3097 if self.peek_type_words(&["TIME", "WITHOUT", "TIME", "ZONE"]) {
3098 return Some((TemporalTypeKind::LocalTime, 4));
3099 }
3100 if self.at(TokenKind::Duration) {
3101 return Some((TemporalTypeKind::Duration, 1));
3102 }
3103 None
3104 }
3105
3106 fn peek_byte_string_type_kind(&self) -> Option<ByteStringTypeKind> {
3107 let text = self.peek().text.to_ascii_uppercase();
3108 match text.as_str() {
3109 "BYTES" => Some(ByteStringTypeKind::Bytes),
3110 "BINARY" => Some(ByteStringTypeKind::Binary),
3111 "VARBINARY" => Some(ByteStringTypeKind::Varbinary),
3112 _ => None,
3113 }
3114 }
3115
3116 fn parse_byte_string_type(&mut self, kind: ByteStringTypeKind) -> Result<ValueType> {
3117 let (min_length, max_length) = if self.eat(TokenKind::LParen).is_some() {
3118 match kind {
3119 ByteStringTypeKind::Bytes => {
3120 let first = self.parse_u64_literal()?;
3121 let (min_length, max_length) = if self.eat(TokenKind::Comma).is_some() {
3122 (
3123 Some(first),
3124 Some(self.parse_positive_u64_literal("byte string max length")?),
3125 )
3126 } else {
3127 self.ensure_positive_u64(first, "byte string max length")?;
3128 (Some(0), Some(first))
3129 };
3130 self.expect(TokenKind::RParen)?;
3131 if let (Some(min_length), Some(max_length)) = (min_length, max_length) {
3132 if min_length > max_length {
3133 return Err(Error::Message {
3134 offset: self.peek().offset,
3135 message: "byte string min length exceeds max length".to_owned(),
3136 });
3137 }
3138 }
3139 (min_length, max_length)
3140 }
3141 ByteStringTypeKind::Binary | ByteStringTypeKind::Varbinary => {
3142 let length = match kind {
3143 ByteStringTypeKind::Binary => {
3144 self.parse_positive_u64_literal("byte string fixed length")?
3145 }
3146 ByteStringTypeKind::Varbinary => {
3147 self.parse_positive_u64_literal("byte string max length")?
3148 }
3149 ByteStringTypeKind::Bytes => unreachable!(),
3150 };
3151 self.expect(TokenKind::RParen)?;
3152 match kind {
3153 ByteStringTypeKind::Binary => (Some(length), Some(length)),
3154 ByteStringTypeKind::Varbinary => (Some(0), Some(length)),
3155 ByteStringTypeKind::Bytes => unreachable!(),
3156 }
3157 }
3158 }
3159 } else {
3160 match kind {
3161 ByteStringTypeKind::Binary => (Some(1), Some(1)),
3162 ByteStringTypeKind::Bytes | ByteStringTypeKind::Varbinary => (Some(0), None),
3163 }
3164 };
3165 Ok(ValueType::ByteString {
3166 kind,
3167 min_length,
3168 max_length,
3169 })
3170 }
3171
3172 fn peek_exact_numeric_type_kind(&self) -> Option<ExactNumericTypeKind> {
3173 let text = self.peek().text.to_ascii_uppercase();
3174 match text.as_str() {
3175 "DEC" | "DECIMAL" => Some(ExactNumericTypeKind::Decimal),
3176 _ => None,
3177 }
3178 }
3179
3180 fn parse_exact_numeric_type(&mut self, kind: ExactNumericTypeKind) -> Result<ValueType> {
3181 let (precision, scale) = self.parse_optional_precision_scale()?;
3182 if let (Some(precision), Some(scale)) = (precision, scale) {
3183 if scale > precision {
3184 return Err(Error::Message {
3185 offset: self.peek().offset,
3186 message: "numeric scale exceeds precision".to_owned(),
3187 });
3188 }
3189 }
3190 Ok(ValueType::ExactNumeric {
3191 kind,
3192 signed: None,
3193 precision,
3194 scale,
3195 })
3196 }
3197
3198 fn parse_signed_or_unsigned_integer_type(&mut self) -> Result<ValueType> {
3199 let signed = self.bump().text.eq_ignore_ascii_case("SIGNED");
3200 self.parse_integer_numeric_type(Some(signed))
3201 }
3202
3203 fn peek_integer_numeric_type_start(&self) -> bool {
3204 let first = self.peek().text.to_ascii_uppercase();
3205 Self::numeric_suffix(&first, "INTEGER").is_some()
3206 || Self::numeric_suffix(&first, "INT").is_some()
3207 || Self::numeric_suffix(&first, "UINT").is_some()
3208 || first == "BIGINT"
3209 || first == "SMALLINT"
3210 || first == "UBIGINT"
3211 || first == "USMALLINT"
3212 || (first == "SMALL" && self.peek_type_words(&["INTEGER"]))
3213 || (first == "BIG" && self.peek_type_words(&["INTEGER"]))
3214 }
3215
3216 fn numeric_suffix(text: &str, prefix: &str) -> Option<Option<u64>> {
3217 let suffix = text.strip_prefix(prefix)?;
3218 if suffix.is_empty() {
3219 return Some(None);
3220 }
3221 if suffix.chars().all(|ch| ch.is_ascii_digit()) {
3222 return suffix.parse().ok().map(Some);
3223 }
3224 None
3225 }
3226
3227 fn parse_integer_numeric_type(&mut self, explicit_signed: Option<bool>) -> Result<ValueType> {
3228 let first = self.parse_identifier()?.value.to_ascii_uppercase();
3229 let mut signed = explicit_signed;
3230 let mut precision = None;
3231
3232 match first.as_str() {
3233 "SMALL" | "BIG" => {
3234 self.expect_identifier_word("INTEGER")?;
3235 signed.get_or_insert(true);
3236 }
3237 "INTEGER" | "INT" | "UINT" => {
3238 if first == "UINT" {
3239 signed = Some(false);
3240 } else {
3241 signed.get_or_insert(true);
3242 }
3243 precision = self.parse_optional_single_precision()?;
3244 }
3245 "SMALLINT" | "BIGINT" => {
3246 signed.get_or_insert(true);
3247 }
3248 "USMALLINT" | "UBIGINT" => {
3249 signed = Some(false);
3250 }
3251 text if Self::numeric_suffix(text, "UINT").is_some() => {
3252 signed = Some(false);
3253 precision = Self::numeric_suffix(text, "UINT").flatten();
3254 if let Some(precision) = precision {
3255 self.ensure_standard_integer_suffix(precision)?;
3256 }
3257 }
3258 text if Self::numeric_suffix(text, "INT").is_some() => {
3259 signed.get_or_insert(true);
3260 precision = Self::numeric_suffix(text, "INT").flatten();
3261 if let Some(precision) = precision {
3262 self.ensure_standard_integer_suffix(precision)?;
3263 }
3264 }
3265 text if Self::numeric_suffix(text, "INTEGER").is_some() => {
3266 signed.get_or_insert(true);
3267 precision = Self::numeric_suffix(text, "INTEGER").flatten();
3268 if let Some(precision) = precision {
3269 self.ensure_standard_integer_suffix(precision)?;
3270 }
3271 }
3272 _ => {
3273 return Err(self.error_expected(vec![TokenKind::Identifier], self.peek_kind()));
3274 }
3275 }
3276
3277 if let Some(precision) = precision {
3278 self.ensure_positive_u64(precision, "numeric precision")?;
3279 }
3280
3281 Ok(ValueType::ExactNumeric {
3282 kind: ExactNumericTypeKind::Integer,
3283 signed,
3284 precision,
3285 scale: None,
3286 })
3287 }
3288
3289 fn ensure_standard_integer_suffix(&self, precision: u64) -> Result<()> {
3290 if !matches!(precision, 8 | 16 | 32 | 64 | 128 | 256) {
3291 return Err(Error::Message {
3292 offset: self.peek().offset,
3293 message: "integer type suffix must be one of 8, 16, 32, 64, 128, or 256".to_owned(),
3294 });
3295 }
3296 Ok(())
3297 }
3298
3299 fn parse_optional_single_precision(&mut self) -> Result<Option<u64>> {
3300 if self.eat(TokenKind::LParen).is_none() {
3301 return Ok(None);
3302 }
3303 let precision = self.parse_positive_u64_literal("numeric precision")?;
3304 self.expect(TokenKind::RParen)?;
3305 Ok(Some(precision))
3306 }
3307
3308 fn peek_approximate_numeric_type_kind(&self) -> Option<ApproximateNumericTypeKind> {
3309 let text = self.peek().text.to_ascii_uppercase();
3310 if Self::numeric_suffix(&text, "FLOAT").is_some() {
3311 return Some(ApproximateNumericTypeKind::Float);
3312 }
3313 match text.as_str() {
3314 "REAL" => Some(ApproximateNumericTypeKind::Real),
3315 "DOUBLE" => Some(ApproximateNumericTypeKind::Double),
3316 _ => None,
3317 }
3318 }
3319
3320 fn parse_approximate_numeric_type(
3321 &mut self,
3322 kind: ApproximateNumericTypeKind,
3323 type_name: String,
3324 ) -> Result<ValueType> {
3325 let mut precision = None;
3326 let mut scale = None;
3327 match kind {
3328 ApproximateNumericTypeKind::Float => {
3329 let text = type_name.to_ascii_uppercase();
3330 precision = Self::numeric_suffix(&text, "FLOAT").flatten();
3331 if let Some(precision) = precision {
3332 self.ensure_standard_float_suffix(precision)?;
3333 self.ensure_approximate_numeric_precision(precision)?;
3334 }
3335 if precision.is_none() {
3336 (precision, scale) = self.parse_optional_precision_scale()?;
3337 if let Some(precision) = precision {
3338 self.ensure_approximate_numeric_precision(precision)?;
3339 }
3340 }
3341 }
3342 ApproximateNumericTypeKind::Real => {}
3343 ApproximateNumericTypeKind::Double => {
3344 if self.peek_type_words(&["PRECISION"]) {
3345 self.bump();
3346 }
3347 }
3348 }
3349 Ok(ValueType::ApproximateNumeric {
3350 kind,
3351 precision,
3352 scale,
3353 })
3354 }
3355
3356 fn parse_optional_precision_scale(&mut self) -> Result<(Option<u64>, Option<u64>)> {
3357 if self.eat(TokenKind::LParen).is_none() {
3358 return Ok((None, None));
3359 }
3360 let precision = self.parse_positive_u64_literal("numeric precision")?;
3361 let scale = if self.eat(TokenKind::Comma).is_some() {
3362 Some(self.parse_u64_literal()?)
3363 } else {
3364 None
3365 };
3366 self.expect(TokenKind::RParen)?;
3367 Ok((Some(precision), scale))
3368 }
3369
3370 fn ensure_approximate_numeric_precision(&self, precision: u64) -> Result<()> {
3371 if precision < 2 {
3372 return Err(Error::Message {
3373 offset: self.peek().offset,
3374 message: "approximate numeric precision must be greater than or equal to 2"
3375 .to_owned(),
3376 });
3377 }
3378 Ok(())
3379 }
3380
3381 fn ensure_standard_float_suffix(&self, precision: u64) -> Result<()> {
3382 if !matches!(precision, 16 | 32 | 64 | 128 | 256) {
3383 return Err(Error::Message {
3384 offset: self.peek().offset,
3385 message: "FLOAT type suffix must be one of 16, 32, 64, 128, or 256".to_owned(),
3386 });
3387 }
3388 Ok(())
3389 }
3390
3391 fn parse_optional_node_type_definition(&mut self) -> Result<Option<NodeTypeDefinition>> {
3392 if !self.eat_node_synonym() {
3393 return Err(
3394 self.error_expected(vec![TokenKind::Node, TokenKind::Vertex], self.peek_kind())
3395 );
3396 }
3397 if self.at(TokenKind::Type) && self.peek_n_kind(1) == Some(TokenKind::Identifier) {
3398 self.bump();
3399 }
3400 if !matches!(self.peek_kind(), TokenKind::Identifier) && !self.starts_node_type_filler() {
3401 return Ok(None);
3402 }
3403 let name = if self.starts_node_type_filler() {
3404 Identifier::new("")
3405 } else {
3406 self.parse_identifier()?
3407 };
3408 let labels = self.parse_optional_type_label_list()?;
3409 let properties = self.parse_optional_property_type_set()?;
3410 Ok(Some(NodeTypeDefinition {
3411 name,
3412 labels,
3413 properties,
3414 }))
3415 }
3416
3417 fn parse_optional_edge_type_definition(&mut self) -> Result<Option<EdgeTypeDefinition>> {
3418 self.parse_optional_edge_type_definition_with_direction(Direction::Right, None)
3419 }
3420
3421 fn parse_optional_edge_type_definition_with_direction(
3422 &mut self,
3423 default_direction: Direction,
3424 explicit_edge_kind: Option<Direction>,
3425 ) -> Result<Option<EdgeTypeDefinition>> {
3426 if !self.eat_edge_synonym() {
3427 return Err(self.error_expected(
3428 vec![TokenKind::Edge, TokenKind::Relationship],
3429 self.peek_kind(),
3430 ));
3431 }
3432 if self.at(TokenKind::Type) && self.peek_n_kind(1) == Some(TokenKind::Identifier) {
3433 self.bump();
3434 }
3435 if !matches!(self.peek_kind(), TokenKind::Identifier) && !self.starts_node_type_filler() {
3436 return Ok(None);
3437 }
3438 let name = if self.starts_node_type_filler() {
3439 Identifier::new("")
3440 } else {
3441 self.parse_identifier()?
3442 };
3443 let labels = self.parse_optional_type_label_list()?;
3444 let (direction, source, destination, properties) =
3445 self.parse_edge_type_tail(default_direction, explicit_edge_kind)?;
3446 Ok(Some(EdgeTypeDefinition {
3447 name,
3448 direction,
3449 labels,
3450 source,
3451 destination,
3452 properties,
3453 }))
3454 }
3455
3456 fn parse_field_type_specification(&mut self) -> Result<Vec<FieldType>> {
3457 self.expect(TokenKind::LBrace)?;
3458 let mut fields = Vec::new();
3459 if !self.at(TokenKind::RBrace) {
3460 loop {
3461 let offset = self.peek().offset;
3462 let name = self.parse_identifier()?;
3463 if fields
3464 .iter()
3465 .any(|field: &FieldType| field.name.value.eq_ignore_ascii_case(&name.value))
3466 {
3467 return Err(Error::Message {
3468 offset,
3469 message: format!("duplicate field '{}'", name.value),
3470 });
3471 }
3472 self.parse_optional_typed_marker()?;
3473 let value_type = self.parse_value_type()?;
3474 fields.push(FieldType { name, value_type });
3475 if self.eat(TokenKind::Comma).is_none() {
3476 break;
3477 }
3478 }
3479 }
3480 self.expect(TokenKind::RBrace)?;
3481 Ok(fields)
3482 }
3483
3484 fn parse_component_type_list(&mut self) -> Result<Vec<ValueType>> {
3485 let mut components = vec![self.parse_value_type_component()?];
3486 while self.eat(TokenKind::Pipe).is_some() {
3487 components.push(self.parse_value_type_component()?);
3488 }
3489 validate_dynamic_union_component_nullability(&components, self.peek().offset)?;
3490 Ok(components)
3491 }
3492
3493 fn parse_optional_list_max_length(&mut self) -> Result<Option<u64>> {
3494 if self.eat(TokenKind::LBracket).is_none() {
3495 return Ok(None);
3496 }
3497 let max_length = self.parse_u64_literal()?;
3498 self.ensure_positive_u64(max_length, "list max length")?;
3499 self.expect(TokenKind::RBracket)?;
3500 Ok(Some(max_length))
3501 }
3502
3503 fn peek_list_value_type_name(&self) -> Option<(TokenKind, bool)> {
3504 match self.peek_kind() {
3505 TokenKind::List | TokenKind::Array => Some((self.peek_kind(), false)),
3506 _ => None,
3507 }
3508 }
3509
3510 fn parse_list_value_type_name(&mut self) -> Result<(TokenKind, bool)> {
3511 if self.at(TokenKind::List) || self.at(TokenKind::Array) {
3512 let token = self.bump();
3513 return Ok((token.kind, false));
3514 }
3515 Err(self.error_expected(vec![TokenKind::List, TokenKind::Array], self.peek_kind()))
3516 }
3517
3518 fn wrap_list_value_type(
3519 element: ValueType,
3520 kind: TokenKind,
3521 group: bool,
3522 max_length: Option<u64>,
3523 offset: usize,
3524 ) -> Result<ValueType> {
3525 if group {
3526 return Err(Error::Message {
3527 offset,
3528 message: "GROUP list value type names are not user-visible standard GQL syntax"
3529 .to_owned(),
3530 });
3531 }
3532 let value_type = match (kind, group, max_length) {
3533 (TokenKind::List, false, Some(max_length)) => ValueType::ListWithLength {
3534 element: Box::new(element),
3535 max_length,
3536 },
3537 (TokenKind::List, false, None) => ValueType::List(Box::new(element)),
3538 (TokenKind::Array, false, Some(max_length)) => ValueType::ArrayWithLength {
3539 element: Box::new(element),
3540 max_length,
3541 },
3542 (TokenKind::Array, false, None) => ValueType::Array(Box::new(element)),
3543 _ => unreachable!("only LIST and ARRAY token kinds wrap list value types"),
3544 };
3545 Ok(value_type)
3546 }
3547
3548 fn parse_value_type_name(&mut self) -> Result<Identifier> {
3549 let mut parts = vec![self.parse_identifier()?.value];
3550 match parts[0].to_ascii_uppercase().as_str() {
3551 "BIG" | "SMALL" if self.peek_type_words(&["INTEGER"]) => {
3552 parts.push(self.bump().text);
3553 }
3554 "DOUBLE" if self.peek_type_words(&["PRECISION"]) => {
3555 parts.push(self.bump().text);
3556 }
3557 "CHAR" | "CHARACTER" if self.peek_type_words(&["VARYING"]) => {
3558 parts.push(self.bump().text);
3559 }
3560 "CHAR" | "CHARACTER" if self.peek_type_words(&["LARGE", "OBJECT"]) => {
3561 parts.push(self.bump().text);
3562 parts.push(self.bump().text);
3563 }
3564 "TIME" | "TIMESTAMP" | "DATETIME"
3565 if self.peek_type_words(&["WITH", "TIME", "ZONE"])
3566 || self.peek_type_words(&["WITHOUT", "TIME", "ZONE"]) =>
3567 {
3568 parts.push(self.bump().text);
3569 parts.push(self.bump().text);
3570 parts.push(self.bump().text);
3571 }
3572 "LOCAL" if self.peek_type_words(&["DATETIME"]) || self.peek_type_words(&["TIME"]) => {
3573 parts.push(self.bump().text);
3574 }
3575 "ZONED" if self.peek_type_words(&["DATETIME"]) || self.peek_type_words(&["TIME"]) => {
3576 parts.push(self.bump().text);
3577 }
3578 _ => {}
3579 }
3580 Ok(Identifier::new(parts.join(" ")))
3581 }
3582
3583 fn peek_type_words(&self, words: &[&str]) -> bool {
3584 words.iter().enumerate().all(|(offset, word)| {
3585 self.tokens.get(self.pos + offset).is_some_and(|token| {
3586 is_identifier_like(token.kind) && token.text.eq_ignore_ascii_case(word)
3587 })
3588 })
3589 }
3590
3591 fn expect_identifier_word(&mut self, word: &str) -> Result<Token> {
3592 if is_identifier_like(self.peek_kind()) && self.peek().text.eq_ignore_ascii_case(word) {
3593 Ok(self.bump())
3594 } else if self.at(TokenKind::Eof) {
3595 Err(self.eof_error())
3596 } else {
3597 Err(self.error_expected(vec![TokenKind::Identifier], self.peek_kind()))
3598 }
3599 }
3600
3601 fn parse_pattern_list(&mut self) -> Result<Vec<PathPattern>> {
3602 let mut patterns = Vec::new();
3603 loop {
3604 patterns.push(self.parse_path_pattern()?);
3605 if self.eat(TokenKind::Comma).is_none() {
3606 break;
3607 }
3608 }
3609 Ok(patterns)
3610 }
3611
3612 fn parse_insert_pattern_list(&mut self) -> Result<Vec<PathPattern>> {
3613 let mut patterns = Vec::new();
3614 loop {
3615 patterns.push(self.parse_insert_path_pattern()?);
3616 if self.eat(TokenKind::Comma).is_none() {
3617 break;
3618 }
3619 }
3620 Ok(patterns)
3621 }
3622
3623 fn parse_insert_path_pattern(&mut self) -> Result<PathPattern> {
3624 let start = self.parse_insert_node_pattern()?;
3625 let mut chains = Vec::new();
3626 while self.starts_insert_relationship() {
3627 let relationship = self.parse_insert_relationship_pattern()?;
3628 let node = self.parse_insert_node_pattern()?;
3629 chains.push(PathPatternChain { relationship, node });
3630 }
3631 let factors = path_pattern_factors_from_flat_path(&start, &chains);
3632 Ok(PathPattern {
3633 variable: None,
3634 prefix: None,
3635 parenthesized: None,
3636 start,
3637 factors,
3638 alternation: None,
3639 chains,
3640 alternatives: Vec::new(),
3641 })
3642 }
3643
3644 fn parse_path_pattern(&mut self) -> Result<PathPattern> {
3645 let variable =
3646 if is_identifier_like(self.peek_kind()) && self.peek_n_kind(1) == Some(TokenKind::Eq) {
3647 let variable = self.parse_identifier()?;
3648 self.expect(TokenKind::Eq)?;
3649 Some(variable)
3650 } else {
3651 None
3652 };
3653 let prefix = self.parse_optional_path_pattern_prefix()?;
3654 let PathPatternTerm {
3655 start,
3656 chains,
3657 factors,
3658 } = self.parse_path_pattern_term()?;
3659 let alternation = self.peek_path_pattern_alternation_operator();
3660 let mut alternatives = Vec::new();
3661 if let Some(alternation) = alternation {
3662 self.parse_path_pattern_alternation_operator()?;
3663 alternatives.push(self.parse_path_pattern_term()?);
3664 while self.peek_path_pattern_alternation_operator() == Some(alternation) {
3665 self.parse_path_pattern_alternation_operator()?;
3666 alternatives.push(self.parse_path_pattern_term()?);
3667 }
3668 }
3669 let parenthesized = match factors.as_slice() {
3670 [PathPatternFactor::Parenthesized(group)] if alternatives.is_empty() => {
3671 Some((**group).clone())
3672 }
3673 _ => None,
3674 };
3675 let (start, chains) = parenthesized.as_ref().map_or((start, chains), |group| {
3676 (group.pattern.start.clone(), group.pattern.chains.clone())
3677 });
3678 Ok(PathPattern {
3679 variable,
3680 prefix,
3681 parenthesized,
3682 start,
3683 chains,
3684 factors,
3685 alternation,
3686 alternatives,
3687 })
3688 }
3689
3690 fn starts_parenthesized_path_pattern_expression(&self) -> bool {
3691 if self.peek_kind() != TokenKind::LParen {
3692 return false;
3693 }
3694
3695 matches!(
3696 self.peek_n_kind(1),
3697 Some(
3698 TokenKind::LParen
3699 | TokenKind::Walk
3700 | TokenKind::Trail
3701 | TokenKind::Simple
3702 | TokenKind::Acyclic
3703 | TokenKind::Minus
3704 | TokenKind::ArrowLeft
3705 | TokenKind::ArrowRight
3706 | TokenKind::Tilde
3707 )
3708 ) || (self.peek_n_kind(1) == Some(TokenKind::Lt)
3709 && self.peek_n_kind(2) == Some(TokenKind::Tilde))
3710 || self.peek_n_kind(1).is_some_and(is_identifier_like)
3711 && self.peek_n_kind(2) == Some(TokenKind::Eq)
3712 }
3713
3714 fn parse_parenthesized_path_pattern_expression(
3715 &mut self,
3716 ) -> Result<ParenthesizedPathPatternExpression> {
3717 self.expect(TokenKind::LParen)?;
3718 let variable =
3719 if is_identifier_like(self.peek_kind()) && self.peek_n_kind(1) == Some(TokenKind::Eq) {
3720 let variable = self.parse_identifier()?;
3721 self.expect(TokenKind::Eq)?;
3722 Some(variable)
3723 } else {
3724 None
3725 };
3726 let prefix = self.parse_optional_path_mode_prefix();
3727 let pattern = self.parse_path_pattern()?;
3728 if pattern.variable.is_some() || pattern.prefix.is_some() {
3729 return Err(Error::Message {
3730 offset: self.peek().offset,
3731 message: "a parenthesized path body is a path expression; additional declarations or search prefixes are not allowed".into(),
3732 });
3733 }
3734 let where_clause = if self.eat(TokenKind::Where).is_some() {
3735 Some(self.parse_expr()?)
3736 } else {
3737 None
3738 };
3739 if let (Some(variable), Some(where_clause)) = (&variable, &where_clause) {
3740 if expr_references_identifier(where_clause, variable) {
3741 return Err(Error::Message {
3742 offset: self.peek().offset,
3743 message: format!(
3744 "parenthesized path pattern WHERE cannot reference path variable '{}'",
3745 variable.value
3746 ),
3747 });
3748 }
3749 }
3750 self.expect(TokenKind::RParen)?;
3751
3752 let questioned = self.eat(TokenKind::Question).is_some();
3753 let quantifier = if questioned {
3754 None
3755 } else {
3756 self.parse_optional_path_quantifier()?
3757 };
3758
3759 Ok(ParenthesizedPathPatternExpression {
3760 variable,
3761 prefix,
3762 pattern: Box::new(pattern),
3763 where_clause,
3764 quantifier,
3765 questioned,
3766 })
3767 }
3768
3769 fn parse_path_pattern_term(&mut self) -> Result<PathPatternTerm> {
3770 let mut factors = self.parse_path_pattern_factor()?;
3771 while self.starts_path_pattern_factor() {
3772 factors.extend(self.parse_path_pattern_factor()?);
3773 }
3774
3775 self.path_pattern_term_from_factors(factors)
3776 }
3777
3778 fn starts_path_pattern_factor(&self) -> bool {
3779 self.starts_parenthesized_path_pattern_expression()
3780 || self.starts_simplified_path_pattern_expression()
3781 || self.at(TokenKind::LParen)
3782 || self.starts_relationship()
3783 }
3784
3785 fn parse_path_pattern_factor(&mut self) -> Result<Vec<PathPatternFactor>> {
3786 if self.starts_parenthesized_path_pattern_expression() {
3787 return Ok(vec![PathPatternFactor::Parenthesized(Box::new(
3788 self.parse_parenthesized_path_pattern_expression()?,
3789 ))]);
3790 }
3791 if self.starts_simplified_path_pattern_expression() {
3792 return Ok(match self.parse_simplified_path_pattern_expression()? {
3793 SimplifiedPathPatternExpression::Linear(relationships) => relationships
3794 .into_iter()
3795 .map(PathPatternFactor::Relationship)
3796 .collect(),
3797 SimplifiedPathPatternExpression::Alternation {
3798 alternation,
3799 alternatives,
3800 } => vec![PathPatternFactor::Alternation {
3801 alternation,
3802 alternatives: alternatives
3803 .into_iter()
3804 .map(|relationships| {
3805 relationships
3806 .into_iter()
3807 .map(PathPatternFactor::Relationship)
3808 .collect()
3809 })
3810 .collect(),
3811 }],
3812 });
3813 }
3814 if self.at(TokenKind::LParen) {
3815 return Ok(vec![PathPatternFactor::Node(self.parse_node_pattern()?)]);
3816 }
3817 if self.starts_relationship() {
3818 return Ok(vec![PathPatternFactor::Relationship(
3819 self.parse_relationship_pattern()?,
3820 )]);
3821 }
3822
3823 Err(self.error_expected(vec![TokenKind::LParen], self.peek_kind()))
3824 }
3825
3826 fn starts_simplified_path_pattern_expression(&self) -> bool {
3827 matches!(
3828 (self.peek_kind(), self.peek_n_kind(1), self.peek_n_kind(2)),
3829 (TokenKind::Minus, Some(TokenKind::Slash), _)
3830 | (TokenKind::Tilde, Some(TokenKind::Slash), _)
3831 | (TokenKind::ArrowLeft, Some(TokenKind::Slash), _)
3832 | (
3833 TokenKind::Lt,
3834 Some(TokenKind::Tilde),
3835 Some(TokenKind::Slash)
3836 )
3837 )
3838 }
3839
3840 fn parse_simplified_path_pattern_expression(
3841 &mut self,
3842 ) -> Result<SimplifiedPathPatternExpression> {
3843 let prefix = self.parse_simplified_delimiter_prefix()?;
3844 let mut branches = vec![self.parse_simplified_relationship_body_sequence()?];
3845 let alternation = self.peek_path_pattern_alternation_operator();
3846 if let Some(alternation) = alternation {
3847 self.parse_path_pattern_alternation_operator()?;
3848 branches.push(self.parse_simplified_relationship_body_sequence()?);
3849 while self.peek_path_pattern_alternation_operator() == Some(alternation) {
3850 self.parse_path_pattern_alternation_operator()?;
3851 branches.push(self.parse_simplified_relationship_body_sequence()?);
3852 }
3853 }
3854 let direction = self.parse_simplified_delimiter_suffix(prefix)?;
3855 let quantifier = self.parse_optional_path_quantifier()?;
3856
3857 let alternatives = branches
3858 .into_iter()
3859 .map(|bodies| self.simplified_relationships_from_bodies(bodies, direction, &quantifier))
3860 .collect::<Vec<_>>();
3861
3862 if let Some(alternation) = alternation {
3863 Ok(SimplifiedPathPatternExpression::Alternation {
3864 alternation,
3865 alternatives,
3866 })
3867 } else {
3868 Ok(SimplifiedPathPatternExpression::Linear(
3869 alternatives.into_iter().next().unwrap_or_default(),
3870 ))
3871 }
3872 }
3873
3874 fn parse_simplified_relationship_body_sequence(
3875 &mut self,
3876 ) -> Result<Vec<SimplifiedRelationshipBody>> {
3877 let mut bodies = vec![self.parse_simplified_relationship_body()?];
3878 while !matches!(self.peek_kind(), TokenKind::Slash | TokenKind::Pipe) {
3879 bodies.push(self.parse_simplified_relationship_body()?);
3880 }
3881 Ok(bodies)
3882 }
3883
3884 fn simplified_relationships_from_bodies(
3885 &self,
3886 bodies: Vec<SimplifiedRelationshipBody>,
3887 direction: Direction,
3888 quantifier: &Option<PathPatternQuantifier>,
3889 ) -> Vec<RelationshipPattern> {
3890 let last = bodies.len().saturating_sub(1);
3891 bodies
3892 .into_iter()
3893 .enumerate()
3894 .map(|(index, body)| RelationshipPattern {
3895 direction: body.direction_override.unwrap_or(direction),
3896 variable: None,
3897 temporary: false,
3898 labels: body.labels,
3899 label_expression: Some(body.label_expression),
3900 properties: None,
3901 where_clause: None,
3902 quantifier: body.quantifier.or_else(|| {
3903 if index == last {
3904 quantifier.clone()
3905 } else {
3906 None
3907 }
3908 }),
3909 })
3910 .collect()
3911 }
3912
3913 fn parse_simplified_relationship_body(&mut self) -> Result<SimplifiedRelationshipBody> {
3914 let leading_override = self.parse_optional_simplified_direction_override_prefix()?;
3915 let label_expression = self.parse_simplified_label_expression()?;
3916 let mut labels = Vec::new();
3917 collect_label_names(&label_expression, &mut labels);
3918 Ok(SimplifiedRelationshipBody {
3919 labels,
3920 label_expression,
3921 direction_override: self
3922 .parse_optional_simplified_direction_override_suffix(leading_override)?,
3923 quantifier: self.parse_optional_path_quantifier()?,
3924 })
3925 }
3926
3927 fn parse_simplified_label_expression(&mut self) -> Result<LabelExpression> {
3928 self.parse_label_and()
3929 }
3930
3931 fn parse_optional_simplified_direction_override_prefix(&mut self) -> Result<Option<Direction>> {
3932 if self.eat(TokenKind::Lt).is_some() {
3933 if self.eat(TokenKind::Tilde).is_some() {
3934 return Ok(Some(Direction::LeftOrUndirected));
3935 }
3936 return Ok(Some(Direction::Left));
3937 }
3938 if self.eat(TokenKind::Tilde).is_some() {
3939 return Ok(Some(Direction::Undirected));
3940 }
3941 if self.eat(TokenKind::Minus).is_some() {
3942 return Ok(Some(Direction::Any));
3943 }
3944 Ok(None)
3945 }
3946
3947 fn parse_optional_simplified_direction_override_suffix(
3948 &mut self,
3949 leading_override: Option<Direction>,
3950 ) -> Result<Option<Direction>> {
3951 if self.eat(TokenKind::Gt).is_some() {
3952 return Ok(Some(match leading_override {
3953 Some(Direction::Left) => Direction::LeftOrRight,
3954 Some(Direction::Undirected) => Direction::UndirectedOrRight,
3955 Some(direction) => direction,
3956 None => Direction::Right,
3957 }));
3958 }
3959 Ok(leading_override)
3960 }
3961
3962 fn parse_simplified_delimiter_prefix(&mut self) -> Result<SimplifiedPrefix> {
3963 if self.eat(TokenKind::Minus).is_some() {
3964 self.expect(TokenKind::Slash)?;
3965 return Ok(SimplifiedPrefix::Minus);
3966 }
3967 if self.eat(TokenKind::Tilde).is_some() {
3968 self.expect(TokenKind::Slash)?;
3969 return Ok(SimplifiedPrefix::Tilde);
3970 }
3971 if self.eat(TokenKind::ArrowLeft).is_some() {
3972 self.expect(TokenKind::Slash)?;
3973 return Ok(SimplifiedPrefix::ArrowLeft);
3974 }
3975 self.expect(TokenKind::Lt)?;
3976 self.expect(TokenKind::Tilde)?;
3977 self.expect(TokenKind::Slash)?;
3978 Ok(SimplifiedPrefix::LtTilde)
3979 }
3980
3981 fn parse_simplified_delimiter_suffix(&mut self, prefix: SimplifiedPrefix) -> Result<Direction> {
3982 self.expect(TokenKind::Slash)?;
3983 match prefix {
3984 SimplifiedPrefix::Minus => {
3985 if self.eat(TokenKind::ArrowRight).is_some() {
3986 Ok(Direction::Right)
3987 } else {
3988 self.expect(TokenKind::Minus)?;
3989 Ok(Direction::Any)
3990 }
3991 }
3992 SimplifiedPrefix::ArrowLeft => {
3993 if self.eat(TokenKind::ArrowRight).is_some() {
3994 Ok(Direction::LeftOrRight)
3995 } else {
3996 self.expect(TokenKind::Minus)?;
3997 Ok(Direction::Left)
3998 }
3999 }
4000 SimplifiedPrefix::Tilde => {
4001 self.expect(TokenKind::Tilde)?;
4002 if self.eat(TokenKind::Gt).is_some() {
4003 Ok(Direction::UndirectedOrRight)
4004 } else {
4005 Ok(Direction::Undirected)
4006 }
4007 }
4008 SimplifiedPrefix::LtTilde => {
4009 self.expect(TokenKind::Tilde)?;
4010 Ok(Direction::LeftOrUndirected)
4011 }
4012 }
4013 }
4014
4015 fn path_pattern_term_from_factors(
4016 &self,
4017 factors: Vec<PathPatternFactor>,
4018 ) -> Result<PathPatternTerm> {
4019 let mut start = None;
4020 let mut chains = Vec::new();
4021 let mut pending_relationship = None;
4022 for factor in &factors {
4023 apply_path_pattern_factor_to_term(
4024 factor,
4025 &mut start,
4026 &mut chains,
4027 &mut pending_relationship,
4028 );
4029 }
4030 if let Some(relationship) = pending_relationship {
4031 if start.is_none() {
4032 start = Some(empty_node_pattern());
4033 }
4034 chains.push(PathPatternChain {
4035 relationship,
4036 node: empty_node_pattern(),
4037 });
4038 }
4039
4040 let start =
4041 start.ok_or_else(|| self.error_expected(vec![TokenKind::LParen], self.peek_kind()))?;
4042
4043 Ok(PathPatternTerm {
4044 start,
4045 chains,
4046 factors,
4047 })
4048 }
4049
4050 fn peek_path_pattern_alternation_operator(&self) -> Option<PathPatternAlternation> {
4051 if self.peek_kind() == TokenKind::Pipe && self.peek_n_kind(1) == Some(TokenKind::Plus) {
4052 Some(PathPatternAlternation::Multiset)
4053 } else if self.peek_kind() == TokenKind::Pipe {
4054 Some(PathPatternAlternation::Union)
4055 } else {
4056 None
4057 }
4058 }
4059
4060 fn parse_path_pattern_alternation_operator(&mut self) -> Result<PathPatternAlternation> {
4061 self.expect(TokenKind::Pipe)?;
4062 if self.eat(TokenKind::Plus).is_some() {
4063 self.expect(TokenKind::Pipe)?;
4064 Ok(PathPatternAlternation::Multiset)
4065 } else {
4066 Ok(PathPatternAlternation::Union)
4067 }
4068 }
4069
4070 fn parse_optional_path_pattern_prefix(&mut self) -> Result<Option<PathPatternPrefix>> {
4071 if matches!(
4072 self.peek_kind(),
4073 TokenKind::All | TokenKind::Any | TokenKind::Shortest
4074 ) {
4075 return self.parse_optional_path_search_prefix();
4076 }
4077
4078 Ok(self.parse_optional_path_mode_prefix())
4079 }
4080
4081 fn parse_optional_path_mode_prefix(&mut self) -> Option<PathPatternPrefix> {
4082 let mode = self.parse_optional_path_mode()?;
4083
4084 let path_or_paths = self.parse_optional_path_or_paths();
4085
4086 Some(PathPatternPrefix::Mode {
4087 mode,
4088 path_or_paths,
4089 })
4090 }
4091
4092 fn parse_required_path_pattern_prefix(&mut self) -> Result<PathPatternPrefix> {
4093 self.parse_optional_path_pattern_prefix()?.ok_or_else(|| {
4094 self.error_expected(
4095 vec![
4096 TokenKind::Walk,
4097 TokenKind::Trail,
4098 TokenKind::Simple,
4099 TokenKind::Acyclic,
4100 TokenKind::All,
4101 TokenKind::Any,
4102 TokenKind::Shortest,
4103 ],
4104 self.peek_kind(),
4105 )
4106 })
4107 }
4108
4109 fn parse_optional_path_search_prefix(&mut self) -> Result<Option<PathPatternPrefix>> {
4110 let search = if self.eat(TokenKind::All).is_some() {
4111 if self.eat(TokenKind::Shortest).is_some() {
4112 PathSearchPrefix::AllShortest {
4113 mode: self.parse_optional_path_mode(),
4114 path_or_paths: self.parse_optional_path_or_paths(),
4115 }
4116 } else {
4117 PathSearchPrefix::All {
4118 mode: self.parse_optional_path_mode(),
4119 path_or_paths: self.parse_optional_path_or_paths(),
4120 }
4121 }
4122 } else if self.eat(TokenKind::Any).is_some() {
4123 if self.eat(TokenKind::Shortest).is_some() {
4124 PathSearchPrefix::AnyShortest {
4125 mode: self.parse_optional_path_mode(),
4126 path_or_paths: self.parse_optional_path_or_paths(),
4127 }
4128 } else {
4129 let count = self.parse_optional_unsigned_integer_specification()?;
4130 PathSearchPrefix::Any {
4131 count,
4132 mode: self.parse_optional_path_mode(),
4133 path_or_paths: self.parse_optional_path_or_paths(),
4134 }
4135 }
4136 } else if self.eat(TokenKind::Shortest).is_some() {
4137 let count = self.parse_optional_unsigned_integer_specification()?;
4138 let mode = self.parse_optional_path_mode();
4139 let path_or_paths = self.parse_optional_path_or_paths();
4140
4141 if self.eat(TokenKind::Group).is_some() {
4142 PathSearchPrefix::CountedShortestGroup {
4143 count,
4144 mode,
4145 path_or_paths,
4146 groups: false,
4147 }
4148 } else if self.eat(TokenKind::Groups).is_some() {
4149 PathSearchPrefix::CountedShortestGroup {
4150 count,
4151 mode,
4152 path_or_paths,
4153 groups: true,
4154 }
4155 } else if let Some(count) = count {
4156 PathSearchPrefix::CountedShortest {
4157 count,
4158 mode,
4159 path_or_paths,
4160 }
4161 } else {
4162 PathSearchPrefix::Shortest {
4163 mode,
4164 path_or_paths,
4165 }
4166 }
4167 } else {
4168 return Ok(None);
4169 };
4170
4171 Ok(Some(PathPatternPrefix::Search(search)))
4172 }
4173
4174 fn parse_optional_unsigned_integer_specification(
4175 &mut self,
4176 ) -> Result<Option<UnsignedIntegerSpecification>> {
4177 if self.at(TokenKind::Integer) {
4178 return Ok(Some(UnsignedIntegerSpecification::Literal(
4179 self.parse_u64_literal()?,
4180 )));
4181 }
4182 if self.at(TokenKind::Parameter) {
4183 let token = self.bump();
4184 return Ok(Some(UnsignedIntegerSpecification::Parameter(
4185 parameter_name(&token.text),
4186 )));
4187 }
4188 Ok(None)
4189 }
4190
4191 fn parse_unsigned_integer_specification(&mut self) -> Result<UnsignedIntegerSpecification> {
4192 self.parse_optional_unsigned_integer_specification()?
4193 .ok_or_else(|| {
4194 self.error_expected(
4195 vec![TokenKind::Integer, TokenKind::Parameter],
4196 self.peek_kind(),
4197 )
4198 })
4199 }
4200
4201 fn parse_optional_path_mode(&mut self) -> Option<PathMode> {
4202 if self.eat(TokenKind::Walk).is_some() {
4203 Some(PathMode::Walk)
4204 } else if self.eat(TokenKind::Trail).is_some() {
4205 Some(PathMode::Trail)
4206 } else if self.eat(TokenKind::Simple).is_some() {
4207 Some(PathMode::Simple)
4208 } else if self.eat(TokenKind::Acyclic).is_some() {
4209 Some(PathMode::Acyclic)
4210 } else {
4211 None
4212 }
4213 }
4214
4215 fn parse_optional_path_or_paths(&mut self) -> Option<PathOrPaths> {
4216 if self.eat(TokenKind::Path).is_some() {
4217 Some(PathOrPaths::Path)
4218 } else if self.eat(TokenKind::Paths).is_some() {
4219 Some(PathOrPaths::Paths)
4220 } else {
4221 None
4222 }
4223 }
4224
4225 fn starts_relationship(&self) -> bool {
4226 matches!(
4227 self.peek_kind(),
4228 TokenKind::Minus | TokenKind::ArrowLeft | TokenKind::ArrowRight | TokenKind::Tilde
4229 ) || (self.peek_kind() == TokenKind::Lt && self.peek_n_kind(1) == Some(TokenKind::Tilde))
4230 }
4231
4232 fn starts_insert_relationship(&self) -> bool {
4233 matches!(
4234 self.peek_kind(),
4235 TokenKind::Minus | TokenKind::ArrowLeft | TokenKind::Tilde
4236 )
4237 }
4238
4239 fn parse_node_pattern(&mut self) -> Result<NodePattern> {
4240 self.expect(TokenKind::LParen)?;
4241 let (variable, temporary, labels, label_expression, properties, where_clause) =
4242 self.parse_pattern_element_body(TokenKind::RParen)?;
4243 self.expect(TokenKind::RParen)?;
4244 let quantifier = self.parse_optional_path_quantifier()?;
4245 Ok(NodePattern {
4246 variable,
4247 temporary,
4248 labels,
4249 label_expression,
4250 properties,
4251 where_clause,
4252 quantifier,
4253 })
4254 }
4255
4256 fn parse_insert_node_pattern(&mut self) -> Result<NodePattern> {
4257 self.expect(TokenKind::LParen)?;
4258 let (variable, labels, label_expression, properties) = if self.at(TokenKind::RParen) {
4259 (None, Vec::new(), None, None)
4260 } else {
4261 self.parse_insert_element_pattern_body(TokenKind::RParen)?
4262 };
4263 self.expect(TokenKind::RParen)?;
4264 Ok(NodePattern {
4265 variable,
4266 temporary: false,
4267 labels,
4268 label_expression,
4269 properties,
4270 where_clause: None,
4271 quantifier: None,
4272 })
4273 }
4274
4275 fn parse_relationship_pattern(&mut self) -> Result<RelationshipPattern> {
4276 if self.eat(TokenKind::ArrowLeft).is_some() {
4277 let (
4278 direction,
4279 variable,
4280 temporary,
4281 labels,
4282 label_expression,
4283 properties,
4284 where_clause,
4285 ) = if self.eat(TokenKind::LBracket).is_some() {
4286 let (variable, temporary, labels, label_expression, properties, where_clause) =
4287 self.parse_pattern_element_body(TokenKind::RBracket)?;
4288 self.expect(TokenKind::RBracket)?;
4289 let direction = if self.eat(TokenKind::ArrowRight).is_some() {
4290 Direction::LeftOrRight
4291 } else {
4292 self.expect(TokenKind::Minus)?;
4293 Direction::Left
4294 };
4295 (
4296 direction,
4297 variable,
4298 temporary,
4299 labels,
4300 label_expression,
4301 properties,
4302 where_clause,
4303 )
4304 } else {
4305 let direction = if self.eat(TokenKind::Gt).is_some() {
4306 Direction::LeftOrRight
4307 } else {
4308 Direction::Left
4309 };
4310 (direction, None, false, Vec::new(), None, None, None)
4311 };
4312 return Ok(RelationshipPattern {
4313 direction,
4314 variable,
4315 temporary,
4316 labels,
4317 label_expression,
4318 properties,
4319 where_clause,
4320 quantifier: self.parse_optional_path_quantifier()?,
4321 });
4322 }
4323
4324 if self.eat(TokenKind::Lt).is_some() {
4325 self.expect(TokenKind::Tilde)?;
4326 if self.eat(TokenKind::LBracket).is_some() {
4327 let (variable, temporary, labels, label_expression, properties, where_clause) =
4328 self.parse_pattern_element_body(TokenKind::RBracket)?;
4329 self.expect(TokenKind::RBracket)?;
4330 self.expect(TokenKind::Tilde)?;
4331 return Ok(RelationshipPattern {
4332 direction: Direction::LeftOrUndirected,
4333 variable,
4334 temporary,
4335 labels,
4336 label_expression,
4337 properties,
4338 where_clause,
4339 quantifier: self.parse_optional_path_quantifier()?,
4340 });
4341 }
4342 return Ok(RelationshipPattern {
4343 direction: Direction::LeftOrUndirected,
4344 variable: None,
4345 temporary: false,
4346 labels: Vec::new(),
4347 label_expression: None,
4348 properties: None,
4349 where_clause: None,
4350 quantifier: self.parse_optional_path_quantifier()?,
4351 });
4352 }
4353
4354 if self.eat(TokenKind::ArrowRight).is_some() {
4355 return Ok(RelationshipPattern {
4356 direction: Direction::Right,
4357 variable: None,
4358 temporary: false,
4359 labels: Vec::new(),
4360 label_expression: None,
4361 properties: None,
4362 where_clause: None,
4363 quantifier: self.parse_optional_path_quantifier()?,
4364 });
4365 }
4366
4367 if self.eat(TokenKind::Tilde).is_some() {
4368 let (
4369 direction,
4370 variable,
4371 temporary,
4372 labels,
4373 label_expression,
4374 properties,
4375 where_clause,
4376 ) = if self.eat(TokenKind::LBracket).is_some() {
4377 let (variable, temporary, labels, label_expression, properties, where_clause) =
4378 self.parse_pattern_element_body(TokenKind::RBracket)?;
4379 self.expect(TokenKind::RBracket)?;
4380 self.expect(TokenKind::Tilde)?;
4381 let direction = if self.eat(TokenKind::Gt).is_some() {
4382 Direction::UndirectedOrRight
4383 } else {
4384 Direction::Undirected
4385 };
4386 (
4387 direction,
4388 variable,
4389 temporary,
4390 labels,
4391 label_expression,
4392 properties,
4393 where_clause,
4394 )
4395 } else {
4396 let direction = if self.eat(TokenKind::Gt).is_some() {
4397 Direction::UndirectedOrRight
4398 } else {
4399 Direction::Undirected
4400 };
4401 (direction, None, false, Vec::new(), None, None, None)
4402 };
4403 return Ok(RelationshipPattern {
4404 direction,
4405 variable,
4406 temporary,
4407 labels,
4408 label_expression,
4409 properties,
4410 where_clause,
4411 quantifier: self.parse_optional_path_quantifier()?,
4412 });
4413 }
4414
4415 self.expect(TokenKind::Minus)?;
4416 let has_body = self.eat(TokenKind::LBracket).is_some();
4417 let (variable, temporary, labels, label_expression, properties, where_clause) = if has_body
4418 {
4419 let body = self.parse_pattern_element_body(TokenKind::RBracket)?;
4420 self.expect(TokenKind::RBracket)?;
4421 body
4422 } else {
4423 (None, false, Vec::new(), None, None, None)
4424 };
4425
4426 let (direction, quantifier) = if self.eat(TokenKind::ArrowRight).is_some() {
4427 (Direction::Right, self.parse_optional_path_quantifier()?)
4428 } else if self.eat(TokenKind::Minus).is_some() {
4429 (Direction::Any, self.parse_optional_path_quantifier()?)
4430 } else if has_body {
4431 return Err(self.error_expected(
4432 vec![TokenKind::ArrowRight, TokenKind::Minus],
4433 self.peek_kind(),
4434 ));
4435 } else {
4436 (Direction::Any, self.parse_optional_path_quantifier()?)
4437 };
4438
4439 Ok(RelationshipPattern {
4440 direction,
4441 variable,
4442 temporary,
4443 labels,
4444 label_expression,
4445 properties,
4446 where_clause,
4447 quantifier,
4448 })
4449 }
4450
4451 fn parse_insert_relationship_pattern(&mut self) -> Result<RelationshipPattern> {
4452 if self.eat(TokenKind::ArrowLeft).is_some() {
4453 self.expect(TokenKind::LBracket)?;
4454 let (variable, labels, label_expression, properties) = if self.at(TokenKind::RBracket) {
4455 (None, Vec::new(), None, None)
4456 } else {
4457 self.parse_insert_element_pattern_body(TokenKind::RBracket)?
4458 };
4459 self.expect(TokenKind::RBracket)?;
4460 self.expect(TokenKind::Minus)?;
4461 return Ok(RelationshipPattern {
4462 direction: Direction::Left,
4463 variable,
4464 temporary: false,
4465 labels,
4466 label_expression,
4467 properties,
4468 where_clause: None,
4469 quantifier: None,
4470 });
4471 }
4472
4473 if self.eat(TokenKind::Tilde).is_some() {
4474 self.expect(TokenKind::LBracket)?;
4475 let (variable, labels, label_expression, properties) = if self.at(TokenKind::RBracket) {
4476 (None, Vec::new(), None, None)
4477 } else {
4478 self.parse_insert_element_pattern_body(TokenKind::RBracket)?
4479 };
4480 self.expect(TokenKind::RBracket)?;
4481 self.expect(TokenKind::Tilde)?;
4482 return Ok(RelationshipPattern {
4483 direction: Direction::Undirected,
4484 variable,
4485 temporary: false,
4486 labels,
4487 label_expression,
4488 properties,
4489 where_clause: None,
4490 quantifier: None,
4491 });
4492 }
4493
4494 self.expect(TokenKind::Minus)?;
4495 self.expect(TokenKind::LBracket)?;
4496 let (variable, labels, label_expression, properties) = if self.at(TokenKind::RBracket) {
4497 (None, Vec::new(), None, None)
4498 } else {
4499 self.parse_insert_element_pattern_body(TokenKind::RBracket)?
4500 };
4501 self.expect(TokenKind::RBracket)?;
4502 let direction = if self.eat(TokenKind::ArrowRight).is_some() {
4503 Direction::Right
4504 } else {
4505 self.expect(TokenKind::Minus)?;
4506 Direction::Undirected
4507 };
4508 Ok(RelationshipPattern {
4509 direction,
4510 variable,
4511 temporary: false,
4512 labels,
4513 label_expression,
4514 properties,
4515 where_clause: None,
4516 quantifier: None,
4517 })
4518 }
4519
4520 fn parse_pattern_element_body(&mut self, terminator: TokenKind) -> Result<PatternElementBody> {
4521 let temporary =
4522 self.at(TokenKind::Temp) && self.peek_n_kind(1).is_some_and(is_identifier_like);
4523 if temporary {
4524 return Err(Error::Message {
4525 offset: self.peek().offset,
4526 message:
4527 "TEMP element variable declarations are not user-visible standard GQL syntax"
4528 .to_owned(),
4529 });
4530 }
4531
4532 let variable = if self.starts_element_variable() {
4533 Some(self.parse_identifier()?)
4534 } else {
4535 None
4536 };
4537
4538 let mut labels = Vec::new();
4539 let mut label_expression = None;
4540 while self.eat(TokenKind::Colon).is_some() || self.eat(TokenKind::Is).is_some() {
4541 let expr = self.parse_label_expression()?;
4542 collect_label_names(&expr, &mut labels);
4543 label_expression = Some(match label_expression {
4544 Some(existing) => LabelExpression::And(Box::new(existing), Box::new(expr)),
4545 None => expr,
4546 });
4547 }
4548
4549 let (properties, where_clause) = if self.at(TokenKind::LBrace) {
4550 (Some(self.parse_map_literal()?), None)
4551 } else if self.eat(TokenKind::Where).is_some() {
4552 (None, Some(self.parse_expr()?))
4553 } else {
4554 (None, None)
4555 };
4556
4557 if !self.at(terminator) {
4558 return Err(self.error_expected(vec![terminator], self.peek_kind()));
4559 }
4560 Ok((
4561 variable,
4562 temporary,
4563 labels,
4564 label_expression,
4565 properties,
4566 where_clause,
4567 ))
4568 }
4569
4570 fn parse_insert_element_pattern_body(
4571 &mut self,
4572 terminator: TokenKind,
4573 ) -> Result<InsertElementBody> {
4574 let variable = if self.starts_element_variable()
4575 && !matches!(self.peek_n_kind(1), Some(TokenKind::Ampersand) | None)
4576 {
4577 Some(self.parse_identifier()?)
4578 } else {
4579 None
4580 };
4581
4582 let (labels, label_expression) =
4583 if self.eat(TokenKind::Colon).is_some() || self.eat(TokenKind::Is).is_some() {
4584 let expr = self.parse_label_expression()?;
4585 let mut labels = Vec::new();
4586 collect_label_names(&expr, &mut labels);
4587 (labels, Some(expr))
4588 } else if is_identifier_like(self.peek_kind()) {
4589 self.parse_insert_label_set()?
4590 } else {
4591 (Vec::new(), None)
4592 };
4593
4594 let properties = if self.at(TokenKind::LBrace) {
4595 Some(self.parse_map_literal()?)
4596 } else {
4597 None
4598 };
4599
4600 if !self.at(terminator) {
4601 return Err(self.error_expected(vec![terminator], self.peek_kind()));
4602 }
4603 Ok((variable, labels, label_expression, properties))
4604 }
4605
4606 fn starts_element_variable(&self) -> bool {
4607 is_identifier_like(self.peek_kind())
4608 && !matches!(self.peek_kind(), TokenKind::Is | TokenKind::Where)
4609 }
4610
4611 fn parse_insert_label_set(&mut self) -> Result<(Vec<Identifier>, Option<LabelExpression>)> {
4612 let mut labels = Vec::new();
4613 let label = self.parse_identifier()?;
4614 push_identifier_if_absent(&mut labels, Some(&label));
4615 while self.eat(TokenKind::Ampersand).is_some() {
4616 let label = self.parse_identifier()?;
4617 push_identifier_if_absent(&mut labels, Some(&label));
4618 }
4619
4620 let mut iter = labels.iter().cloned();
4621 let first = iter
4622 .next()
4623 .ok_or_else(|| self.error_expected(vec![TokenKind::Identifier], self.peek_kind()))?;
4624 let mut expr = LabelExpression::Label(first);
4625 for label in iter {
4626 expr = LabelExpression::And(Box::new(expr), Box::new(LabelExpression::Label(label)));
4627 }
4628
4629 Ok((labels, Some(expr)))
4630 }
4631
4632 fn parse_optional_path_quantifier(&mut self) -> Result<Option<PathPatternQuantifier>> {
4633 if self.eat(TokenKind::Star).is_some() {
4634 return Ok(Some(PathPatternQuantifier::ZeroOrMore));
4635 }
4636 if self.eat(TokenKind::Plus).is_some() {
4637 return Ok(Some(PathPatternQuantifier::OneOrMore));
4638 }
4639 if self.eat(TokenKind::Question).is_some() {
4640 return Ok(Some(PathPatternQuantifier::Optional));
4641 }
4642 if self.eat(TokenKind::LBrace).is_none() {
4643 return Ok(None);
4644 }
4645
4646 let min = if self.at(TokenKind::Integer) {
4647 Some(self.parse_u64_literal()?)
4648 } else {
4649 None
4650 };
4651 let quantifier = if self.eat(TokenKind::Comma).is_some() {
4652 let max = if self.at(TokenKind::Integer) {
4653 Some(self.parse_u64_literal()?)
4654 } else {
4655 None
4656 };
4657 if let Some(max) = max {
4658 if min.unwrap_or(0) > max {
4659 return Err(Error::Message {
4660 offset: self.peek().offset,
4661 message: "path quantifier lower bound exceeds upper bound".to_owned(),
4662 });
4663 }
4664 }
4665 PathPatternQuantifier::Range { min, max }
4666 } else {
4667 let value = min.ok_or_else(|| {
4668 self.error_expected(vec![TokenKind::Integer, TokenKind::Comma], self.peek_kind())
4669 })?;
4670 PathPatternQuantifier::Fixed(value)
4671 };
4672 self.expect(TokenKind::RBrace)?;
4673 Ok(Some(quantifier))
4674 }
4675
4676 fn parse_u64_literal(&mut self) -> Result<u64> {
4677 let token = self.expect(TokenKind::Integer)?;
4678 token.text.parse::<u64>().map_err(|_| Error::BadNumber {
4679 offset: token.offset,
4680 token_text: token.text,
4681 })
4682 }
4683
4684 fn parse_positive_u64_literal(&mut self, description: &str) -> Result<u64> {
4685 let value = self.parse_u64_literal()?;
4686 self.ensure_positive_u64(value, description)?;
4687 Ok(value)
4688 }
4689
4690 fn ensure_positive_u64(&self, value: u64, description: &str) -> Result<()> {
4691 if value == 0 {
4692 return Err(Error::Message {
4693 offset: self.peek().offset,
4694 message: format!("{description} must be greater than or equal to 1"),
4695 });
4696 }
4697 Ok(())
4698 }
4699
4700 fn parse_label_expression(&mut self) -> Result<LabelExpression> {
4701 self.parse_label_or()
4702 }
4703
4704 fn parse_label_or(&mut self) -> Result<LabelExpression> {
4705 let mut expr = self.parse_label_and()?;
4706 let mut chain = 1u32;
4707 while self.eat(TokenKind::Pipe).is_some() {
4708 chain += 1;
4709 self.check_chain(chain)?;
4710 let right = self.parse_label_and()?;
4711 expr = LabelExpression::Or(Box::new(expr), Box::new(right));
4712 }
4713 Ok(expr)
4714 }
4715
4716 fn parse_label_and(&mut self) -> Result<LabelExpression> {
4717 let mut expr = self.parse_label_unary()?;
4718 let mut chain = 1u32;
4719 while self.eat(TokenKind::Ampersand).is_some() {
4720 chain += 1;
4721 self.check_chain(chain)?;
4722 let right = self.parse_label_unary()?;
4723 expr = LabelExpression::And(Box::new(expr), Box::new(right));
4724 }
4725 Ok(expr)
4726 }
4727
4728 fn parse_label_unary(&mut self) -> Result<LabelExpression> {
4729 self.enter()?;
4730 let expr = self.parse_label_unary_body();
4731 self.exit();
4732 expr
4733 }
4734
4735 fn parse_label_unary_body(&mut self) -> Result<LabelExpression> {
4736 if self.at(TokenKind::Not) {
4737 return Err(Error::Message {
4738 offset: self.peek().offset,
4739 message: "label negation uses !, not NOT".to_owned(),
4740 });
4741 }
4742 if self.eat(TokenKind::Bang).is_some() {
4743 return Ok(LabelExpression::Not(Box::new(self.parse_label_unary()?)));
4744 }
4745 if self.eat(TokenKind::LParen).is_some() {
4746 let expr = self.parse_label_expression()?;
4747 self.expect(TokenKind::RParen)?;
4748 return Ok(LabelExpression::Parenthesized(Box::new(expr)));
4749 }
4750 if self.eat(TokenKind::Percent).is_some() {
4751 return Ok(LabelExpression::Wildcard);
4752 }
4753 Ok(LabelExpression::Label(self.parse_identifier()?))
4754 }
4755
4756 fn parse_expr(&mut self) -> Result<Expr> {
4757 self.enter()?;
4758 let expr = self.parse_or();
4759 self.exit();
4760 expr
4761 }
4762
4763 fn parse_or(&mut self) -> Result<Expr> {
4764 let mut expr = self.parse_and()?;
4765 let mut chain = 1u32;
4766 loop {
4767 let op = if self.eat(TokenKind::Or).is_some() {
4768 BinaryOp::Or
4769 } else if self.eat(TokenKind::Xor).is_some() {
4770 BinaryOp::Xor
4771 } else {
4772 break;
4773 };
4774 chain += 1;
4775 self.check_chain(chain)?;
4776 let right = self.parse_and()?;
4777 expr = Expr::Binary {
4778 left: Box::new(expr),
4779 op,
4780 right: Box::new(right),
4781 };
4782 }
4783 Ok(expr)
4784 }
4785
4786 fn parse_and(&mut self) -> Result<Expr> {
4787 let mut expr = self.parse_not()?;
4788 let mut chain = 1u32;
4789 while self.eat(TokenKind::And).is_some() {
4790 chain += 1;
4791 self.check_chain(chain)?;
4792 let right = self.parse_not()?;
4793 expr = Expr::Binary {
4794 left: Box::new(expr),
4795 op: BinaryOp::And,
4796 right: Box::new(right),
4797 };
4798 }
4799 Ok(expr)
4800 }
4801
4802 fn parse_not(&mut self) -> Result<Expr> {
4803 if self.eat(TokenKind::Not).is_some() {
4804 self.enter()?;
4805 let expr = self.parse_not();
4806 self.exit();
4807 return Ok(Expr::Unary {
4808 op: UnaryOp::Not,
4809 expr: Box::new(expr?),
4810 });
4811 }
4812 self.parse_comparison()
4813 }
4814
4815 fn parse_comparison(&mut self) -> Result<Expr> {
4816 let mut expr = self.parse_concat()?;
4817 let mut chain = 1u32;
4818 loop {
4819 if self.eat(TokenKind::Colon).is_some() {
4820 let variable = self.expr_to_element_variable(expr, "labeled")?;
4821 let label_expression = self.parse_label_expression()?;
4822 expr = Expr::IsLabeled {
4823 variable,
4824 negated: false,
4825 label_expression,
4826 };
4827 continue;
4828 }
4829
4830 let op = match self.peek_kind() {
4831 TokenKind::Eq => BinaryOp::Eq,
4832 TokenKind::Neq => BinaryOp::Neq,
4833 TokenKind::Lt => BinaryOp::Lt,
4834 TokenKind::Le => BinaryOp::Le,
4835 TokenKind::Gt => BinaryOp::Gt,
4836 TokenKind::Ge => BinaryOp::Ge,
4837 TokenKind::Is => {
4838 self.bump();
4839 let negated = self.eat(TokenKind::Not).is_some();
4840 expr = self.parse_is_predicate_tail(expr, negated)?;
4841 continue;
4842 }
4843 _ => break,
4844 };
4845 chain += 1;
4846 self.check_chain(chain)?;
4847 self.bump();
4848 let right = self.parse_concat()?;
4849 expr = Expr::Binary {
4850 left: Box::new(expr),
4851 op,
4852 right: Box::new(right),
4853 };
4854 }
4855 Ok(expr)
4856 }
4857
4858 fn parse_is_predicate_tail(&mut self, expr: Expr, negated: bool) -> Result<Expr> {
4859 if self.at(TokenKind::Typed) || self.at(TokenKind::DoubleColon) {
4860 self.parse_optional_typed_marker()?;
4861 let value_type = self.parse_value_type()?;
4862 return Ok(Expr::IsTyped {
4863 expr: Box::new(expr),
4864 negated,
4865 value_type,
4866 });
4867 }
4868 if self.eat(TokenKind::Null).is_some() {
4869 return Ok(Expr::IsNull {
4870 expr: Box::new(expr),
4871 negated,
4872 });
4873 }
4874 if self.eat(TokenKind::Unknown).is_some() {
4875 return Ok(Expr::IsUnknown {
4876 expr: Box::new(expr),
4877 negated,
4878 });
4879 }
4880 if self.eat(TokenKind::True).is_some() {
4881 return Ok(Expr::IsTruth {
4882 expr: Box::new(expr),
4883 negated,
4884 value: true,
4885 });
4886 }
4887 if self.eat(TokenKind::False).is_some() {
4888 return Ok(Expr::IsTruth {
4889 expr: Box::new(expr),
4890 negated,
4891 value: false,
4892 });
4893 }
4894 if matches!(self.peek_kind(), TokenKind::Source | TokenKind::Destination) {
4895 let node = self.expr_to_element_variable(expr, "source/destination")?;
4896 let kind = if self.eat(TokenKind::Source).is_some() {
4897 SourceDestinationKind::Source
4898 } else {
4899 self.expect(TokenKind::Destination)?;
4900 SourceDestinationKind::Destination
4901 };
4902 self.expect(TokenKind::Of)?;
4903 let edge = self.parse_identifier()?;
4904 return Ok(Expr::SourceDestination {
4905 node,
4906 negated,
4907 kind,
4908 edge,
4909 });
4910 }
4911 if self.at(TokenKind::Normalized)
4912 || (is_identifier_like(self.peek_kind())
4913 && self.peek_n_kind(1) == Some(TokenKind::Normalized))
4914 {
4915 let normal_form = if self.at(TokenKind::Normalized) {
4916 None
4917 } else {
4918 Some(self.parse_normal_form()?)
4919 };
4920 self.expect(TokenKind::Normalized)?;
4921 return Ok(Expr::IsNormalized {
4922 expr: Box::new(expr),
4923 negated,
4924 normal_form,
4925 });
4926 }
4927 if self.eat(TokenKind::Directed).is_some() {
4928 let variable = self.expr_to_element_variable(expr, "directed")?;
4929 return Ok(Expr::IsDirected { variable, negated });
4930 }
4931 if self.eat(TokenKind::Labeled).is_some() {
4932 let variable = self.expr_to_element_variable(expr, "labeled")?;
4933 let label_expression = self.parse_label_expression()?;
4934 return Ok(Expr::IsLabeled {
4935 variable,
4936 negated,
4937 label_expression,
4938 });
4939 }
4940
4941 Err(Error::Message {
4942 offset: self.peek().offset,
4943 message: "expected standard IS predicate tail".to_owned(),
4944 })
4945 }
4946
4947 fn parse_concat(&mut self) -> Result<Expr> {
4948 let mut expr = self.parse_additive()?;
4949 let mut chain = 1u32;
4950 while self.eat(TokenKind::DoublePipe).is_some() {
4951 chain += 1;
4952 self.check_chain(chain)?;
4953 let right = self.parse_additive()?;
4954 expr = Expr::Binary {
4955 left: Box::new(expr),
4956 op: BinaryOp::Concat,
4957 right: Box::new(right),
4958 };
4959 }
4960 Ok(expr)
4961 }
4962
4963 fn parse_additive(&mut self) -> Result<Expr> {
4964 let mut expr = self.parse_multiplicative()?;
4965 let mut chain = 1u32;
4966 loop {
4967 let op = if self.eat(TokenKind::Plus).is_some() {
4968 BinaryOp::Add
4969 } else if self.eat(TokenKind::Minus).is_some() {
4970 BinaryOp::Sub
4971 } else {
4972 break;
4973 };
4974 chain += 1;
4975 self.check_chain(chain)?;
4976 let right = self.parse_multiplicative()?;
4977 expr = Expr::Binary {
4978 left: Box::new(expr),
4979 op,
4980 right: Box::new(right),
4981 };
4982 }
4983 Ok(expr)
4984 }
4985
4986 fn parse_multiplicative(&mut self) -> Result<Expr> {
4987 let mut expr = self.parse_unary()?;
4988 let mut chain = 1u32;
4989 loop {
4990 let op = if self.eat(TokenKind::Star).is_some() {
4991 BinaryOp::Mul
4992 } else if self.eat(TokenKind::Slash).is_some() {
4993 BinaryOp::Div
4994 } else {
4995 break;
4996 };
4997 chain += 1;
4998 self.check_chain(chain)?;
4999 let right = self.parse_unary()?;
5000 expr = Expr::Binary {
5001 left: Box::new(expr),
5002 op,
5003 right: Box::new(right),
5004 };
5005 }
5006 Ok(expr)
5007 }
5008
5009 fn parse_unary(&mut self) -> Result<Expr> {
5010 if self.eat(TokenKind::Plus).is_some() {
5011 self.enter()?;
5012 let expr = self.parse_unary();
5013 self.exit();
5014 return Ok(Expr::Unary {
5015 op: UnaryOp::Pos,
5016 expr: Box::new(expr?),
5017 });
5018 }
5019 if self.eat(TokenKind::Minus).is_some() {
5020 if self.at(TokenKind::Integer) && self.peek().text == "9223372036854775808" {
5022 self.bump();
5023 return Ok(Expr::Literal(Literal::Integer(i64::MIN)));
5024 }
5025 self.enter()?;
5026 let expr = self.parse_unary();
5027 self.exit();
5028 return Ok(Expr::Unary {
5029 op: UnaryOp::Neg,
5030 expr: Box::new(expr?),
5031 });
5032 }
5033 self.parse_postfix()
5034 }
5035
5036 fn parse_postfix(&mut self) -> Result<Expr> {
5037 let mut expr = self.parse_primary()?;
5038 loop {
5039 if self.eat(TokenKind::Dot).is_some() {
5040 let key = self.parse_identifier()?;
5041 expr = Expr::Property {
5042 base: Box::new(expr),
5043 key,
5044 };
5045 continue;
5046 }
5047 break;
5048 }
5049 Ok(expr)
5050 }
5051
5052 fn parse_primary(&mut self) -> Result<Expr> {
5053 let token = self.bump();
5054 match token.kind {
5055 TokenKind::Date if self.at(TokenKind::LParen) => {
5056 self.parse_datetime_value_function(DateTimeFunctionKind::Date)
5057 }
5058 TokenKind::Date => self.parse_typed_string_literal(LiteralKind::Date),
5059 TokenKind::Time => self.parse_typed_string_literal(LiteralKind::Time),
5060 TokenKind::Datetime | TokenKind::Timestamp => {
5061 self.parse_typed_string_literal(LiteralKind::DateTime)
5062 }
5063 TokenKind::Interval => self.parse_sql_interval_literal(),
5064 TokenKind::Duration if self.is_character_string_token(self.peek_kind()) => {
5065 self.parse_typed_string_literal(LiteralKind::Duration)
5066 }
5067 TokenKind::Duration if self.at(TokenKind::LParen) => self.parse_duration_function(),
5068 TokenKind::DurationBetween if self.at(TokenKind::LParen) => {
5069 self.parse_duration_between_function()
5070 }
5071 TokenKind::Record if self.at(TokenKind::LBrace) => self.parse_record_constructor(true),
5072 TokenKind::List if self.at(TokenKind::LBracket) => {
5073 self.parse_typed_list_constructor(ListValueTypeName::List)
5074 }
5075 TokenKind::Array if self.at(TokenKind::LBracket) => {
5076 self.parse_typed_list_constructor(ListValueTypeName::Array)
5077 }
5078 TokenKind::Group
5079 if self.at(TokenKind::List) && self.peek_n_kind(1) == Some(TokenKind::LBracket) =>
5080 {
5081 Err(Error::Message {
5082 offset: token.offset,
5083 message: "GROUP list value type names are not user-visible standard GQL syntax"
5084 .to_owned(),
5085 })
5086 }
5087 TokenKind::Group
5088 if self.at(TokenKind::Array)
5089 && self.peek_n_kind(1) == Some(TokenKind::LBracket) =>
5090 {
5091 Err(Error::Message {
5092 offset: token.offset,
5093 message: "GROUP list value type names are not user-visible standard GQL syntax"
5094 .to_owned(),
5095 })
5096 }
5097 TokenKind::Path if self.at(TokenKind::LBracket) => self.parse_path_value_constructor(),
5098 TokenKind::Case => self.parse_case_expression(),
5099 TokenKind::Coalesce if self.at(TokenKind::LParen) => self.parse_coalesce_expression(),
5100 TokenKind::Nullif if self.at(TokenKind::LParen) => self.parse_nullif_expression(),
5101 TokenKind::Cast => self.parse_cast_expression(),
5102 TokenKind::CurrentDate => Ok(Expr::CurrentDate),
5103 TokenKind::CurrentTime => self.parse_current_time_function(),
5104 TokenKind::CurrentTimestamp => self.parse_current_timestamp_function(),
5105 TokenKind::CurrentUser => Ok(Expr::CurrentUser),
5106 TokenKind::ZonedTime if self.at(TokenKind::LParen) => {
5107 self.parse_datetime_value_function(DateTimeFunctionKind::ZonedTime)
5108 }
5109 TokenKind::ZonedDatetime if self.at(TokenKind::LParen) => {
5110 self.parse_datetime_value_function(DateTimeFunctionKind::ZonedDateTime)
5111 }
5112 TokenKind::LocalTime if self.at(TokenKind::LParen) => {
5113 self.parse_datetime_value_function(DateTimeFunctionKind::LocalTime)
5114 }
5115 TokenKind::LocalTime => Ok(Expr::LocalTime { precision: None }),
5116 TokenKind::LocalDatetime if self.at(TokenKind::LParen) => {
5117 self.parse_datetime_value_function(DateTimeFunctionKind::LocalDateTime)
5118 }
5119 TokenKind::Localtimestamp => self.parse_local_timestamp_function(),
5120 TokenKind::Abs if self.at(TokenKind::LParen) => self.parse_absolute_value_function(),
5121 TokenKind::Floor if self.at(TokenKind::LParen) => {
5122 self.parse_unary_numeric_function(NumericFunctionKind::Floor)
5123 }
5124 TokenKind::Ceil | TokenKind::Ceiling if self.at(TokenKind::LParen) => {
5125 self.parse_unary_numeric_function(NumericFunctionKind::Ceil)
5126 }
5127 TokenKind::Sqrt if self.at(TokenKind::LParen) => {
5128 self.parse_unary_numeric_function(NumericFunctionKind::Sqrt)
5129 }
5130 TokenKind::Log10 if self.at(TokenKind::LParen) => {
5131 self.parse_unary_numeric_function(NumericFunctionKind::Log10)
5132 }
5133 TokenKind::Ln if self.at(TokenKind::LParen) => {
5134 self.parse_unary_numeric_function(NumericFunctionKind::Ln)
5135 }
5136 TokenKind::Exp if self.at(TokenKind::LParen) => {
5137 self.parse_unary_numeric_function(NumericFunctionKind::Exp)
5138 }
5139 TokenKind::Sin if self.at(TokenKind::LParen) => {
5140 self.parse_unary_numeric_function(NumericFunctionKind::Sin)
5141 }
5142 TokenKind::Cos if self.at(TokenKind::LParen) => {
5143 self.parse_unary_numeric_function(NumericFunctionKind::Cos)
5144 }
5145 TokenKind::Tan if self.at(TokenKind::LParen) => {
5146 self.parse_unary_numeric_function(NumericFunctionKind::Tan)
5147 }
5148 TokenKind::Cot if self.at(TokenKind::LParen) => {
5149 self.parse_unary_numeric_function(NumericFunctionKind::Cot)
5150 }
5151 TokenKind::Sinh if self.at(TokenKind::LParen) => {
5152 self.parse_unary_numeric_function(NumericFunctionKind::Sinh)
5153 }
5154 TokenKind::Cosh if self.at(TokenKind::LParen) => {
5155 self.parse_unary_numeric_function(NumericFunctionKind::Cosh)
5156 }
5157 TokenKind::Tanh if self.at(TokenKind::LParen) => {
5158 self.parse_unary_numeric_function(NumericFunctionKind::Tanh)
5159 }
5160 TokenKind::Asin if self.at(TokenKind::LParen) => {
5161 self.parse_unary_numeric_function(NumericFunctionKind::Asin)
5162 }
5163 TokenKind::Acos if self.at(TokenKind::LParen) => {
5164 self.parse_unary_numeric_function(NumericFunctionKind::Acos)
5165 }
5166 TokenKind::Atan if self.at(TokenKind::LParen) => {
5167 self.parse_unary_numeric_function(NumericFunctionKind::Atan)
5168 }
5169 TokenKind::Degrees if self.at(TokenKind::LParen) => {
5170 self.parse_unary_numeric_function(NumericFunctionKind::Degrees)
5171 }
5172 TokenKind::Radians if self.at(TokenKind::LParen) => {
5173 self.parse_unary_numeric_function(NumericFunctionKind::Radians)
5174 }
5175 TokenKind::PathLength if self.at(TokenKind::LParen) => {
5176 self.parse_unary_numeric_function(NumericFunctionKind::PathLength)
5177 }
5178 TokenKind::Mod if self.at(TokenKind::LParen) => {
5179 self.parse_binary_numeric_function(NumericFunctionKind::Mod)
5180 }
5181 TokenKind::Power if self.at(TokenKind::LParen) => {
5182 self.parse_binary_numeric_function(NumericFunctionKind::Power)
5183 }
5184 TokenKind::Log if self.at(TokenKind::LParen) => {
5185 self.parse_binary_numeric_function(NumericFunctionKind::Log)
5186 }
5187 TokenKind::PropertyExists => self.parse_property_exists_predicate(),
5188 TokenKind::ElementId => self.parse_element_id_function(),
5189 TokenKind::Value if self.at(TokenKind::LBrace) => {
5190 self.parse_value_query_expression(token.offset)
5191 }
5192 TokenKind::Let if self.starts_let_value_expression() => {
5193 self.parse_let_value_expression()
5194 }
5195 TokenKind::Left if self.at(TokenKind::LParen) => {
5196 self.parse_left_right_substring_function(SubstringSide::Left)
5197 }
5198 TokenKind::Right if self.at(TokenKind::LParen) => {
5199 self.parse_left_right_substring_function(SubstringSide::Right)
5200 }
5201 TokenKind::Trim if self.at(TokenKind::LParen) => self.parse_trim_function(),
5202 TokenKind::Btrim if self.at(TokenKind::LParen) => {
5203 self.parse_multi_trim_function(TrimSpec::Both)
5204 }
5205 TokenKind::Ltrim if self.at(TokenKind::LParen) => {
5206 self.parse_multi_trim_function(TrimSpec::Leading)
5207 }
5208 TokenKind::Rtrim if self.at(TokenKind::LParen) => {
5209 self.parse_multi_trim_function(TrimSpec::Trailing)
5210 }
5211 TokenKind::Elements if self.at(TokenKind::LParen) => self.parse_elements_function(),
5212 TokenKind::Upper if self.at(TokenKind::LParen) => self.parse_fold_function(true),
5213 TokenKind::Lower if self.at(TokenKind::LParen) => self.parse_fold_function(false),
5214 TokenKind::Normalize if self.at(TokenKind::LParen) => self.parse_normalize_function(),
5215 TokenKind::CharLength | TokenKind::CharacterLength if self.at(TokenKind::LParen) => {
5216 self.parse_string_length_function(StringLengthUnit::Characters)
5217 }
5218 TokenKind::ByteLength | TokenKind::OctetLength if self.at(TokenKind::LParen) => {
5219 self.parse_string_length_function(StringLengthUnit::Bytes)
5220 }
5221 TokenKind::Exists => self.parse_exists_predicate(),
5222 TokenKind::Same => self.parse_same_predicate(),
5223 TokenKind::AllDifferent => self.parse_all_different_predicate(),
5224 TokenKind::Graph if self.is_strict_graph_expression_start(self.peek_kind()) => {
5225 Ok(Expr::GraphReference {
5226 property_graph: false,
5227 graph: self.parse_graph_expression()?,
5228 })
5229 }
5230 TokenKind::Property
5231 if self.at(TokenKind::Graph)
5232 && self
5233 .peek_n_kind(1)
5234 .is_some_and(|kind| self.is_strict_graph_expression_start(kind)) =>
5235 {
5236 self.expect(TokenKind::Graph)?;
5237 Ok(Expr::GraphReference {
5238 property_graph: true,
5239 graph: self.parse_graph_expression()?,
5240 })
5241 }
5242 TokenKind::Table if self.is_strict_binding_table_expression_start(self.peek_kind()) => {
5243 Ok(Expr::BindingTableReference {
5244 binding: false,
5245 table: self.parse_binding_table_expression()?,
5246 })
5247 }
5248 TokenKind::Binding if self.at(TokenKind::Table) => {
5249 self.expect(TokenKind::Table)?;
5250 Ok(Expr::BindingTableReference {
5251 binding: true,
5252 table: self.parse_binding_table_expression()?,
5253 })
5254 }
5255 TokenKind::DoubleQuotedString
5256 if self.at(TokenKind::Dot) || self.at(TokenKind::LParen) =>
5257 {
5258 let ident = Identifier::new(token.text);
5259 if self.eat(TokenKind::LParen).is_some() {
5260 self.parse_function_call(ident, token.offset)
5261 } else {
5262 Ok(Expr::Identifier(ident))
5263 }
5264 }
5265 TokenKind::DoubleQuotedString => Ok(Expr::Literal(Literal::String(token.text))),
5266 kind if is_identifier_like(kind)
5267 && !matches!(
5268 kind,
5269 TokenKind::Null | TokenKind::True | TokenKind::False | TokenKind::Unknown
5270 ) =>
5271 {
5272 let ident = Identifier::new(token.text);
5273 if self.eat(TokenKind::LParen).is_some() {
5274 self.parse_function_call(ident, token.offset)
5275 } else {
5276 Ok(Expr::Identifier(ident))
5277 }
5278 }
5279 TokenKind::Parameter => Ok(Expr::Parameter(parameter_name(&token.text))),
5280 TokenKind::String => Ok(Expr::Literal(Literal::String(token.text))),
5281 TokenKind::ByteString => self.parse_byte_string_literal(token),
5282 TokenKind::Integer => {
5283 let value = token.text.parse::<i64>().map_err(|_| Error::BadNumber {
5284 offset: token.offset,
5285 token_text: token.text.clone(),
5286 })?;
5287 Ok(Expr::Literal(Literal::Integer(value)))
5288 }
5289 TokenKind::Decimal => {
5290 let value = token.text.parse::<f64>().map_err(|_| Error::BadNumber {
5291 offset: token.offset,
5292 token_text: token.text.clone(),
5293 })?;
5294 Ok(Expr::Literal(Literal::Decimal(value)))
5295 }
5296 TokenKind::Null => Ok(Expr::Literal(Literal::Null)),
5297 TokenKind::True => Ok(Expr::Literal(Literal::Boolean(true))),
5298 TokenKind::False => Ok(Expr::Literal(Literal::Boolean(false))),
5299 TokenKind::Unknown => Ok(Expr::Literal(Literal::Unknown)),
5300 TokenKind::Star => Ok(Expr::Wildcard),
5301 TokenKind::LParen => {
5302 let expr = self.parse_expr()?;
5303 self.expect(TokenKind::RParen)?;
5304 Ok(expr)
5305 }
5306 TokenKind::LBracket => {
5307 let values = self.parse_list_elements_after_lbracket()?;
5308 Ok(Expr::List(values))
5309 }
5310 TokenKind::LBrace => {
5311 self.pos -= 1;
5312 self.parse_record_constructor(false)
5313 }
5314 TokenKind::Eof => Err(self.eof_error()),
5315 kind => Err(Error::expected(
5316 token.offset,
5317 vec![
5318 TokenKind::Identifier,
5319 TokenKind::Parameter,
5320 TokenKind::String,
5321 TokenKind::ByteString,
5322 TokenKind::Integer,
5323 TokenKind::Decimal,
5324 TokenKind::Null,
5325 TokenKind::True,
5326 TokenKind::False,
5327 TokenKind::Unknown,
5328 TokenKind::Case,
5329 TokenKind::Cast,
5330 TokenKind::Interval,
5331 TokenKind::PropertyExists,
5332 TokenKind::ElementId,
5333 TokenKind::Exists,
5334 TokenKind::Same,
5335 TokenKind::AllDifferent,
5336 TokenKind::LParen,
5337 TokenKind::LBracket,
5338 TokenKind::LBrace,
5339 ],
5340 kind,
5341 token.text,
5342 )),
5343 }
5344 }
5345
5346 fn parse_byte_string_literal(&self, token: Token) -> Result<Expr> {
5347 let mut value = Vec::with_capacity(token.text.len() / 2);
5348 for pair in token.text.as_bytes().as_chunks::<2>().0 {
5349 let pair = std::str::from_utf8(pair).map_err(|_| Error::Message {
5350 offset: token.offset,
5351 message: "invalid byte string literal".to_owned(),
5352 })?;
5353 let byte = u8::from_str_radix(pair, 16).map_err(|_| Error::Message {
5354 offset: token.offset,
5355 message: "invalid byte string literal".to_owned(),
5356 })?;
5357 value.push(byte);
5358 }
5359 Ok(Expr::Literal(Literal::Bytes(value)))
5360 }
5361
5362 fn is_strict_graph_expression_start(&self, kind: TokenKind) -> bool {
5363 self.starts_object_expression_primary_special_case(kind)
5364 || matches!(
5365 kind,
5366 TokenKind::Identifier
5367 | TokenKind::Parameter
5368 | TokenKind::Variable
5369 | TokenKind::LParen
5370 | TokenKind::Slash
5371 | TokenKind::Dot
5372 | TokenKind::CurrentGraph
5373 | TokenKind::CurrentPropertyGraph
5374 | TokenKind::HomeGraph
5375 | TokenKind::HomePropertyGraph
5376 )
5377 }
5378
5379 fn is_strict_binding_table_expression_start(&self, kind: TokenKind) -> bool {
5380 self.starts_object_expression_primary_special_case(kind)
5381 || matches!(
5382 kind,
5383 TokenKind::Identifier
5384 | TokenKind::Parameter
5385 | TokenKind::Variable
5386 | TokenKind::LParen
5387 | TokenKind::LBrace
5388 | TokenKind::Slash
5389 | TokenKind::Dot
5390 )
5391 }
5392
5393 fn starts_object_expression_primary_special_case(&self, kind: TokenKind) -> bool {
5394 matches!(
5395 kind,
5396 TokenKind::String
5397 | TokenKind::ByteString
5398 | TokenKind::Integer
5399 | TokenKind::Decimal
5400 | TokenKind::Null
5401 | TokenKind::True
5402 | TokenKind::False
5403 | TokenKind::Unknown
5404 | TokenKind::CurrentDate
5405 | TokenKind::CurrentTime
5406 | TokenKind::CurrentTimestamp
5407 | TokenKind::CurrentUser
5408 | TokenKind::Localtimestamp
5409 | TokenKind::LocalTime
5410 | TokenKind::Case
5411 | TokenKind::LBrace
5412 | TokenKind::LBracket
5413 ) || matches!(
5414 kind,
5415 TokenKind::Date | TokenKind::Time | TokenKind::Datetime | TokenKind::Timestamp
5416 ) && matches!(
5417 self.peek_n_kind(1),
5418 Some(
5419 TokenKind::String
5420 | TokenKind::DoubleQuotedString
5421 | TokenKind::QuotedString
5422 | TokenKind::LParen,
5423 )
5424 ) || kind == TokenKind::Interval
5425 && matches!(
5426 self.peek_n_kind(1),
5427 Some(
5428 TokenKind::String
5429 | TokenKind::DoubleQuotedString
5430 | TokenKind::QuotedString
5431 | TokenKind::Plus
5432 | TokenKind::Minus
5433 )
5434 )
5435 || kind == TokenKind::Duration
5436 && matches!(
5437 self.peek_n_kind(1),
5438 Some(
5439 TokenKind::String
5440 | TokenKind::DoubleQuotedString
5441 | TokenKind::QuotedString
5442 | TokenKind::LParen,
5443 )
5444 )
5445 || matches!(
5446 kind,
5447 TokenKind::Avg
5448 | TokenKind::Count
5449 | TokenKind::Max
5450 | TokenKind::Min
5451 | TokenKind::Sum
5452 | TokenKind::CollectList
5453 | TokenKind::StddevSamp
5454 | TokenKind::StddevPop
5455 | TokenKind::PercentileCont
5456 | TokenKind::PercentileDisc
5457 | TokenKind::Cast
5458 | TokenKind::ElementId
5459 ) && self.peek_n_kind(1) == Some(TokenKind::LParen)
5460 || matches!(kind, TokenKind::Record | TokenKind::Value)
5461 && self.peek_n_kind(1) == Some(TokenKind::LBrace)
5462 || matches!(kind, TokenKind::List | TokenKind::Array | TokenKind::Path)
5463 && self.peek_n_kind(1) == Some(TokenKind::LBracket)
5464 || kind == TokenKind::Group
5465 && matches!(
5466 self.peek_n_kind(1),
5467 Some(TokenKind::List | TokenKind::Array)
5468 )
5469 && self.peek_n_kind(2) == Some(TokenKind::LBracket)
5470 || kind == TokenKind::Let && self.starts_let_value_expression_after_let()
5471 }
5472
5473 fn starts_let_value_expression_after_let(&self) -> bool {
5474 self.peek_n_kind(1) == Some(TokenKind::Value)
5475 || self.peek_n_kind(1).is_some_and(is_identifier_like)
5476 && self.peek_n_kind(2) == Some(TokenKind::Eq)
5477 }
5478
5479 fn parse_cast_expression(&mut self) -> Result<Expr> {
5480 self.expect(TokenKind::LParen)?;
5481 let expr = self.parse_expr()?;
5482 self.expect(TokenKind::As)?;
5483 let value_type = self.parse_value_type()?;
5484 self.expect(TokenKind::RParen)?;
5485 Ok(Expr::Cast {
5486 expr: Box::new(expr),
5487 value_type,
5488 })
5489 }
5490
5491 fn parse_element_id_function(&mut self) -> Result<Expr> {
5492 self.expect(TokenKind::LParen)?;
5493 let variable = self.parse_identifier()?;
5494 self.expect(TokenKind::RParen)?;
5495 Ok(Expr::ElementId { variable })
5496 }
5497
5498 fn parse_value_query_expression(&mut self, offset: usize) -> Result<Expr> {
5499 let query = self.parse_nested_query_specification()?;
5500 validate_value_query_expression(&query, offset)?;
5501 Ok(Expr::ValueQuery {
5502 query: Box::new(query),
5503 })
5504 }
5505
5506 fn starts_let_value_expression(&self) -> bool {
5507 self.at(TokenKind::Value)
5508 || (is_identifier_like(self.peek_kind()) && self.peek_n_kind(1) == Some(TokenKind::Eq))
5509 }
5510
5511 fn parse_let_value_expression(&mut self) -> Result<Expr> {
5512 let mut items = Vec::new();
5513 loop {
5514 let item_offset = self.peek().offset;
5515 let item = self.parse_let_item_with_in_delimiter(true)?;
5516 self.push_let_item(&mut items, item, item_offset)?;
5517 if self.eat(TokenKind::Comma).is_none() {
5518 break;
5519 }
5520 }
5521 self.expect(TokenKind::In)?;
5522 let value = self.parse_expr()?;
5523 self.expect(TokenKind::End)?;
5524 Ok(Expr::Let {
5525 items,
5526 value: Box::new(value),
5527 })
5528 }
5529
5530 fn push_let_item(&self, items: &mut Vec<LetItem>, item: LetItem, offset: usize) -> Result<()> {
5531 if items.iter().any(|existing| existing.name == item.name) {
5532 return Err(Error::Message {
5533 offset,
5534 message: format!("duplicate let variable '{}'", item.name.value),
5535 });
5536 }
5537 items.push(item);
5538 Ok(())
5539 }
5540
5541 fn parse_record_constructor(&mut self, explicit: bool) -> Result<Expr> {
5542 Ok(Expr::Record {
5543 explicit,
5544 fields: self.parse_map_literal()?,
5545 })
5546 }
5547
5548 fn parse_typed_list_constructor(&mut self, type_name: ListValueTypeName) -> Result<Expr> {
5549 self.expect(TokenKind::LBracket)?;
5550 let values = self.parse_list_elements_after_lbracket()?;
5551 Ok(Expr::TypedList { type_name, values })
5552 }
5553
5554 fn parse_path_value_constructor(&mut self) -> Result<Expr> {
5555 self.expect(TokenKind::LBracket)?;
5556 if self.at(TokenKind::RBracket) {
5557 return Err(self.error_expected(
5558 vec![
5559 TokenKind::Identifier,
5560 TokenKind::Parameter,
5561 TokenKind::LParen,
5562 TokenKind::Graph,
5563 TokenKind::Binding,
5564 TokenKind::Table,
5565 ],
5566 self.peek_kind(),
5567 ));
5568 }
5569 let mut values = vec![self.parse_expr()?];
5570 while self.eat(TokenKind::Comma).is_some() {
5571 values.push(self.parse_expr()?);
5572 self.expect(TokenKind::Comma)?;
5573 values.push(self.parse_expr()?);
5574 }
5575 self.expect(TokenKind::RBracket)?;
5576 Ok(Expr::Path(values))
5577 }
5578
5579 fn parse_list_elements_after_lbracket(&mut self) -> Result<Vec<Expr>> {
5580 let mut values = Vec::new();
5581 if !self.at(TokenKind::RBracket) {
5582 loop {
5583 values.push(self.parse_expr()?);
5584 if self.eat(TokenKind::Comma).is_none() {
5585 break;
5586 }
5587 }
5588 }
5589 self.expect(TokenKind::RBracket)?;
5590 Ok(values)
5591 }
5592
5593 fn parse_duration_function(&mut self) -> Result<Expr> {
5594 self.expect(TokenKind::LParen)?;
5595 let value = self.parse_temporal_function_parameter("DURATION")?;
5596 self.expect(TokenKind::RParen)?;
5597 Ok(Expr::DurationFunction {
5598 value: Box::new(value),
5599 })
5600 }
5601
5602 fn parse_duration_between_function(&mut self) -> Result<Expr> {
5603 self.expect(TokenKind::LParen)?;
5604 let left = self.parse_expr()?;
5605 self.expect(TokenKind::Comma)?;
5606 let right = self.parse_expr()?;
5607 self.expect(TokenKind::RParen)?;
5608 Ok(Expr::DurationBetween {
5609 left: Box::new(left),
5610 right: Box::new(right),
5611 })
5612 }
5613
5614 fn parse_current_time_function(&mut self) -> Result<Expr> {
5615 if self.at(TokenKind::LParen) {
5616 return Err(Error::Message {
5617 offset: self.peek().offset,
5618 message: "CURRENT_TIME does not accept parameters".to_owned(),
5619 });
5620 }
5621 Ok(Expr::CurrentTime { precision: None })
5622 }
5623
5624 fn parse_current_timestamp_function(&mut self) -> Result<Expr> {
5625 if self.at(TokenKind::LParen) {
5626 return Err(Error::Message {
5627 offset: self.peek().offset,
5628 message: "CURRENT_TIMESTAMP does not accept parameters".to_owned(),
5629 });
5630 }
5631 Ok(Expr::CurrentTimestamp { precision: None })
5632 }
5633
5634 fn parse_datetime_value_function(&mut self, function: DateTimeFunctionKind) -> Result<Expr> {
5635 self.expect(TokenKind::LParen)?;
5636 let value = if self.at(TokenKind::RParen) {
5637 None
5638 } else {
5639 Some(Box::new(
5640 self.parse_temporal_function_parameter(function.name())?,
5641 ))
5642 };
5643 self.expect(TokenKind::RParen)?;
5644 Ok(Expr::DateTimeFunction { function, value })
5645 }
5646
5647 fn parse_temporal_function_parameter(&mut self, function_name: &str) -> Result<Expr> {
5648 if self.is_character_string_token(self.peek_kind()) {
5649 return self.parse_character_string_literal_expr();
5650 }
5651 if self.eat(TokenKind::Record).is_some() {
5652 return self.parse_record_constructor(true);
5653 }
5654 if self.at(TokenKind::LBrace) {
5655 return self.parse_record_constructor(false);
5656 }
5657 Err(Error::Message {
5658 offset: self.peek().offset,
5659 message: format!(
5660 "{function_name} requires a string literal or record value constructor parameter"
5661 ),
5662 })
5663 }
5664
5665 fn parse_local_timestamp_function(&mut self) -> Result<Expr> {
5666 if self.at(TokenKind::LParen) {
5667 return Err(Error::Message {
5668 offset: self.peek().offset,
5669 message: "LOCAL_TIMESTAMP does not accept parameters".to_owned(),
5670 });
5671 }
5672 Ok(Expr::LocalTimestamp { precision: None })
5673 }
5674
5675 fn parse_absolute_value_function(&mut self) -> Result<Expr> {
5676 self.expect(TokenKind::LParen)?;
5677 let expr = self.parse_expr()?;
5678 self.expect(TokenKind::RParen)?;
5679 Ok(Expr::AbsoluteValue {
5680 expr: Box::new(expr),
5681 })
5682 }
5683
5684 fn parse_unary_numeric_function(&mut self, function: NumericFunctionKind) -> Result<Expr> {
5685 self.expect(TokenKind::LParen)?;
5686 let arg = self.parse_expr()?;
5687 self.expect(TokenKind::RParen)?;
5688 Ok(Expr::NumericFunction {
5689 function,
5690 args: vec![arg],
5691 })
5692 }
5693
5694 fn parse_binary_numeric_function(&mut self, function: NumericFunctionKind) -> Result<Expr> {
5695 self.expect(TokenKind::LParen)?;
5696 let left = self.parse_expr()?;
5697 self.expect(TokenKind::Comma)?;
5698 let right = self.parse_expr()?;
5699 self.expect(TokenKind::RParen)?;
5700 Ok(Expr::NumericFunction {
5701 function,
5702 args: vec![left, right],
5703 })
5704 }
5705
5706 fn parse_left_right_substring_function(&mut self, side: SubstringSide) -> Result<Expr> {
5707 self.expect(TokenKind::LParen)?;
5708 let value = self.parse_expr()?;
5709 self.expect(TokenKind::Comma)?;
5710 let length = self.parse_expr()?;
5711 self.expect(TokenKind::RParen)?;
5712 Ok(Expr::SubstringByLength {
5713 side,
5714 value: Box::new(value),
5715 length: Box::new(length),
5716 })
5717 }
5718
5719 fn parse_trim_function(&mut self) -> Result<Expr> {
5720 self.expect(TokenKind::LParen)?;
5721 let specification = self.parse_optional_trim_specification();
5722
5723 let (trim_character, value) = if specification.is_some() {
5724 let trim_character = if self.eat(TokenKind::From).is_some() {
5725 None
5726 } else {
5727 let trim_character = self.parse_expr()?;
5728 self.expect(TokenKind::From)?;
5729 Some(Box::new(trim_character))
5730 };
5731 let value = self.parse_expr()?;
5732 (trim_character, value)
5733 } else {
5734 let first_expr = self.parse_expr()?;
5735 if self.eat(TokenKind::Comma).is_some() {
5736 let count = self.parse_expr()?;
5737 self.expect(TokenKind::RParen)?;
5738 return Ok(Expr::TrimList {
5739 value: Box::new(first_expr),
5740 count: Box::new(count),
5741 });
5742 } else if self.eat(TokenKind::From).is_some() {
5743 let value = self.parse_expr()?;
5744 (Some(Box::new(first_expr)), value)
5745 } else {
5746 (None, first_expr)
5747 }
5748 };
5749
5750 self.expect(TokenKind::RParen)?;
5751 Ok(Expr::Trim {
5752 specification,
5753 trim_character,
5754 value: Box::new(value),
5755 })
5756 }
5757
5758 fn parse_optional_trim_specification(&mut self) -> Option<TrimSpec> {
5759 if self.eat(TokenKind::Leading).is_some() {
5760 Some(TrimSpec::Leading)
5761 } else if self.eat(TokenKind::Trailing).is_some() {
5762 Some(TrimSpec::Trailing)
5763 } else if self.eat(TokenKind::Both).is_some() {
5764 Some(TrimSpec::Both)
5765 } else {
5766 None
5767 }
5768 }
5769
5770 fn parse_multi_trim_function(&mut self, specification: TrimSpec) -> Result<Expr> {
5771 self.expect(TokenKind::LParen)?;
5772 let value = self.parse_expr()?;
5773 let trim_characters = if self.eat(TokenKind::Comma).is_some() {
5774 Some(Box::new(self.parse_expr()?))
5775 } else {
5776 None
5777 };
5778 self.expect(TokenKind::RParen)?;
5779 Ok(Expr::MultiTrim {
5780 specification,
5781 value: Box::new(value),
5782 trim_characters,
5783 })
5784 }
5785
5786 fn parse_elements_function(&mut self) -> Result<Expr> {
5787 self.expect(TokenKind::LParen)?;
5788 let path = self.parse_expr()?;
5789 self.expect(TokenKind::RParen)?;
5790 Ok(Expr::Elements {
5791 path: Box::new(path),
5792 })
5793 }
5794
5795 fn parse_string_length_function(&mut self, unit: StringLengthUnit) -> Result<Expr> {
5796 self.expect(TokenKind::LParen)?;
5797 let value = self.parse_expr()?;
5798 self.expect(TokenKind::RParen)?;
5799 Ok(Expr::StringLength {
5800 unit,
5801 value: Box::new(value),
5802 })
5803 }
5804
5805 fn parse_fold_function(&mut self, upper: bool) -> Result<Expr> {
5806 self.expect(TokenKind::LParen)?;
5807 let value = self.parse_expr()?;
5808 self.expect(TokenKind::RParen)?;
5809 Ok(Expr::Fold {
5810 upper,
5811 value: Box::new(value),
5812 })
5813 }
5814
5815 fn parse_normalize_function(&mut self) -> Result<Expr> {
5816 self.expect(TokenKind::LParen)?;
5817 let value = self.parse_expr()?;
5818 let normal_form = if self.eat(TokenKind::Comma).is_some() {
5819 Some(self.parse_normal_form()?)
5820 } else {
5821 None
5822 };
5823 self.expect(TokenKind::RParen)?;
5824 Ok(Expr::Normalize {
5825 value: Box::new(value),
5826 normal_form,
5827 })
5828 }
5829
5830 fn parse_normal_form(&mut self) -> Result<Identifier> {
5831 let normal_form = self.parse_identifier()?;
5832 match normal_form.value.to_ascii_uppercase().as_str() {
5833 "NFC" | "NFD" | "NFKC" | "NFKD" => Ok(normal_form),
5834 _ => Err(Error::Message {
5835 offset: self.peek().offset,
5836 message: format!("invalid normal form '{}'", normal_form.value),
5837 }),
5838 }
5839 }
5840
5841 fn parse_function_arguments(&mut self) -> Result<(Option<SetQuantifier>, Vec<Expr>)> {
5842 let mut args = Vec::new();
5843 if self.at(TokenKind::RParen) {
5844 return Ok((None, args));
5845 }
5846
5847 let quantifier = if self.eat(TokenKind::Distinct).is_some() {
5848 Some(SetQuantifier::Distinct)
5849 } else if self.eat(TokenKind::All).is_some() {
5850 Some(SetQuantifier::All)
5851 } else {
5852 None
5853 };
5854
5855 loop {
5856 args.push(self.parse_expr()?);
5857 if self.eat(TokenKind::Comma).is_none() {
5858 break;
5859 }
5860 }
5861
5862 Ok((quantifier, args))
5863 }
5864
5865 fn parse_function_call(&mut self, name: Identifier, offset: usize) -> Result<Expr> {
5866 let (quantifier, args) = self.parse_function_arguments()?;
5867 self.expect(TokenKind::RParen)?;
5868 reject_non_standard_value_function(&name, offset)?;
5869 self.validate_aggregate_function_call(&name, quantifier, &args, offset)?;
5870 let quantifier = normalize_function_quantifier(&name, quantifier, &args);
5871 Ok(Expr::Function {
5872 name,
5873 quantifier,
5874 args,
5875 })
5876 }
5877
5878 fn validate_aggregate_function_call(
5879 &self,
5880 name: &Identifier,
5881 quantifier: Option<SetQuantifier>,
5882 args: &[Expr],
5883 offset: usize,
5884 ) -> Result<()> {
5885 if is_aggregate_function_name(&name.value) && args.iter().any(expr_contains_procedure_body)
5886 {
5887 return Err(Error::Message {
5888 offset,
5889 message: format!(
5890 "aggregate function {} cannot contain a procedure body",
5891 name.value
5892 ),
5893 });
5894 }
5895
5896 match name.value.to_ascii_uppercase().as_str() {
5897 "COUNT" => {
5898 if args.len() != 1 {
5899 return Err(Error::Message {
5900 offset,
5901 message: "aggregate function COUNT requires one value expression or *"
5902 .to_owned(),
5903 });
5904 }
5905 if matches!(args[0], Expr::Wildcard) && quantifier.is_some() {
5906 return Err(Error::Message {
5907 offset,
5908 message: "aggregate function COUNT(*) cannot specify a set quantifier"
5909 .to_owned(),
5910 });
5911 }
5912 }
5913 "AVG" | "MAX" | "MIN" | "SUM" | "COLLECT_LIST" | "STDDEV_SAMP" | "STDDEV_POP" => {
5914 if args.len() != 1 || matches!(args.first(), Some(Expr::Wildcard)) {
5915 return Err(Error::Message {
5916 offset,
5917 message: format!(
5918 "aggregate function {} requires one value expression",
5919 name.value
5920 ),
5921 });
5922 }
5923 }
5924 "PERCENTILE_CONT" | "PERCENTILE_DISC"
5925 if args.len() != 2 || args.iter().any(|arg| matches!(arg, Expr::Wildcard)) =>
5926 {
5927 return Err(Error::Message {
5928 offset,
5929 message: format!(
5930 "aggregate function {} requires two numeric value expressions",
5931 name.value
5932 ),
5933 });
5934 }
5935 _ => {}
5936 }
5937 Ok(())
5938 }
5939
5940 fn parse_typed_string_literal(&mut self, kind: LiteralKind) -> Result<Expr> {
5941 let token = self.parse_character_string_token()?;
5942 let literal = match kind {
5943 LiteralKind::Date => Literal::Date(token.text),
5944 LiteralKind::Time => Literal::Time(token.text),
5945 LiteralKind::DateTime => Literal::DateTime(token.text),
5946 LiteralKind::Duration => Literal::Duration(token.text),
5947 };
5948 Ok(Expr::Literal(literal))
5949 }
5950
5951 fn parse_character_string_literal_expr(&mut self) -> Result<Expr> {
5952 let token = self.parse_character_string_token()?;
5953 Ok(Expr::Literal(Literal::String(token.text)))
5954 }
5955
5956 fn parse_character_string_token(&mut self) -> Result<Token> {
5957 if self.is_character_string_token(self.peek_kind()) {
5958 Ok(self.bump())
5959 } else if self.at(TokenKind::Eof) {
5960 Err(self.eof_error())
5961 } else {
5962 let got = self.peek().clone();
5963 Err(Error::expected(
5964 got.offset,
5965 vec![
5966 TokenKind::String,
5967 TokenKind::DoubleQuotedString,
5968 TokenKind::QuotedString,
5969 ],
5970 got.kind,
5971 got.text,
5972 ))
5973 }
5974 }
5975
5976 fn is_character_string_token(&self, kind: TokenKind) -> bool {
5977 matches!(
5978 kind,
5979 TokenKind::String | TokenKind::DoubleQuotedString | TokenKind::QuotedString
5980 )
5981 }
5982
5983 fn parse_sql_interval_literal(&mut self) -> Result<Expr> {
5984 let sign = if self.eat(TokenKind::Plus).is_some() {
5985 Some("+")
5986 } else if self.eat(TokenKind::Minus).is_some() {
5987 Some("-")
5988 } else {
5989 None
5990 };
5991 let token = self.parse_character_string_token()?;
5992 let value = if let Some(sign) = sign {
5993 format!("{sign}{}", token.text)
5994 } else {
5995 token.text
5996 };
5997 let qualifier = self.parse_sql_interval_qualifier()?;
5998 Ok(Expr::Literal(Literal::SqlInterval { value, qualifier }))
5999 }
6000
6001 fn parse_sql_interval_qualifier(&mut self) -> Result<SqlIntervalQualifier> {
6002 let (start, start_kind, start_precision, start_fractional_precision) =
6003 self.parse_sql_interval_start_field()?;
6004 let (end, end_precision) = if self.eat(TokenKind::To).is_some() {
6005 if start_fractional_precision.is_some() {
6006 return Err(Error::Message {
6007 offset: self.peek().offset,
6008 message:
6009 "SECOND interval qualifier cannot specify fractional precision before TO"
6010 .to_owned(),
6011 });
6012 }
6013 let end_offset = self.peek().offset;
6014 let (end, end_kind, end_precision) = self.parse_sql_interval_end_field()?;
6015 self.validate_sql_interval_range(start_kind, end_kind, end_offset)?;
6016 (Some(end), end_precision)
6017 } else {
6018 (None, start_fractional_precision)
6019 };
6020 Ok(SqlIntervalQualifier {
6021 start,
6022 start_precision,
6023 end,
6024 end_precision,
6025 })
6026 }
6027
6028 fn parse_sql_interval_start_field(
6029 &mut self,
6030 ) -> Result<(Identifier, SqlIntervalFieldKind, Option<u64>, Option<u64>)> {
6031 let (field, kind) = self.parse_sql_interval_field_name()?;
6032 let (precision, fractional_precision) = if self.eat(TokenKind::LParen).is_some() {
6033 let precision = self.parse_u64_literal()?;
6034 let fractional_precision = if self.eat(TokenKind::Comma).is_some() {
6035 if kind != SqlIntervalFieldKind::Second {
6036 return Err(Error::Message {
6037 offset: self.peek().offset,
6038 message: "only SECOND interval field can specify fractional precision"
6039 .to_owned(),
6040 });
6041 }
6042 Some(self.parse_u64_literal()?)
6043 } else {
6044 None
6045 };
6046 self.expect(TokenKind::RParen)?;
6047 (Some(precision), fractional_precision)
6048 } else {
6049 (None, None)
6050 };
6051 Ok((field, kind, precision, fractional_precision))
6052 }
6053
6054 fn parse_sql_interval_end_field(
6055 &mut self,
6056 ) -> Result<(Identifier, SqlIntervalFieldKind, Option<u64>)> {
6057 let (field, kind) = self.parse_sql_interval_field_name()?;
6058 let precision = if self.eat(TokenKind::LParen).is_some() {
6059 if kind != SqlIntervalFieldKind::Second {
6060 return Err(Error::Message {
6061 offset: self.peek().offset,
6062 message: "only SECOND end interval field can specify fractional precision"
6063 .to_owned(),
6064 });
6065 }
6066 let precision = self.parse_u64_literal()?;
6067 self.expect(TokenKind::RParen)?;
6068 Some(precision)
6069 } else {
6070 None
6071 };
6072 Ok((field, kind, precision))
6073 }
6074
6075 fn parse_sql_interval_field_name(&mut self) -> Result<(Identifier, SqlIntervalFieldKind)> {
6076 let offset = self.peek().offset;
6077 let field = self.parse_identifier()?;
6078 let kind = match field.value.to_ascii_uppercase().as_str() {
6079 "YEAR" => SqlIntervalFieldKind::Year,
6080 "MONTH" => SqlIntervalFieldKind::Month,
6081 "DAY" => SqlIntervalFieldKind::Day,
6082 "HOUR" => SqlIntervalFieldKind::Hour,
6083 "MINUTE" => SqlIntervalFieldKind::Minute,
6084 "SECOND" => SqlIntervalFieldKind::Second,
6085 _ => {
6086 return Err(Error::Message {
6087 offset,
6088 message: format!("invalid interval field '{}'", field.value),
6089 });
6090 }
6091 };
6092 Ok((field, kind))
6093 }
6094
6095 fn validate_sql_interval_range(
6096 &self,
6097 start: SqlIntervalFieldKind,
6098 end: SqlIntervalFieldKind,
6099 offset: usize,
6100 ) -> Result<()> {
6101 let valid = matches!(
6102 (start, end),
6103 (SqlIntervalFieldKind::Year, SqlIntervalFieldKind::Month)
6104 | (SqlIntervalFieldKind::Day, SqlIntervalFieldKind::Hour)
6105 | (SqlIntervalFieldKind::Day, SqlIntervalFieldKind::Minute)
6106 | (SqlIntervalFieldKind::Day, SqlIntervalFieldKind::Second)
6107 | (SqlIntervalFieldKind::Hour, SqlIntervalFieldKind::Minute)
6108 | (SqlIntervalFieldKind::Hour, SqlIntervalFieldKind::Second)
6109 | (SqlIntervalFieldKind::Minute, SqlIntervalFieldKind::Second)
6110 );
6111 if !valid {
6112 return Err(Error::Message {
6113 offset,
6114 message: "invalid SQL interval qualifier range".to_owned(),
6115 });
6116 }
6117 Ok(())
6118 }
6119
6120 fn expr_to_element_variable(&self, expr: Expr, predicate: &str) -> Result<Identifier> {
6121 if let Expr::Identifier(identifier) = expr {
6122 Ok(identifier)
6123 } else {
6124 Err(Error::Message {
6125 offset: self.peek().offset,
6126 message: format!("{predicate} predicate target must be an element variable"),
6127 })
6128 }
6129 }
6130
6131 fn parse_case_expression(&mut self) -> Result<Expr> {
6132 let operand = if self.at(TokenKind::When) {
6133 None
6134 } else {
6135 Some(Box::new(self.parse_expr()?))
6136 };
6137
6138 let mut when_clauses = Vec::new();
6139 while self.eat(TokenKind::When).is_some() {
6140 let condition = self.parse_case_when_operand(operand.as_deref())?;
6141 let mut additional_operands = Vec::new();
6142 if operand.is_some() {
6143 while self.eat(TokenKind::Comma).is_some() {
6144 additional_operands.push(self.parse_case_when_operand(operand.as_deref())?);
6145 }
6146 }
6147 self.expect(TokenKind::Then)?;
6148 let result = self.parse_expr()?;
6149 when_clauses.push(CaseWhenClause {
6150 condition,
6151 additional_operands,
6152 result,
6153 });
6154 }
6155
6156 if when_clauses.is_empty() {
6157 return Err(self.error_expected(vec![TokenKind::When], self.peek_kind()));
6158 }
6159
6160 let else_expr = if self.eat(TokenKind::Else).is_some() {
6161 Some(Box::new(self.parse_expr()?))
6162 } else {
6163 None
6164 };
6165 self.expect(TokenKind::End)?;
6166
6167 Ok(Expr::Case {
6168 operand,
6169 when_clauses,
6170 else_expr,
6171 })
6172 }
6173
6174 fn parse_case_when_operand(&mut self, operand: Option<&Expr>) -> Result<Expr> {
6175 let Some(operand) = operand else {
6176 return self.parse_expr();
6177 };
6178
6179 let op = match self.peek_kind() {
6180 TokenKind::Eq => Some(BinaryOp::Eq),
6181 TokenKind::Neq => Some(BinaryOp::Neq),
6182 TokenKind::Lt => Some(BinaryOp::Lt),
6183 TokenKind::Le => Some(BinaryOp::Le),
6184 TokenKind::Gt => Some(BinaryOp::Gt),
6185 TokenKind::Ge => Some(BinaryOp::Ge),
6186 TokenKind::Is => {
6187 self.bump();
6188 let negated = self.eat(TokenKind::Not).is_some();
6189 return self.parse_is_predicate_tail(operand.clone(), negated);
6190 }
6191 _ => None,
6192 };
6193
6194 if let Some(op) = op {
6195 self.bump();
6196 let right = self.parse_concat()?;
6197 return Ok(Expr::Binary {
6198 left: Box::new(operand.clone()),
6199 op,
6200 right: Box::new(right),
6201 });
6202 }
6203
6204 self.parse_case_when_value_operand()
6205 }
6206
6207 fn parse_case_when_value_operand(&mut self) -> Result<Expr> {
6208 if self.at(TokenKind::LParen) {
6209 return Err(Error::Message {
6210 offset: self.peek().offset,
6211 message: "simple CASE WHEN operand must be a non-parenthesized value primary"
6212 .to_owned(),
6213 });
6214 }
6215 self.parse_postfix()
6216 }
6217
6218 fn parse_coalesce_expression(&mut self) -> Result<Expr> {
6219 self.expect(TokenKind::LParen)?;
6220 let mut args = vec![self.parse_expr()?];
6221 self.expect(TokenKind::Comma)?;
6222 args.push(self.parse_expr()?);
6223 while self.eat(TokenKind::Comma).is_some() {
6224 args.push(self.parse_expr()?);
6225 }
6226 self.expect(TokenKind::RParen)?;
6227 Ok(Expr::Coalesce(args))
6228 }
6229
6230 fn parse_nullif_expression(&mut self) -> Result<Expr> {
6231 self.expect(TokenKind::LParen)?;
6232 let left = self.parse_expr()?;
6233 self.expect(TokenKind::Comma)?;
6234 let right = self.parse_expr()?;
6235 self.expect(TokenKind::RParen)?;
6236 Ok(Expr::NullIf {
6237 left: Box::new(left),
6238 right: Box::new(right),
6239 })
6240 }
6241
6242 fn parse_property_exists_predicate(&mut self) -> Result<Expr> {
6243 self.expect(TokenKind::LParen)?;
6244 let variable = self.parse_identifier()?;
6245 self.expect(TokenKind::Comma)?;
6246 let property = self.parse_identifier()?;
6247 self.expect(TokenKind::RParen)?;
6248 Ok(Expr::PropertyExists { variable, property })
6249 }
6250
6251 fn parse_exists_predicate(&mut self) -> Result<Expr> {
6252 if self.eat(TokenKind::LBrace).is_some() {
6253 let mut trial = self.clone();
6254 if let Ok(query) = trial.parse_query_statement() {
6255 if trial.eat(TokenKind::RBrace).is_some() {
6256 *self = trial;
6257 return Ok(Expr::ExistsQuery {
6258 query: Box::new(query),
6259 });
6260 }
6261 }
6262 if matches!(self.peek_kind(), TokenKind::Optional | TokenKind::Match) {
6263 let matches = self.parse_match_statement_block(TokenKind::RBrace)?;
6264 self.expect(TokenKind::RBrace)?;
6265 return Ok(Expr::ExistsMatch { matches });
6266 }
6267 let patterns = self.parse_pattern_list()?;
6268 self.expect(TokenKind::RBrace)?;
6269 Ok(Expr::Exists { patterns })
6270 } else if self.eat(TokenKind::LParen).is_some() {
6271 if matches!(self.peek_kind(), TokenKind::Optional | TokenKind::Match) {
6272 let matches = self.parse_match_statement_block(TokenKind::RParen)?;
6273 self.expect(TokenKind::RParen)?;
6274 return Ok(Expr::ExistsMatch { matches });
6275 }
6276 let patterns = self.parse_pattern_list()?;
6277 self.expect(TokenKind::RParen)?;
6278 Ok(Expr::Exists { patterns })
6279 } else {
6280 Err(self.error_expected(vec![TokenKind::LBrace, TokenKind::LParen], self.peek_kind()))
6281 }
6282 }
6283
6284 fn parse_match_statement_block(&mut self, closing: TokenKind) -> Result<Vec<MatchClause>> {
6285 let mut matches = Vec::new();
6286 while matches!(self.peek_kind(), TokenKind::Optional | TokenKind::Match) {
6287 matches.push(self.parse_match_clause()?);
6288 }
6289 if matches.is_empty() {
6290 return Err(self.error_expected(
6291 vec![TokenKind::Optional, TokenKind::Match],
6292 self.peek_kind(),
6293 ));
6294 }
6295 if self.at(closing) {
6296 Ok(matches)
6297 } else {
6298 Err(self.error_expected(vec![closing], self.peek_kind()))
6299 }
6300 }
6301
6302 fn parse_same_predicate(&mut self) -> Result<Expr> {
6303 Ok(Expr::Same {
6304 variables: self.parse_element_variable_list_with_min_two()?,
6305 })
6306 }
6307
6308 fn parse_all_different_predicate(&mut self) -> Result<Expr> {
6309 Ok(Expr::AllDifferent {
6310 variables: self.parse_element_variable_list_with_min_two()?,
6311 })
6312 }
6313
6314 fn parse_element_variable_list_with_min_two(&mut self) -> Result<Vec<Identifier>> {
6315 self.expect(TokenKind::LParen)?;
6316 let mut variables = vec![self.parse_identifier()?];
6317 self.expect(TokenKind::Comma)?;
6318 variables.push(self.parse_identifier()?);
6319 while self.eat(TokenKind::Comma).is_some() {
6320 variables.push(self.parse_identifier()?);
6321 }
6322 self.expect(TokenKind::RParen)?;
6323 Ok(variables)
6324 }
6325
6326 fn parse_map_literal(&mut self) -> Result<MapLiteral> {
6327 self.expect(TokenKind::LBrace)?;
6328 let mut entries = Vec::new();
6329 let mut field_names = std::collections::HashSet::new();
6330 if !self.at(TokenKind::RBrace) {
6331 loop {
6332 let key_offset = self.peek().offset;
6333 let key = self.parse_identifier()?;
6334 let normalized_key = key.value.to_ascii_uppercase();
6335 if !field_names.insert(normalized_key) {
6336 return Err(Error::Message {
6337 offset: key_offset,
6338 message: format!("duplicate field '{}'", key.value),
6339 });
6340 }
6341 self.expect(TokenKind::Colon)?;
6342 let value = self.parse_expr()?;
6343 entries.push((key, value));
6344 if self.eat(TokenKind::Comma).is_none() {
6345 break;
6346 }
6347 }
6348 }
6349 self.expect(TokenKind::RBrace)?;
6350 Ok(MapLiteral { entries })
6351 }
6352
6353 fn parse_identifier(&mut self) -> Result<Identifier> {
6354 if is_identifier_like(self.peek_kind()) {
6355 Ok(Identifier::new(self.bump().text))
6356 } else if self.at(TokenKind::Eof) {
6357 Err(self.eof_error())
6358 } else {
6359 let got = self.peek().clone();
6360 Err(Error::expected(
6361 got.offset,
6362 vec![TokenKind::Identifier],
6363 got.kind,
6364 got.text,
6365 ))
6366 }
6367 }
6368
6369 fn expect(&mut self, kind: TokenKind) -> Result<Token> {
6370 if self.at(kind) {
6371 Ok(self.bump())
6372 } else if self.at(TokenKind::Eof) {
6373 Err(self.eof_error())
6374 } else {
6375 let got = self.peek().clone();
6376 Err(Error::expected(got.offset, vec![kind], got.kind, got.text))
6377 }
6378 }
6379
6380 fn eat(&mut self, kind: TokenKind) -> Option<Token> {
6381 if self.at(kind) {
6382 Some(self.bump())
6383 } else {
6384 None
6385 }
6386 }
6387
6388 fn eat_many(&mut self, kind: TokenKind) {
6389 while self.at(kind) {
6390 self.bump();
6391 }
6392 }
6393
6394 fn bump(&mut self) -> Token {
6395 let token = self.peek().clone();
6396 if !self.at(TokenKind::Eof) {
6397 self.pos += 1;
6398 }
6399 token
6400 }
6401
6402 fn at(&self, kind: TokenKind) -> bool {
6403 self.peek_kind() == kind
6404 }
6405
6406 fn peek(&self) -> &Token {
6407 &self.tokens[self.pos]
6408 }
6409
6410 fn peek_kind(&self) -> TokenKind {
6411 self.peek().kind
6412 }
6413
6414 fn peek_n_kind(&self, n: usize) -> Option<TokenKind> {
6415 self.tokens.get(self.pos + n).map(|token| token.kind)
6416 }
6417
6418 fn error_expected(&self, expected: Vec<TokenKind>, got: TokenKind) -> Error {
6419 if got == TokenKind::Eof {
6420 if let Some(err) = self.lexer_error.clone() {
6421 return err;
6422 }
6423 }
6424 let token = self.peek();
6425 Error::expected(token.offset, expected, got, token.text.clone())
6426 }
6427
6428 fn eof_error(&self) -> Error {
6429 self.lexer_error.clone().unwrap_or(Error::UnexpectedEof)
6430 }
6431
6432 fn enter(&mut self) -> Result<()> {
6433 self.depth += 1;
6434 if self.depth > MAX_PARSE_DEPTH {
6435 return Err(Error::Message {
6436 offset: self.peek().offset,
6437 message: "input is nested too deeply".to_owned(),
6438 });
6439 }
6440 Ok(())
6441 }
6442
6443 fn exit(&mut self) {
6444 self.depth = self.depth.saturating_sub(1);
6445 }
6446
6447 fn check_chain(&self, len: u32) -> Result<()> {
6448 if len > MAX_EXPR_CHAIN {
6449 return Err(Error::Message {
6450 offset: self.peek().offset,
6451 message: "expression is too long".to_owned(),
6452 });
6453 }
6454 Ok(())
6455 }
6456}
6457
6458fn parameter_name(text: &str) -> String {
6459 text.strip_prefix('$').unwrap_or(text).to_owned()
6460}
6461
6462fn apply_path_pattern_factor_to_term(
6463 factor: &PathPatternFactor,
6464 start: &mut Option<NodePattern>,
6465 chains: &mut Vec<PathPatternChain>,
6466 pending_relationship: &mut Option<RelationshipPattern>,
6467) {
6468 match factor {
6469 PathPatternFactor::Relationship(relationship) => {
6470 if let Some(pending) = pending_relationship.take() {
6471 if start.is_none() {
6472 *start = Some(empty_node_pattern());
6473 }
6474 chains.push(PathPatternChain {
6475 relationship: pending,
6476 node: empty_node_pattern(),
6477 });
6478 }
6479 *pending_relationship = Some(relationship.clone());
6480 }
6481 PathPatternFactor::Node(node) => {
6482 apply_path_pattern_node_to_term(node.clone(), start, chains, pending_relationship);
6483 }
6484 PathPatternFactor::Parenthesized(parenthesized) => {
6485 apply_path_pattern_node_to_term(
6486 parenthesized.pattern.start.clone(),
6487 start,
6488 chains,
6489 pending_relationship,
6490 );
6491 }
6492 PathPatternFactor::Alternation { alternatives, .. } => {
6493 if let Some(first) = alternatives.first() {
6494 for factor in first {
6495 apply_path_pattern_factor_to_term(factor, start, chains, pending_relationship);
6496 }
6497 }
6498 }
6499 }
6500}
6501
6502fn apply_path_pattern_node_to_term(
6503 node: NodePattern,
6504 start: &mut Option<NodePattern>,
6505 chains: &mut Vec<PathPatternChain>,
6506 pending_relationship: &mut Option<RelationshipPattern>,
6507) {
6508 if let Some(relationship) = pending_relationship.take() {
6509 if start.is_none() {
6510 *start = Some(empty_node_pattern());
6511 }
6512 chains.push(PathPatternChain { relationship, node });
6513 } else if start.is_none() {
6514 *start = Some(node);
6515 }
6516}
6517
6518fn path_pattern_factors_from_flat_path(
6519 start: &NodePattern,
6520 chains: &[PathPatternChain],
6521) -> Vec<PathPatternFactor> {
6522 let mut factors = vec![PathPatternFactor::Node(start.clone())];
6523 for chain in chains {
6524 factors.push(PathPatternFactor::Relationship(chain.relationship.clone()));
6525 factors.push(PathPatternFactor::Node(chain.node.clone()));
6526 }
6527 factors
6528}
6529
6530fn empty_node_pattern() -> NodePattern {
6531 NodePattern {
6532 variable: None,
6533 temporary: false,
6534 labels: Vec::new(),
6535 label_expression: None,
6536 properties: None,
6537 where_clause: None,
6538 quantifier: None,
6539 }
6540}
6541
6542fn validate_graph_pattern_yield_clause(
6543 patterns: &[PathPattern],
6544 yield_clause: &YieldClause,
6545 offset: usize,
6546) -> Result<()> {
6547 let mut variables = Vec::new();
6548 for pattern in patterns {
6549 collect_path_pattern_variables(pattern, &mut variables);
6550 }
6551
6552 for item in &yield_clause.items {
6553 let YieldItem::Item { name, .. } = item else {
6554 continue;
6555 };
6556 if !variables
6557 .iter()
6558 .any(|variable: &Identifier| variable.value.eq_ignore_ascii_case(&name.value))
6559 {
6560 return Err(Error::Message {
6561 offset,
6562 message: format!(
6563 "graph pattern yield variable '{}' is not declared",
6564 name.value
6565 ),
6566 });
6567 }
6568 }
6569 Ok(())
6570}
6571
6572fn validate_insert_graph_pattern_variables(patterns: &[PathPattern], offset: usize) -> Result<()> {
6573 let mut declarations = Vec::new();
6574 for pattern in patterns {
6575 validate_insert_node_pattern_variable(&pattern.start, &mut declarations, offset)?;
6576 for chain in &pattern.chains {
6577 validate_insert_relationship_pattern_variable(
6578 &chain.relationship,
6579 &mut declarations,
6580 offset,
6581 )?;
6582 validate_insert_node_pattern_variable(&chain.node, &mut declarations, offset)?;
6583 }
6584 }
6585 Ok(())
6586}
6587
6588fn validate_insert_node_pattern_variable(
6589 node: &NodePattern,
6590 declarations: &mut Vec<(Identifier, InsertElementKind, bool)>,
6591 offset: usize,
6592) -> Result<()> {
6593 validate_insert_element_variable(
6594 node.variable.as_ref(),
6595 InsertElementKind::Node,
6596 insert_node_pattern_has_label_or_property_set(node),
6597 declarations,
6598 offset,
6599 )
6600}
6601
6602fn validate_insert_relationship_pattern_variable(
6603 relationship: &RelationshipPattern,
6604 declarations: &mut Vec<(Identifier, InsertElementKind, bool)>,
6605 offset: usize,
6606) -> Result<()> {
6607 validate_insert_element_variable(
6608 relationship.variable.as_ref(),
6609 InsertElementKind::Edge,
6610 insert_relationship_pattern_has_label_or_property_set(relationship),
6611 declarations,
6612 offset,
6613 )
6614}
6615
6616fn validate_insert_element_variable(
6617 variable: Option<&Identifier>,
6618 kind: InsertElementKind,
6619 has_label_or_property_set: bool,
6620 declarations: &mut Vec<(Identifier, InsertElementKind, bool)>,
6621 offset: usize,
6622) -> Result<()> {
6623 let Some(variable) = variable else {
6624 return Ok(());
6625 };
6626
6627 let duplicate = declarations
6628 .iter()
6629 .find(|(existing, _, _)| existing.value.eq_ignore_ascii_case(&variable.value));
6630 if let Some((_, existing_kind, _)) = duplicate {
6631 if kind == InsertElementKind::Edge || *existing_kind == InsertElementKind::Edge {
6632 return Err(Error::Message {
6633 offset,
6634 message: format!(
6635 "insert edge variable '{}' cannot duplicate another element variable",
6636 variable.value
6637 ),
6638 });
6639 }
6640 if has_label_or_property_set {
6641 return Err(Error::Message {
6642 offset,
6643 message: format!(
6644 "repeated insert element variable '{}' cannot contain labels or properties",
6645 variable.value
6646 ),
6647 });
6648 }
6649 }
6650
6651 declarations.push((variable.clone(), kind, has_label_or_property_set));
6652 Ok(())
6653}
6654
6655fn insert_node_pattern_has_label_or_property_set(node: &NodePattern) -> bool {
6656 !node.labels.is_empty() || node.label_expression.is_some() || node.properties.is_some()
6657}
6658
6659fn insert_relationship_pattern_has_label_or_property_set(
6660 relationship: &RelationshipPattern,
6661) -> bool {
6662 !relationship.labels.is_empty()
6663 || relationship.label_expression.is_some()
6664 || relationship.properties.is_some()
6665}
6666
6667fn validate_set_item_conflicts(existing: &[SetItem], item: &SetItem, offset: usize) -> Result<()> {
6668 let Some(target) = set_item_assignment_target(item) else {
6669 return Ok(());
6670 };
6671
6672 for existing_item in existing {
6673 let Some(existing_target) = set_item_assignment_target(existing_item) else {
6674 continue;
6675 };
6676 match (existing_target, target) {
6677 (
6678 SetAssignmentTarget::Property {
6679 variable: existing_variable,
6680 property: existing_property,
6681 },
6682 SetAssignmentTarget::Property { variable, property },
6683 ) if existing_variable.eq_ignore_ascii_case(variable)
6684 && existing_property.eq_ignore_ascii_case(property) =>
6685 {
6686 return Err(Error::Message {
6687 offset,
6688 message: format!(
6689 "duplicate SET assignment to property '{variable}.{property}'"
6690 ),
6691 });
6692 }
6693 (
6694 SetAssignmentTarget::AllProperties {
6695 variable: existing_variable,
6696 },
6697 SetAssignmentTarget::AllProperties { variable },
6698 ) if existing_variable.eq_ignore_ascii_case(variable) => {
6699 return Err(Error::Message {
6700 offset,
6701 message: format!("duplicate SET all-properties assignment to '{variable}'"),
6702 });
6703 }
6704 (
6705 SetAssignmentTarget::AllProperties {
6706 variable: existing_variable,
6707 },
6708 SetAssignmentTarget::Property { variable, .. },
6709 )
6710 | (
6711 SetAssignmentTarget::Property {
6712 variable: existing_variable,
6713 ..
6714 },
6715 SetAssignmentTarget::AllProperties { variable },
6716 ) if existing_variable.eq_ignore_ascii_case(variable) => {
6717 return Err(Error::Message {
6718 offset,
6719 message: format!(
6720 "SET all-properties assignment conflicts with property assignment for '{variable}'"
6721 ),
6722 });
6723 }
6724 _ => {}
6725 }
6726 }
6727
6728 Ok(())
6729}
6730
6731#[derive(Clone, Copy)]
6732enum SetAssignmentTarget<'a> {
6733 Property {
6734 variable: &'a str,
6735 property: &'a str,
6736 },
6737 AllProperties {
6738 variable: &'a str,
6739 },
6740}
6741
6742fn set_item_assignment_target(item: &SetItem) -> Option<SetAssignmentTarget<'_>> {
6743 match item {
6744 SetItem::Property {
6745 target:
6746 Expr::Property {
6747 base,
6748 key: property,
6749 },
6750 ..
6751 } => {
6752 let Expr::Identifier(variable) = base.as_ref() else {
6753 return None;
6754 };
6755 Some(SetAssignmentTarget::Property {
6756 variable: variable.value.as_str(),
6757 property: property.value.as_str(),
6758 })
6759 }
6760 SetItem::AllProperties { variable, .. } => Some(SetAssignmentTarget::AllProperties {
6761 variable: variable.value.as_str(),
6762 }),
6763 SetItem::Label { .. } | SetItem::Property { .. } => None,
6764 }
6765}
6766
6767fn validate_graph_type_element_name(
6768 existing: &[GraphTypeElement],
6769 element: &GraphTypeElement,
6770 offset: usize,
6771) -> Result<()> {
6772 let Some((kind, name)) = graph_type_element_kind_and_name(element) else {
6773 return Ok(());
6774 };
6775 let duplicate = existing.iter().any(|existing| {
6776 graph_type_element_kind_and_name(existing).is_some_and(|(existing_kind, existing_name)| {
6777 existing_kind == kind && existing_name.eq_ignore_ascii_case(name)
6778 })
6779 });
6780 if duplicate {
6781 return Err(Error::Message {
6782 offset,
6783 message: format!("duplicate {kind} type name '{name}'"),
6784 });
6785 }
6786 Ok(())
6787}
6788
6789fn graph_type_element_kind_and_name(element: &GraphTypeElement) -> Option<(&'static str, &str)> {
6790 match element {
6791 GraphTypeElement::Node(node) if !node.name.value.is_empty() => {
6792 Some(("node", node.name.value.as_str()))
6793 }
6794 GraphTypeElement::Edge(edge) if !edge.name.value.is_empty() => {
6795 Some(("edge", edge.name.value.as_str()))
6796 }
6797 _ => None,
6798 }
6799}
6800
6801fn validate_graph_type_body_edge_phrase(
6802 context: GraphTypeElementContext,
6803 edge_kind: Option<Direction>,
6804 name: &Identifier,
6805 offset: usize,
6806) -> Result<()> {
6807 if context != GraphTypeElementContext::GraphTypeSpecificationBody {
6808 return Ok(());
6809 }
6810 if edge_kind.is_none() {
6811 return Err(Error::Message {
6812 offset,
6813 message: "graph type body edge type phrase requires DIRECTED or UNDIRECTED".to_owned(),
6814 });
6815 }
6816 if name.value.is_empty() {
6817 return Err(Error::Message {
6818 offset,
6819 message: "graph type body edge type phrase requires an edge type name".to_owned(),
6820 });
6821 }
6822 Ok(())
6823}
6824
6825fn validate_closed_edge_reference_definition(
6826 definition: &EdgeTypeDefinition,
6827 offset: usize,
6828) -> Result<()> {
6829 if !definition.name.value.is_empty() {
6830 return Err(Error::Message {
6831 offset,
6832 message: "closed edge reference type cannot contain an edge type name".to_owned(),
6833 });
6834 }
6835 if definition.source.is_some() || definition.destination.is_some() {
6836 return Err(Error::Message {
6837 offset,
6838 message: "closed edge reference type cannot contain endpoint node type names"
6839 .to_owned(),
6840 });
6841 }
6842 Ok(())
6843}
6844
6845fn validate_endpoint_pair_shape(
6846 explicit_edge_kind: Option<Direction>,
6847 endpoint_shape: Direction,
6848 offset: usize,
6849) -> Result<()> {
6850 match (explicit_edge_kind, endpoint_shape) {
6851 (Some(Direction::Right), Direction::Undirected) => Err(Error::Message {
6852 offset,
6853 message: "DIRECTED edge type cannot use an undirected endpoint pair".to_owned(),
6854 }),
6855 (Some(Direction::Undirected), Direction::Right) => Err(Error::Message {
6856 offset,
6857 message: "UNDIRECTED edge type requires an undirected endpoint pair".to_owned(),
6858 }),
6859 _ => Ok(()),
6860 }
6861}
6862
6863fn validate_dynamic_union_component_nullability(
6864 components: &[ValueType],
6865 offset: usize,
6866) -> Result<()> {
6867 let Some(first) = components.first() else {
6868 return Ok(());
6869 };
6870 let first_is_not_null = is_known_not_null_value_type(first);
6871 if components
6872 .iter()
6873 .any(|component| is_known_not_null_value_type(component) != first_is_not_null)
6874 {
6875 return Err(Error::Message {
6876 offset,
6877 message: "dynamic union component types must have matching nullability".to_owned(),
6878 });
6879 }
6880 Ok(())
6881}
6882
6883fn is_known_not_null_value_type(value_type: &ValueType) -> bool {
6884 matches!(value_type, ValueType::NotNull(_))
6885}
6886
6887fn validate_graph_type_endpoint_node_types(
6888 elements: &[GraphTypeElement],
6889 offset: usize,
6890) -> Result<()> {
6891 for element in elements {
6892 let GraphTypeElement::Edge(edge) = element else {
6893 continue;
6894 };
6895 validate_graph_type_endpoint_node_type(elements, edge.source.as_ref(), offset)?;
6896 validate_graph_type_endpoint_node_type(elements, edge.destination.as_ref(), offset)?;
6897 }
6898 Ok(())
6899}
6900
6901fn validate_graph_type_endpoint_node_type(
6902 elements: &[GraphTypeElement],
6903 endpoint: Option<&Identifier>,
6904 offset: usize,
6905) -> Result<()> {
6906 let Some(endpoint) = endpoint else {
6907 return Ok(());
6908 };
6909 if elements.iter().any(|element| {
6910 matches!(
6911 element,
6912 GraphTypeElement::Node(node)
6913 if !node.name.value.is_empty()
6914 && node.name.value.eq_ignore_ascii_case(&endpoint.value)
6915 )
6916 }) {
6917 return Ok(());
6918 }
6919 Err(Error::Message {
6920 offset,
6921 message: format!("endpoint node type '{}' is not defined", endpoint.value),
6922 })
6923}
6924
6925fn collect_path_pattern_variables(pattern: &PathPattern, variables: &mut Vec<Identifier>) {
6926 push_identifier_if_absent(variables, pattern.variable.as_ref());
6927 collect_node_pattern_variables(&pattern.start, variables);
6928 for chain in &pattern.chains {
6929 collect_relationship_pattern_variables(&chain.relationship, variables);
6930 collect_node_pattern_variables(&chain.node, variables);
6931 }
6932 for factor in &pattern.factors {
6933 collect_path_pattern_factor_variables(factor, variables);
6934 }
6935 for alternative in &pattern.alternatives {
6936 collect_node_pattern_variables(&alternative.start, variables);
6937 for chain in &alternative.chains {
6938 collect_relationship_pattern_variables(&chain.relationship, variables);
6939 collect_node_pattern_variables(&chain.node, variables);
6940 }
6941 for factor in &alternative.factors {
6942 collect_path_pattern_factor_variables(factor, variables);
6943 }
6944 }
6945 if let Some(parenthesized) = &pattern.parenthesized {
6946 collect_path_pattern_variables(&parenthesized.pattern, variables);
6947 }
6948}
6949
6950fn collect_path_pattern_factor_variables(
6951 factor: &PathPatternFactor,
6952 variables: &mut Vec<Identifier>,
6953) {
6954 match factor {
6955 PathPatternFactor::Node(node) => collect_node_pattern_variables(node, variables),
6956 PathPatternFactor::Relationship(relationship) => {
6957 collect_relationship_pattern_variables(relationship, variables);
6958 }
6959 PathPatternFactor::Parenthesized(parenthesized) => {
6960 collect_path_pattern_variables(&parenthesized.pattern, variables);
6961 }
6962 PathPatternFactor::Alternation { alternatives, .. } => {
6963 for alternative in alternatives {
6964 for factor in alternative {
6965 collect_path_pattern_factor_variables(factor, variables);
6966 }
6967 }
6968 }
6969 }
6970}
6971
6972fn collect_node_pattern_variables(node: &NodePattern, variables: &mut Vec<Identifier>) {
6973 if !node.temporary {
6974 push_identifier_if_absent(variables, node.variable.as_ref());
6975 }
6976}
6977
6978fn collect_relationship_pattern_variables(
6979 relationship: &RelationshipPattern,
6980 variables: &mut Vec<Identifier>,
6981) {
6982 if !relationship.temporary {
6983 push_identifier_if_absent(variables, relationship.variable.as_ref());
6984 }
6985}
6986
6987fn push_identifier_if_absent(variables: &mut Vec<Identifier>, candidate: Option<&Identifier>) {
6988 let Some(candidate) = candidate else {
6989 return;
6990 };
6991 if !variables
6992 .iter()
6993 .any(|variable| variable.value.eq_ignore_ascii_case(&candidate.value))
6994 {
6995 variables.push(candidate.clone());
6996 }
6997}
6998
6999fn is_statement_follow(kind: TokenKind) -> bool {
7000 matches!(
7001 kind,
7002 TokenKind::Semicolon | TokenKind::Next | TokenKind::RBrace | TokenKind::Eof
7003 )
7004}
7005
7006impl DateTimeFunctionKind {
7007 fn name(self) -> &'static str {
7008 match self {
7009 DateTimeFunctionKind::Date => "DATE",
7010 DateTimeFunctionKind::ZonedTime => "ZONED_TIME",
7011 DateTimeFunctionKind::ZonedDateTime => "ZONED_DATETIME",
7012 DateTimeFunctionKind::LocalTime => "LOCAL_TIME",
7013 DateTimeFunctionKind::LocalDateTime => "LOCAL_DATETIME",
7014 }
7015 }
7016}
7017
7018fn starts_transaction_procedure(kind: TokenKind) -> bool {
7019 matches!(
7020 kind,
7021 TokenKind::At
7022 | TokenKind::Use
7023 | TokenKind::Match
7024 | TokenKind::Optional
7025 | TokenKind::Filter
7026 | TokenKind::Let
7027 | TokenKind::For
7028 | TokenKind::Order
7029 | TokenKind::Offset
7030 | TokenKind::Skip
7031 | TokenKind::Limit
7032 | TokenKind::LBrace
7033 | TokenKind::Return
7034 | TokenKind::Select
7035 | TokenKind::Finish
7036 | TokenKind::Call
7037 | TokenKind::Insert
7038 | TokenKind::Delete
7039 | TokenKind::Detach
7040 | TokenKind::Nodetach
7041 | TokenKind::Set
7042 | TokenKind::Remove
7043 | TokenKind::Create
7044 | TokenKind::Drop
7045 )
7046}
7047
7048fn is_identifier_like(kind: TokenKind) -> bool {
7049 matches!(
7050 kind,
7051 TokenKind::Identifier
7052 | TokenKind::DoubleQuotedString
7053 | TokenKind::QuotedString
7054 | TokenKind::Match
7055 | TokenKind::Optional
7056 | TokenKind::Where
7057 | TokenKind::Filter
7058 | TokenKind::Let
7059 | TokenKind::For
7060 | TokenKind::ParameterKeyword
7061 | TokenKind::Parameters
7062 | TokenKind::Characteristics
7063 | TokenKind::In
7064 | TokenKind::Between
7065 | TokenKind::Call
7066 | TokenKind::Yield
7067 | TokenKind::Next
7068 | TokenKind::Select
7069 | TokenKind::Return
7070 | TokenKind::Distinct
7071 | TokenKind::All
7072 | TokenKind::As
7073 | TokenKind::With
7074 | TokenKind::Group
7075 | TokenKind::Groups
7076 | TokenKind::Having
7077 | TokenKind::Keep
7078 | TokenKind::Order
7079 | TokenKind::By
7080 | TokenKind::Asc
7081 | TokenKind::Ascending
7082 | TokenKind::Desc
7083 | TokenKind::Descending
7084 | TokenKind::Nulls
7085 | TokenKind::First
7086 | TokenKind::Last
7087 | TokenKind::Limit
7088 | TokenKind::Offset
7089 | TokenKind::Skip
7090 | TokenKind::Insert
7091 | TokenKind::Create
7092 | TokenKind::Delete
7093 | TokenKind::Set
7094 | TokenKind::Remove
7095 | TokenKind::Detach
7096 | TokenKind::Nodetach
7097 | TokenKind::Property
7098 | TokenKind::Graph
7099 | TokenKind::Schema
7100 | TokenKind::Type
7101 | TokenKind::Node
7102 | TokenKind::Vertex
7103 | TokenKind::Edge
7104 | TokenKind::Relationship
7105 | TokenKind::Relationships
7106 | TokenKind::From
7107 | TokenKind::To
7108 | TokenKind::Connecting
7109 | TokenKind::If
7110 | TokenKind::Not
7111 | TokenKind::Exists
7112 | TokenKind::Drop
7113 | TokenKind::Use
7114 | TokenKind::At
7115 | TokenKind::Reset
7116 | TokenKind::Close
7117 | TokenKind::Session
7118 | TokenKind::Start
7119 | TokenKind::Transaction
7120 | TokenKind::Read
7121 | TokenKind::Write
7122 | TokenKind::Only
7123 | TokenKind::Isolation
7124 | TokenKind::Level
7125 | TokenKind::Serializable
7126 | TokenKind::Repeatable
7127 | TokenKind::Committed
7128 | TokenKind::Uncommitted
7129 | TokenKind::List
7130 | TokenKind::Array
7131 | TokenKind::Record
7132 | TokenKind::Date
7133 | TokenKind::Time
7134 | TokenKind::Zone
7135 | TokenKind::Datetime
7136 | TokenKind::Timestamp
7137 | TokenKind::Interval
7138 | TokenKind::Duration
7139 | TokenKind::DurationBetween
7140 | TokenKind::CurrentDate
7141 | TokenKind::CurrentTime
7142 | TokenKind::CurrentTimestamp
7143 | TokenKind::CurrentUser
7144 | TokenKind::Localtimestamp
7145 | TokenKind::ZonedTime
7146 | TokenKind::ZonedDatetime
7147 | TokenKind::LocalTime
7148 | TokenKind::LocalDatetime
7149 | TokenKind::Avg
7150 | TokenKind::Count
7151 | TokenKind::Max
7152 | TokenKind::Min
7153 | TokenKind::Sum
7154 | TokenKind::CollectList
7155 | TokenKind::StddevSamp
7156 | TokenKind::StddevPop
7157 | TokenKind::PercentileCont
7158 | TokenKind::PercentileDisc
7159 | TokenKind::Abs
7160 | TokenKind::Mod
7161 | TokenKind::Floor
7162 | TokenKind::Ceil
7163 | TokenKind::Ceiling
7164 | TokenKind::Sqrt
7165 | TokenKind::Power
7166 | TokenKind::Log
7167 | TokenKind::Log10
7168 | TokenKind::Ln
7169 | TokenKind::Exp
7170 | TokenKind::Sin
7171 | TokenKind::Cos
7172 | TokenKind::Tan
7173 | TokenKind::Cot
7174 | TokenKind::Sinh
7175 | TokenKind::Cosh
7176 | TokenKind::Tanh
7177 | TokenKind::Asin
7178 | TokenKind::Acos
7179 | TokenKind::Atan
7180 | TokenKind::Degrees
7181 | TokenKind::Radians
7182 | TokenKind::PathLength
7183 | TokenKind::Case
7184 | TokenKind::Coalesce
7185 | TokenKind::Nullif
7186 | TokenKind::Cast
7187 | TokenKind::When
7188 | TokenKind::Then
7189 | TokenKind::Else
7190 | TokenKind::End
7191 | TokenKind::PropertyExists
7192 | TokenKind::ElementId
7193 | TokenKind::Same
7194 | TokenKind::AllDifferent
7195 | TokenKind::Overlay
7196 | TokenKind::Placing
7197 | TokenKind::Position
7198 | TokenKind::Substring
7199 | TokenKind::Left
7200 | TokenKind::Right
7201 | TokenKind::Trim
7202 | TokenKind::Btrim
7203 | TokenKind::Ltrim
7204 | TokenKind::Rtrim
7205 | TokenKind::Upper
7206 | TokenKind::Lower
7207 | TokenKind::Normalize
7208 | TokenKind::CharLength
7209 | TokenKind::CharacterLength
7210 | TokenKind::ByteLength
7211 | TokenKind::OctetLength
7212 | TokenKind::Leading
7213 | TokenKind::Trailing
7214 | TokenKind::Both
7215 | TokenKind::Source
7216 | TokenKind::Destination
7217 | TokenKind::Of
7218 | TokenKind::Normalized
7219 | TokenKind::Directed
7220 | TokenKind::Undirected
7221 | TokenKind::Labeled
7222 | TokenKind::Label
7223 | TokenKind::Labels
7224 | TokenKind::Commit
7225 | TokenKind::Rollback
7226 | TokenKind::Replace
7227 | TokenKind::Like
7228 | TokenKind::Escape
7229 | TokenKind::Copy
7230 | TokenKind::Current
7231 | TokenKind::CurrentGraph
7232 | TokenKind::CurrentPropertyGraph
7233 | TokenKind::CurrentSchema
7234 | TokenKind::HomeGraph
7235 | TokenKind::HomePropertyGraph
7236 | TokenKind::HomeSchema
7237 | TokenKind::And
7238 | TokenKind::Or
7239 | TokenKind::Xor
7240 | TokenKind::Is
7241 | TokenKind::Typed
7242 | TokenKind::Null
7243 | TokenKind::True
7244 | TokenKind::False
7245 | TokenKind::Unknown
7246 | TokenKind::Value
7247 | TokenKind::Variable
7248 | TokenKind::Union
7249 | TokenKind::Except
7250 | TokenKind::Intersect
7251 | TokenKind::Otherwise
7252 | TokenKind::Ordinality
7253 | TokenKind::Finish
7254 | TokenKind::No
7255 | TokenKind::Binding
7256 | TokenKind::Bindings
7257 | TokenKind::Table
7258 | TokenKind::Temp
7259 | TokenKind::Different
7260 | TokenKind::Element
7261 | TokenKind::Elements
7262 | TokenKind::Edges
7263 | TokenKind::Any
7264 | TokenKind::Shortest
7265 | TokenKind::Walk
7266 | TokenKind::Trail
7267 | TokenKind::Simple
7268 | TokenKind::Acyclic
7269 | TokenKind::Path
7270 | TokenKind::Paths
7271 )
7272}
7273
7274fn is_edge_synonym_kind(kind: TokenKind) -> bool {
7275 matches!(kind, TokenKind::Edge | TokenKind::Relationship)
7276}
7277
7278fn is_type_name_after_type_marker(kind: TokenKind) -> bool {
7279 is_identifier_like(kind)
7280 && !matches!(
7281 kind,
7282 TokenKind::Label
7283 | TokenKind::Labels
7284 | TokenKind::LBrace
7285 | TokenKind::From
7286 | TokenKind::To
7287 | TokenKind::Connecting
7288 | TokenKind::Comma
7289 | TokenKind::RBrace
7290 | TokenKind::Eof
7291 )
7292}
7293
7294fn is_data_modifying_query_clause(clause: &QueryClause) -> bool {
7295 matches!(
7296 clause,
7297 QueryClause::Insert(_)
7298 | QueryClause::Delete(_)
7299 | QueryClause::Set(_)
7300 | QueryClause::Remove(_)
7301 )
7302}
7303
7304fn binding_variable_definition_name(definition: &BindingVariableDefinition) -> &Identifier {
7305 match definition {
7306 BindingVariableDefinition::Graph(definition) => &definition.name,
7307 BindingVariableDefinition::BindingTable(definition) => &definition.name,
7308 BindingVariableDefinition::Value(definition) => &definition.name,
7309 }
7310}
7311
7312fn is_nested_query_clause(clause: &QueryClause) -> bool {
7313 matches!(clause, QueryClause::NestedQuery(_))
7314}
7315
7316fn result_clause_has_wildcard(result_clause: &ResultClause) -> bool {
7317 result_clause
7318 .items
7319 .iter()
7320 .any(|item| matches!(item.expr, Expr::Wildcard))
7321}
7322
7323fn query_clauses_have_non_unit_working_table(clauses: &[QueryClause]) -> bool {
7324 clauses.iter().any(|clause| {
7325 matches!(
7326 clause,
7327 QueryClause::NestedQuery(_)
7328 | QueryClause::Match(_)
7329 | QueryClause::OptionalMatchBlock(_)
7330 | QueryClause::Let(_)
7331 | QueryClause::For(_)
7332 | QueryClause::Call(_)
7333 )
7334 })
7335}
7336
7337fn validate_value_query_expression(query: &QueryStatement, offset: usize) -> Result<()> {
7338 let body = &query.body;
7339 if body.result_clause.items.len() != 1 {
7340 return Err(Error::Message {
7341 offset,
7342 message: "value query expression must return exactly one item".to_owned(),
7343 });
7344 }
7345
7346 if matches!(body.limit, Some(UnsignedIntegerSpecification::Literal(1))) {
7347 return Ok(());
7348 }
7349
7350 if !body.group_by.is_empty() || body.empty_grouping_set {
7351 return Err(Error::Message {
7352 offset,
7353 message: "value query expression without LIMIT 1 cannot contain GROUP BY".to_owned(),
7354 });
7355 }
7356
7357 if expr_contains_aggregate_function(&body.result_clause.items[0].expr) {
7358 return Ok(());
7359 }
7360
7361 Err(Error::Message {
7362 offset,
7363 message: "value query expression requires LIMIT 1 or an aggregate result".to_owned(),
7364 })
7365}
7366
7367fn expr_contains_aggregate_function(expr: &Expr) -> bool {
7368 match expr {
7369 Expr::Function { name, args, .. } => {
7370 is_aggregate_function_name(&name.value)
7371 || args.iter().any(expr_contains_aggregate_function)
7372 }
7373 Expr::Property { base, .. } => expr_contains_aggregate_function(base),
7374 Expr::Unary { expr, .. }
7375 | Expr::Cast { expr, .. }
7376 | Expr::DurationFunction { value: expr }
7377 | Expr::AbsoluteValue { expr }
7378 | Expr::Elements { path: expr } => expr_contains_aggregate_function(expr),
7379 Expr::Binary { left, right, .. }
7380 | Expr::DurationBetween { left, right }
7381 | Expr::NullIf { left, right } => {
7382 expr_contains_aggregate_function(left) || expr_contains_aggregate_function(right)
7383 }
7384 Expr::SubstringByLength { value, length, .. } => {
7385 expr_contains_aggregate_function(value) || expr_contains_aggregate_function(length)
7386 }
7387 Expr::Trim {
7388 trim_character,
7389 value,
7390 ..
7391 } => {
7392 trim_character
7393 .as_deref()
7394 .is_some_and(expr_contains_aggregate_function)
7395 || expr_contains_aggregate_function(value)
7396 }
7397 Expr::MultiTrim {
7398 value,
7399 trim_characters,
7400 ..
7401 } => {
7402 expr_contains_aggregate_function(value)
7403 || trim_characters
7404 .as_deref()
7405 .is_some_and(expr_contains_aggregate_function)
7406 }
7407 Expr::TrimList { value, count } => {
7408 expr_contains_aggregate_function(value) || expr_contains_aggregate_function(count)
7409 }
7410 Expr::StringLength { value, .. }
7411 | Expr::Fold { value, .. }
7412 | Expr::Normalize { value, .. } => expr_contains_aggregate_function(value),
7413 Expr::DateTimeFunction { value, .. } => value
7414 .as_deref()
7415 .is_some_and(expr_contains_aggregate_function),
7416 Expr::NumericFunction { args, .. }
7417 | Expr::Coalesce(args)
7418 | Expr::List(args)
7419 | Expr::TypedList { values: args, .. }
7420 | Expr::Path(args) => args.iter().any(expr_contains_aggregate_function),
7421 Expr::Let { items, value } => {
7422 items
7423 .iter()
7424 .any(|item| expr_contains_aggregate_function(&item.value))
7425 || expr_contains_aggregate_function(value)
7426 }
7427 Expr::IsTyped { expr, .. }
7428 | Expr::IsNull { expr, .. }
7429 | Expr::IsUnknown { expr, .. }
7430 | Expr::IsTruth { expr, .. }
7431 | Expr::IsNormalized { expr, .. } => expr_contains_aggregate_function(expr),
7432 Expr::Case {
7433 operand,
7434 when_clauses,
7435 else_expr,
7436 } => {
7437 operand
7438 .as_deref()
7439 .is_some_and(expr_contains_aggregate_function)
7440 || when_clauses.iter().any(|clause| {
7441 expr_contains_aggregate_function(&clause.condition)
7442 || clause
7443 .additional_operands
7444 .iter()
7445 .any(expr_contains_aggregate_function)
7446 || expr_contains_aggregate_function(&clause.result)
7447 })
7448 || else_expr
7449 .as_deref()
7450 .is_some_and(expr_contains_aggregate_function)
7451 }
7452 Expr::Record { fields, .. } | Expr::Map(fields) => fields
7453 .entries
7454 .iter()
7455 .any(|(_, value)| expr_contains_aggregate_function(value)),
7456 Expr::Identifier(_)
7457 | Expr::GraphReference { .. }
7458 | Expr::BindingTableReference { .. }
7459 | Expr::Parameter(_)
7460 | Expr::Literal(_)
7461 | Expr::CurrentDate
7462 | Expr::CurrentTime { .. }
7463 | Expr::CurrentTimestamp { .. }
7464 | Expr::CurrentUser
7465 | Expr::LocalTime { .. }
7466 | Expr::LocalTimestamp { .. }
7467 | Expr::ValueQuery { .. }
7468 | Expr::PropertyExists { .. }
7469 | Expr::ElementId { .. }
7470 | Expr::Exists { .. }
7471 | Expr::ExistsQuery { .. }
7472 | Expr::ExistsMatch { .. }
7473 | Expr::Same { .. }
7474 | Expr::AllDifferent { .. }
7475 | Expr::SourceDestination { .. }
7476 | Expr::IsDirected { .. }
7477 | Expr::IsLabeled { .. }
7478 | Expr::Wildcard => false,
7479 }
7480}
7481
7482fn expr_references_identifier(expr: &Expr, identifier: &Identifier) -> bool {
7483 match expr {
7484 Expr::Identifier(candidate) => candidate.value.eq_ignore_ascii_case(&identifier.value),
7485 Expr::Property { base, .. } => expr_references_identifier(base, identifier),
7486 Expr::GraphReference { graph, .. } => {
7487 graph_expression_references_identifier(graph, identifier)
7488 }
7489 Expr::BindingTableReference { table, .. } => {
7490 binding_table_expression_references_identifier(table, identifier)
7491 }
7492 Expr::Unary { expr, .. }
7493 | Expr::Cast { expr, .. }
7494 | Expr::DurationFunction { value: expr }
7495 | Expr::AbsoluteValue { expr }
7496 | Expr::Elements { path: expr }
7497 | Expr::IsTyped { expr, .. }
7498 | Expr::IsNull { expr, .. }
7499 | Expr::IsUnknown { expr, .. }
7500 | Expr::IsTruth { expr, .. }
7501 | Expr::IsNormalized { expr, .. } => expr_references_identifier(expr, identifier),
7502 Expr::Binary { left, right, .. }
7503 | Expr::DurationBetween { left, right }
7504 | Expr::NullIf { left, right } => {
7505 expr_references_identifier(left, identifier)
7506 || expr_references_identifier(right, identifier)
7507 }
7508 Expr::Function { args, .. }
7509 | Expr::NumericFunction { args, .. }
7510 | Expr::Coalesce(args)
7511 | Expr::List(args)
7512 | Expr::TypedList { values: args, .. }
7513 | Expr::Path(args) => args
7514 .iter()
7515 .any(|arg| expr_references_identifier(arg, identifier)),
7516 Expr::SubstringByLength { value, length, .. } => {
7517 expr_references_identifier(value, identifier)
7518 || expr_references_identifier(length, identifier)
7519 }
7520 Expr::Trim {
7521 trim_character,
7522 value,
7523 ..
7524 } => {
7525 trim_character
7526 .as_deref()
7527 .is_some_and(|expr| expr_references_identifier(expr, identifier))
7528 || expr_references_identifier(value, identifier)
7529 }
7530 Expr::MultiTrim {
7531 value,
7532 trim_characters,
7533 ..
7534 } => {
7535 expr_references_identifier(value, identifier)
7536 || trim_characters
7537 .as_deref()
7538 .is_some_and(|expr| expr_references_identifier(expr, identifier))
7539 }
7540 Expr::TrimList { value, count } => {
7541 expr_references_identifier(value, identifier)
7542 || expr_references_identifier(count, identifier)
7543 }
7544 Expr::StringLength { value, .. }
7545 | Expr::Fold { value, .. }
7546 | Expr::Normalize { value, .. } => expr_references_identifier(value, identifier),
7547 Expr::DateTimeFunction { value, .. } => value
7548 .as_deref()
7549 .is_some_and(|expr| expr_references_identifier(expr, identifier)),
7550 Expr::Let { items, value } => {
7551 items
7552 .iter()
7553 .any(|item| expr_references_identifier(&item.value, identifier))
7554 || expr_references_identifier(value, identifier)
7555 }
7556 Expr::PropertyExists { variable, .. }
7557 | Expr::ElementId { variable }
7558 | Expr::IsDirected { variable, .. } => {
7559 variable.value.eq_ignore_ascii_case(&identifier.value)
7560 }
7561 Expr::Same { variables } | Expr::AllDifferent { variables } => variables
7562 .iter()
7563 .any(|variable| variable.value.eq_ignore_ascii_case(&identifier.value)),
7564 Expr::SourceDestination { node, edge, .. } => {
7565 node.value.eq_ignore_ascii_case(&identifier.value)
7566 || edge.value.eq_ignore_ascii_case(&identifier.value)
7567 }
7568 Expr::IsLabeled { variable, .. } => variable.value.eq_ignore_ascii_case(&identifier.value),
7569 Expr::Case {
7570 operand,
7571 when_clauses,
7572 else_expr,
7573 } => {
7574 operand
7575 .as_deref()
7576 .is_some_and(|expr| expr_references_identifier(expr, identifier))
7577 || when_clauses.iter().any(|clause| {
7578 expr_references_identifier(&clause.condition, identifier)
7579 || clause
7580 .additional_operands
7581 .iter()
7582 .any(|expr| expr_references_identifier(expr, identifier))
7583 || expr_references_identifier(&clause.result, identifier)
7584 })
7585 || else_expr
7586 .as_deref()
7587 .is_some_and(|expr| expr_references_identifier(expr, identifier))
7588 }
7589 Expr::Record { fields, .. } | Expr::Map(fields) => {
7590 map_literal_references_identifier(fields, identifier)
7591 }
7592 Expr::Parameter(_)
7593 | Expr::Literal(_)
7594 | Expr::CurrentDate
7595 | Expr::CurrentTime { .. }
7596 | Expr::CurrentTimestamp { .. }
7597 | Expr::CurrentUser
7598 | Expr::LocalTime { .. }
7599 | Expr::LocalTimestamp { .. }
7600 | Expr::ValueQuery { .. }
7601 | Expr::Exists { .. }
7602 | Expr::ExistsQuery { .. }
7603 | Expr::ExistsMatch { .. }
7604 | Expr::Wildcard => false,
7605 }
7606}
7607
7608fn graph_expression_references_identifier(
7609 graph: &GraphExpression,
7610 identifier: &Identifier,
7611) -> bool {
7612 match graph {
7613 GraphExpression::Variable(expr) => expr_references_identifier(expr, identifier),
7614 GraphExpression::Name(_)
7615 | GraphExpression::Parameter(_)
7616 | GraphExpression::CurrentGraph
7617 | GraphExpression::CurrentPropertyGraph
7618 | GraphExpression::HomeGraph
7619 | GraphExpression::HomePropertyGraph => false,
7620 }
7621}
7622
7623fn binding_table_expression_references_identifier(
7624 table: &BindingTableExpression,
7625 identifier: &Identifier,
7626) -> bool {
7627 match table {
7628 BindingTableExpression::Variable(expr) => expr_references_identifier(expr, identifier),
7629 BindingTableExpression::NestedQuery(_)
7630 | BindingTableExpression::Name(_)
7631 | BindingTableExpression::Parameter(_) => false,
7632 }
7633}
7634
7635fn map_literal_references_identifier(map: &MapLiteral, identifier: &Identifier) -> bool {
7636 map.entries
7637 .iter()
7638 .any(|(_, value)| expr_references_identifier(value, identifier))
7639}
7640
7641fn expr_contains_procedure_body(expr: &Expr) -> bool {
7642 match expr {
7643 Expr::ValueQuery { query } | Expr::ExistsQuery { query } => {
7644 query_statement_contains_procedure_body(query)
7645 }
7646 Expr::GraphReference { graph, .. } => graph_expression_contains_procedure_body(graph),
7647 Expr::BindingTableReference { table, .. } => {
7648 binding_table_expression_contains_procedure_body(table)
7649 }
7650 Expr::Property { base, .. } => expr_contains_procedure_body(base),
7651 Expr::Function { args, .. }
7652 | Expr::NumericFunction { args, .. }
7653 | Expr::Coalesce(args)
7654 | Expr::List(args)
7655 | Expr::TypedList { values: args, .. }
7656 | Expr::Path(args) => args.iter().any(expr_contains_procedure_body),
7657 Expr::Unary { expr, .. }
7658 | Expr::Cast { expr, .. }
7659 | Expr::DurationFunction { value: expr }
7660 | Expr::AbsoluteValue { expr }
7661 | Expr::Elements { path: expr }
7662 | Expr::IsTyped { expr, .. }
7663 | Expr::IsNull { expr, .. }
7664 | Expr::IsUnknown { expr, .. }
7665 | Expr::IsTruth { expr, .. }
7666 | Expr::IsNormalized { expr, .. } => expr_contains_procedure_body(expr),
7667 Expr::Binary { left, right, .. }
7668 | Expr::DurationBetween { left, right }
7669 | Expr::NullIf { left, right } => {
7670 expr_contains_procedure_body(left) || expr_contains_procedure_body(right)
7671 }
7672 Expr::SubstringByLength { value, length, .. } => {
7673 expr_contains_procedure_body(value) || expr_contains_procedure_body(length)
7674 }
7675 Expr::Trim {
7676 trim_character,
7677 value,
7678 ..
7679 } => {
7680 trim_character
7681 .as_deref()
7682 .is_some_and(expr_contains_procedure_body)
7683 || expr_contains_procedure_body(value)
7684 }
7685 Expr::MultiTrim {
7686 value,
7687 trim_characters,
7688 ..
7689 } => {
7690 expr_contains_procedure_body(value)
7691 || trim_characters
7692 .as_deref()
7693 .is_some_and(expr_contains_procedure_body)
7694 }
7695 Expr::TrimList { value, count } => {
7696 expr_contains_procedure_body(value) || expr_contains_procedure_body(count)
7697 }
7698 Expr::StringLength { value, .. }
7699 | Expr::Fold { value, .. }
7700 | Expr::Normalize { value, .. } => expr_contains_procedure_body(value),
7701 Expr::DateTimeFunction { value, .. } => {
7702 value.as_deref().is_some_and(expr_contains_procedure_body)
7703 }
7704 Expr::Let { items, value } => {
7705 items
7706 .iter()
7707 .any(|item| expr_contains_procedure_body(&item.value))
7708 || expr_contains_procedure_body(value)
7709 }
7710 Expr::Case {
7711 operand,
7712 when_clauses,
7713 else_expr,
7714 } => {
7715 operand.as_deref().is_some_and(expr_contains_procedure_body)
7716 || when_clauses.iter().any(|clause| {
7717 expr_contains_procedure_body(&clause.condition)
7718 || clause
7719 .additional_operands
7720 .iter()
7721 .any(expr_contains_procedure_body)
7722 || expr_contains_procedure_body(&clause.result)
7723 })
7724 || else_expr
7725 .as_deref()
7726 .is_some_and(expr_contains_procedure_body)
7727 }
7728 Expr::Record { fields, .. } | Expr::Map(fields) => {
7729 map_literal_contains_procedure_body(fields)
7730 }
7731 Expr::Exists { patterns } => patterns.iter().any(path_pattern_contains_procedure_body),
7732 Expr::ExistsMatch { matches } => matches.iter().any(match_clause_contains_procedure_body),
7733 Expr::Identifier(_)
7734 | Expr::Parameter(_)
7735 | Expr::Literal(_)
7736 | Expr::CurrentDate
7737 | Expr::CurrentTime { .. }
7738 | Expr::CurrentTimestamp { .. }
7739 | Expr::CurrentUser
7740 | Expr::LocalTime { .. }
7741 | Expr::LocalTimestamp { .. }
7742 | Expr::PropertyExists { .. }
7743 | Expr::ElementId { .. }
7744 | Expr::Same { .. }
7745 | Expr::AllDifferent { .. }
7746 | Expr::SourceDestination { .. }
7747 | Expr::IsDirected { .. }
7748 | Expr::IsLabeled { .. }
7749 | Expr::Wildcard => false,
7750 }
7751}
7752
7753fn query_statement_contains_procedure_body(query: &QueryStatement) -> bool {
7754 query
7755 .use_graph
7756 .as_ref()
7757 .is_some_and(graph_expression_contains_procedure_body)
7758 || query_body_contains_procedure_body(&query.body)
7759 || query
7760 .set_operations
7761 .iter()
7762 .any(|operation| query_body_contains_procedure_body(&operation.body))
7763}
7764
7765fn query_body_contains_procedure_body(body: &QueryBody) -> bool {
7766 body.clauses
7767 .iter()
7768 .any(query_clause_contains_procedure_body)
7769 || body
7770 .result_clause
7771 .items
7772 .iter()
7773 .any(|item| expr_contains_procedure_body(&item.expr))
7774 || body.select_from.iter().any(|item| {
7775 graph_expression_contains_procedure_body(&item.graph)
7776 || match_clause_contains_procedure_body(&item.match_clause)
7777 })
7778 || body.select_query.as_ref().is_some_and(|select| {
7779 select
7780 .graph
7781 .as_ref()
7782 .is_some_and(graph_expression_contains_procedure_body)
7783 || query_statement_contains_procedure_body(&select.query)
7784 })
7785 || body
7786 .select_where
7787 .as_ref()
7788 .is_some_and(expr_contains_procedure_body)
7789 || body.group_by.iter().any(expr_contains_procedure_body)
7790 || body
7791 .having
7792 .as_ref()
7793 .is_some_and(expr_contains_procedure_body)
7794 || body
7795 .order_by
7796 .iter()
7797 .any(|item| expr_contains_procedure_body(&item.expr))
7798}
7799
7800fn query_clause_contains_procedure_body(clause: &QueryClause) -> bool {
7801 match clause {
7802 QueryClause::UseGraph(graph) => graph_expression_contains_procedure_body(graph),
7803 QueryClause::NestedQuery(query) => query_statement_contains_procedure_body(query),
7804 QueryClause::Match(match_clause) => match_clause_contains_procedure_body(match_clause),
7805 QueryClause::OptionalMatchBlock(matches) => {
7806 matches.iter().any(match_clause_contains_procedure_body)
7807 }
7808 QueryClause::Filter(filter) => expr_contains_procedure_body(&filter.predicate),
7809 QueryClause::Let(let_clause) => let_clause
7810 .items
7811 .iter()
7812 .any(|item| expr_contains_procedure_body(&item.value)),
7813 QueryClause::For(for_clause) => expr_contains_procedure_body(&for_clause.source),
7814 QueryClause::Call(call) => call_clause_contains_procedure_body(call),
7815 QueryClause::Insert(insert) => insert
7816 .patterns
7817 .iter()
7818 .any(path_pattern_contains_procedure_body),
7819 QueryClause::Delete(delete) => delete.items.iter().any(expr_contains_procedure_body),
7820 QueryClause::Set(set) => set.items.iter().any(set_item_contains_procedure_body),
7821 QueryClause::Remove(remove) => remove.items.iter().any(remove_item_contains_procedure_body),
7822 QueryClause::OrderByPage(page) => page
7823 .order_by
7824 .iter()
7825 .any(|item| expr_contains_procedure_body(&item.expr)),
7826 }
7827}
7828
7829fn call_clause_contains_procedure_body(call: &CallClause) -> bool {
7830 match &call.call {
7831 ProcedureCall::Inline(_) => true,
7832 ProcedureCall::Named { args, .. } => args.iter().any(expr_contains_procedure_body),
7833 }
7834}
7835
7836fn graph_expression_contains_procedure_body(graph: &GraphExpression) -> bool {
7837 match graph {
7838 GraphExpression::Variable(expr) => expr_contains_procedure_body(expr),
7839 GraphExpression::Name(_)
7840 | GraphExpression::Parameter(_)
7841 | GraphExpression::CurrentGraph
7842 | GraphExpression::CurrentPropertyGraph
7843 | GraphExpression::HomeGraph
7844 | GraphExpression::HomePropertyGraph => false,
7845 }
7846}
7847
7848fn binding_table_expression_contains_procedure_body(table: &BindingTableExpression) -> bool {
7849 match table {
7850 BindingTableExpression::NestedQuery(query) => {
7851 query_statement_contains_procedure_body(query)
7852 }
7853 BindingTableExpression::Variable(expr) => expr_contains_procedure_body(expr),
7854 BindingTableExpression::Name(_) | BindingTableExpression::Parameter(_) => false,
7855 }
7856}
7857
7858fn match_clause_contains_procedure_body(match_clause: &MatchClause) -> bool {
7859 match_clause
7860 .patterns
7861 .iter()
7862 .any(path_pattern_contains_procedure_body)
7863 || match_clause
7864 .where_clause
7865 .as_ref()
7866 .is_some_and(expr_contains_procedure_body)
7867}
7868
7869fn path_pattern_contains_procedure_body(pattern: &PathPattern) -> bool {
7870 node_pattern_contains_procedure_body(&pattern.start)
7871 || pattern.chains.iter().any(|chain| {
7872 relationship_pattern_contains_procedure_body(&chain.relationship)
7873 || node_pattern_contains_procedure_body(&chain.node)
7874 })
7875 || pattern
7876 .factors
7877 .iter()
7878 .any(path_pattern_factor_contains_procedure_body)
7879 || pattern.alternatives.iter().any(|alternative| {
7880 node_pattern_contains_procedure_body(&alternative.start)
7881 || alternative.chains.iter().any(|chain| {
7882 relationship_pattern_contains_procedure_body(&chain.relationship)
7883 || node_pattern_contains_procedure_body(&chain.node)
7884 })
7885 || alternative
7886 .factors
7887 .iter()
7888 .any(path_pattern_factor_contains_procedure_body)
7889 })
7890 || pattern.parenthesized.as_ref().is_some_and(|parenthesized| {
7891 path_pattern_contains_procedure_body(&parenthesized.pattern)
7892 || parenthesized
7893 .where_clause
7894 .as_ref()
7895 .is_some_and(expr_contains_procedure_body)
7896 })
7897}
7898
7899fn path_pattern_factor_contains_procedure_body(factor: &PathPatternFactor) -> bool {
7900 match factor {
7901 PathPatternFactor::Node(node) => node_pattern_contains_procedure_body(node),
7902 PathPatternFactor::Relationship(relationship) => {
7903 relationship_pattern_contains_procedure_body(relationship)
7904 }
7905 PathPatternFactor::Parenthesized(parenthesized) => {
7906 path_pattern_contains_procedure_body(&parenthesized.pattern)
7907 || parenthesized
7908 .where_clause
7909 .as_ref()
7910 .is_some_and(expr_contains_procedure_body)
7911 }
7912 PathPatternFactor::Alternation { alternatives, .. } => alternatives
7913 .iter()
7914 .flatten()
7915 .any(path_pattern_factor_contains_procedure_body),
7916 }
7917}
7918
7919fn node_pattern_contains_procedure_body(node: &NodePattern) -> bool {
7920 node.properties
7921 .as_ref()
7922 .is_some_and(map_literal_contains_procedure_body)
7923 || node
7924 .where_clause
7925 .as_ref()
7926 .is_some_and(expr_contains_procedure_body)
7927}
7928
7929fn relationship_pattern_contains_procedure_body(relationship: &RelationshipPattern) -> bool {
7930 relationship
7931 .properties
7932 .as_ref()
7933 .is_some_and(map_literal_contains_procedure_body)
7934 || relationship
7935 .where_clause
7936 .as_ref()
7937 .is_some_and(expr_contains_procedure_body)
7938}
7939
7940fn set_item_contains_procedure_body(item: &SetItem) -> bool {
7941 match item {
7942 SetItem::Property { target, value } => {
7943 expr_contains_procedure_body(target) || expr_contains_procedure_body(value)
7944 }
7945 SetItem::AllProperties { properties, .. } => {
7946 map_literal_contains_procedure_body(properties)
7947 }
7948 SetItem::Label { .. } => false,
7949 }
7950}
7951
7952fn remove_item_contains_procedure_body(item: &RemoveItem) -> bool {
7953 match item {
7954 RemoveItem::Property(expr) => expr_contains_procedure_body(expr),
7955 RemoveItem::Label { .. } => false,
7956 }
7957}
7958
7959fn map_literal_contains_procedure_body(map: &MapLiteral) -> bool {
7960 map.entries
7961 .iter()
7962 .any(|(_, value)| expr_contains_procedure_body(value))
7963}
7964
7965fn is_aggregate_function_name(name: &str) -> bool {
7966 matches!(
7967 name.to_ascii_uppercase().as_str(),
7968 "COUNT"
7969 | "AVG"
7970 | "MAX"
7971 | "MIN"
7972 | "SUM"
7973 | "COLLECT_LIST"
7974 | "STDDEV_SAMP"
7975 | "STDDEV_POP"
7976 | "PERCENTILE_CONT"
7977 | "PERCENTILE_DISC"
7978 )
7979}
7980
7981fn is_general_set_function_name(name: &str) -> bool {
7982 matches!(
7983 name.to_ascii_uppercase().as_str(),
7984 "AVG" | "COUNT" | "MAX" | "MIN" | "SUM" | "COLLECT_LIST" | "STDDEV_SAMP" | "STDDEV_POP"
7985 )
7986}
7987
7988fn normalize_function_quantifier(
7989 name: &Identifier,
7990 quantifier: Option<SetQuantifier>,
7991 args: &[Expr],
7992) -> Option<SetQuantifier> {
7993 if quantifier.is_none()
7994 && is_general_set_function_name(&name.value)
7995 && !matches!(args, [Expr::Wildcard])
7996 {
7997 Some(SetQuantifier::All)
7998 } else {
7999 quantifier
8000 }
8001}
8002
8003fn reject_non_standard_value_function(name: &Identifier, offset: usize) -> Result<()> {
8004 if !is_aggregate_function_name(&name.value)
8005 || matches!(
8006 name.value.to_ascii_uppercase().as_str(),
8007 "OVERLAY" | "POSITION" | "SUBSTRING"
8008 )
8009 {
8010 return Err(Error::Message {
8011 offset,
8012 message: format!(
8013 "function {} is not a standard GQL value function",
8014 name.value
8015 ),
8016 });
8017 }
8018 Ok(())
8019}
8020
8021fn is_schema_reference_follow(kind: TokenKind) -> bool {
8022 matches!(
8023 kind,
8024 TokenKind::Use
8025 | TokenKind::Optional
8026 | TokenKind::Match
8027 | TokenKind::Filter
8028 | TokenKind::Let
8029 | TokenKind::For
8030 | TokenKind::Call
8031 | TokenKind::Insert
8032 | TokenKind::Delete
8033 | TokenKind::Detach
8034 | TokenKind::Nodetach
8035 | TokenKind::Set
8036 | TokenKind::Remove
8037 | TokenKind::Order
8038 | TokenKind::Offset
8039 | TokenKind::Skip
8040 | TokenKind::Limit
8041 | TokenKind::Return
8042 | TokenKind::Select
8043 | TokenKind::Finish
8044 | TokenKind::Semicolon
8045 | TokenKind::Eof
8046 | TokenKind::RBrace
8047 )
8048}
8049
8050fn collect_label_names(expr: &LabelExpression, labels: &mut Vec<Identifier>) {
8051 match expr {
8052 LabelExpression::Label(label) => labels.push(label.clone()),
8053 LabelExpression::Wildcard => {}
8054 LabelExpression::And(left, right) | LabelExpression::Or(left, right) => {
8055 collect_label_names(left, labels);
8056 collect_label_names(right, labels);
8057 }
8058 LabelExpression::Not(inner) | LabelExpression::Parenthesized(inner) => {
8059 collect_label_names(inner, labels);
8060 }
8061 }
8062}