Function trim_function_call

graphlite/src/ast/parser.rs:2192–2283

Parse special TRIM function with ISO GQL FROM clause syntax TRIM "(" [("LEADING" | "TRAILING" | "BOTH") [ ] "FROM"] ")"

(tokens: &[Token])

/// Parse special TRIM function with ISO GQL FROM clause syntax
/// TRIM "(" [("LEADING" | "TRAILING" | "BOTH") [<string-expr>] "FROM"] <string-expr> ")"
fn trim_function_call(tokens: &[Token]) -> IResult<&[Token], FunctionCall> {
    // Check if this is a TRIM function call
    if !matches!(tokens.first(), Some(Token::Identifier(name)) if name.eq_ignore_ascii_case("TRIM"))
    {
        return Err(nom::Err::Error(nom::error::Error::new(
            tokens,
            nom::error::ErrorKind::Tag,
        )));
    }

    let (tokens, _name) = identifier(tokens)?; // Consume TRIM
    let (tokens, _) = expect_token(Token::LeftParen)(tokens)?; // Consume (

    let mut arguments = Vec::new();
    let mut remaining = tokens;

    // Check for trim mode keywords: LEADING, TRAILING, BOTH
    let trim_mode = match remaining.first() {
        Some(Token::Leading) => {
            remaining = &remaining[1..];
            Some("LEADING")
        }
        Some(Token::Trailing) => {
            remaining = &remaining[1..];
            Some("TRAILING")
        }
        Some(Token::Both) => {
            remaining = &remaining[1..];
            Some("BOTH")
        }
        _ => None,
    };

    // If we have a trim mode, check for optional trim character and FROM keyword
    if let Some(mode) = trim_mode {
        // Add mode as first argument
        arguments.push(Expression::Literal(Literal::String(mode.to_string())));

        // Check if next token is FROM (no trim character specified) or an expression (trim character)
        if matches!(remaining.first(), Some(Token::From)) {
            // TRIM(MODE FROM string) - no trim character, use default whitespace
            remaining = &remaining[1..]; // consume FROM
            arguments.push(Expression::Literal(Literal::String(" ".to_string())));
        // default trim char
        } else {
            // TRIM(MODE char_expr FROM string) - parse trim character
            let (new_remaining, trim_char_expr) = expression(remaining)?;
            remaining = new_remaining;
            arguments.push(trim_char_expr); // trim character

            // Expect FROM keyword
            let (new_remaining, _) = expect_token(Token::From)(remaining)?;
            remaining = new_remaining;
        }

        // Parse the string expression to trim
        let (new_remaining, string_expr) = expression(remaining)?;
        remaining = new_remaining;