Function primary_expression

graphlite/src/ast/parser.rs:2068–2104

Parse primary expression: (expr) | function_call | property_access | value | case_expr

(tokens: &[Token])

/// Parse primary expression: (expr) | function_call | property_access | value | case_expr
fn primary_expression(tokens: &[Token]) -> IResult<&[Token], Expression> {
    alt((
        // NOT EXISTS subquery must be checked before EXISTS to avoid conflicts
        map(not_exists_subquery, Expression::NotExistsSubquery),
        // EXISTS subquery must be checked before general parenthesized expressions
        map(exists_subquery, Expression::ExistsSubquery),
        // Try pattern expression first (for WHERE clause patterns)
        map(pattern_expression, Expression::Pattern),
        // Try subquery first, then fall back to parenthesized expression
        map(
            alt((
                map(subquery_expression, Expression::Subquery),
                map(
                    tuple((
                        expect_token(Token::LeftParen),
                        expression,
                        expect_token(Token::RightParen),
                    )),
                    |(_, expr, _)| expr,
                ),
            )),
            |expr| expr,
        ),
        map(case_expression, Expression::Case),
        map(cast_expression, Expression::Cast),
        map(path_constructor, Expression::PathConstructor),
        map(array_expression, Expression::Literal),
        map(trim_function_call, Expression::FunctionCall), // Special TRIM FROM syntax
        map(function_call, Expression::FunctionCall),
        map(property_access, Expression::PropertyAccess),
        map(property_access_continued, Expression::PropertyAccess),
        map(property_access_token, Expression::PropertyAccess),
        map(parameter, Expression::Parameter),
        map(variable, Expression::Variable),
        map(literal, Expression::Literal),
    ))(tokens)
}

/// Parse expression list: expr1, expr2, expr3, ...
fn expression_list(tokens: &[Token]) -> IResult<&[Token], Vec<Expression>> {