Function parse_expr

raphtory-cypher/src/parser/mod.rs:285–340

(pairs: Pairs<Rule>)

}

pub fn parse_expr(pairs: Pairs<Rule>) -> Result<Expr, ParseError> {
    PRATT_PARSER
        .map_primary(|primary| parse_primary(primary))
        .map_infix(|lhs, op, rhs| {
            let bin_op_type = match op.as_rule() {
                Rule::add => BinOpType::Add,
                Rule::subtract => BinOpType::Sub,
                Rule::multiply => BinOpType::Mul,
                Rule::divide => BinOpType::Div,
                Rule::pow => BinOpType::Pow,
                Rule::eq => BinOpType::Eq,
                Rule::modulo => BinOpType::Mod,
                Rule::lt => BinOpType::Lt,
                Rule::lte => BinOpType::Lte,
                Rule::gt => BinOpType::Gt,
                Rule::gte => BinOpType::Gte,
                Rule::ne => BinOpType::Neq,
                Rule::and => BinOpType::And,
                Rule::or => BinOpType::Or,
                Rule::xor => BinOpType::Xor,
                Rule::IN => BinOpType::In,
                Rule::contains => BinOpType::Contains,
                Rule::starts_with => BinOpType::StartsWith,
                Rule::ends_with => BinOpType::EndsWith,
                rule => return unsupported("parse_expr", &rule),
            };

            Ok(Expr::BinOp {
                op: bin_op_type,
                left: Box::new(lhs?),
                right: Box::new(rhs?),
            })
        })
        .map_prefix(|op, expr| match op.as_rule() {
            Rule::not => Ok(Expr::UnaryOp {
                op: UnaryOpType::Not,
                expr: Box::new(expr?),
            }),
            Rule::minus => Ok(Expr::UnaryOp {
                op: UnaryOpType::Neg,
                expr: Box::new(expr?),
            }),
            rule => unsupported("parse_expr", &rule),
        })
        .map_postfix(|expr, op| match op.as_rule() {
            Rule::is_null => {
                if let Some(Rule::NOT) = op.into_inner().next().map(|op| op.as_rule()) {
                    Ok(Expr::is_not_null(expr?))
                } else {
                    Ok(Expr::is_null(expr?))
                }
            }
            rule => unsupported("parse_expr", &rule),
        })
        .parse(pairs)
}

pub fn parse_primary(pair: Pair<Rule>) -> Result<Expr, ParseError> {