Function function_call

graphlite/src/ast/parser.rs:2122–2188

Parse function call: name(args...) using ISO GQL compliant token-based parsing

(tokens: &[Token])

/// Parse function call: name(args...) using ISO GQL compliant token-based parsing
fn function_call(tokens: &[Token]) -> IResult<&[Token], FunctionCall> {
    // ISO GQL: <function-call> ::= <identifier> "(" [DISTINCT|ALL] [<expression> ("," <expression>)*] ")"

    // Parse function name (identifier)
    let (tokens, name) = identifier(tokens)?;
    let name = name.to_uppercase(); // Normalize function names to uppercase

    // Parse opening parenthesis
    let (tokens, _) = expect_token(Token::LeftParen)(tokens)?;

    // Parse optional DISTINCT/ALL qualifier for aggregate functions
    let (tokens, distinct_qualifier) = opt(distinct_qualifier)(tokens)?;
    let distinct = distinct_qualifier.unwrap_or(DistinctQualifier::None);

    // Parse arguments (expressions separated by commas)
    let mut arguments = Vec::new();
    let mut remaining = tokens;

    // Check if there are arguments (not immediate closing paren)
    if !matches!(remaining.first(), Some(Token::RightParen)) {
        // Special case for COUNT(*) and similar aggregate functions with *
        if matches!(remaining.first(), Some(Token::Star)) {
            // Create a wildcard variable expression for *
            arguments.push(Expression::Variable(Variable {
                name: "*".to_string(),
                location: Location::default(),
            }));
            remaining = &remaining[1..]; // consume the star
        } else {
            // Regular argument parsing loop
            loop {
                // Parse an expression as argument
                let (new_remaining, expr) = expression(remaining)?;
                arguments.push(expr);
                remaining = new_remaining;

                // Check for comma (more arguments) or closing paren (end)
                match remaining.first() {
                    Some(Token::Comma) => {
                        remaining = &remaining[1..]; // consume comma
                        continue;
                    }
                    Some(Token::RightParen) => break,
                    _ => {
                        return Err(nom::Err::Error(nom::error::Error::new(
                            remaining,
                            nom::error::ErrorKind::Tag,
                        )))
                    }
                }
            }
        }
    }

    // Parse closing parenthesis
    let (remaining, _) = expect_token(Token::RightParen)(remaining)?;

    Ok((