Skip to main content

gql_parser/
parser.rs

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
40// Test threads use a 2MB stack. Each nested construct keeps the descent
41// frames live, and dropping the partial tree needs a similar amount again.
42const 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            // A nested read query is a query primary: its result flows outward.
724            // Only a modifying pipeline implicitly finishes without a result.
725            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            // The positive magnitude does not fit in i64; the negation does.
5021            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}