Method parse_like

src/sql-parser/src/parser.rs:1643–1671

Parses `LIKE [ ESCAPE ]`, assuming the `LIKE` keyword was already consumed

(
        &mut self,
        expr: Expr<Raw>,
        case_insensitive: bool,
        negated: bool,
    )

    /// Parses `LIKE <pattern> [ ESCAPE <char> ]`, assuming the `LIKE` keyword was already consumed
    fn parse_like(
        &mut self,
        expr: Expr<Raw>,
        case_insensitive: bool,
        negated: bool,
    ) -> Result<Expr<Raw>, ParserError> {
        if let Some(kw) = self.parse_one_of_keywords(ANY_ALL_KEYWORDS) {
            let op = match (case_insensitive, negated) {
                (false, false) => "~~",
                (false, true) => "!~~",
                (true, false) => "~~*",
                (true, true) => "!~~*",
            };
            return self.parse_any_all(expr, Op::bare(op), kw);
        }
        let pattern = self.parse_subexpr(Precedence::Like)?;
        let escape = if self.parse_keyword(ESCAPE) {
            Some(Box::new(self.parse_subexpr(Precedence::Like)?))
        } else {
            None
        };
        Ok(Expr::Like {
            expr: Box::new(expr),
            pattern: Box::new(pattern),
            escape,
            case_insensitive,
            negated,
        })
    }

    /// Parse a postgresql casting style which is in the form of `expr::datatype`
    fn parse_pg_cast(&mut self, expr: Expr<Raw>) -> Result<Expr<Raw>, ParserError> {