sql: parenthesize a LIKE pattern whose right spine would steal ESCAPE

A `[I]LIKE` pattern parses at `Like` precedence and, when an `ESCAPE`
follows, sits immediately to the left of the `ESCAPE` keyword. Only
`[I]LIKE` consumes `ESCAPE`, so a `[I]LIKE` exposed on the pattern's *right*
spine steals the outer escape as its own: `x LIKE NOT (a LIKE b) ESCAPE c`,
printed bare as `x LIKE NOT a LIKE b ESCAPE c`, binds the escape onto the
inner `a LIKE b` instead of the outer `LIKE`.

The pattern's left edge was already guarded (so its left spine doesn't
re-associate out of the `LIKE`), but the escape-stealing hazard is on the
right spine and only exists when an escape is present. Add a right-edge
guard conditioned on `escape.is_some()`. The parser never builds a pattern
that is itself a trailing escapeless `[I]LIKE` under an outer escape (it
left-nests instead), so parser-produced ASTs are unaffected and the
datadriven suites are unchanged.

This drift collides under stable-string printing (both ASTs print to the
same text), so the round-trip fuzz oracle was strengthened to compare
reparsed ASTs structurally rather than by re-printed string.

Tests: adds `like_pattern_reparenthesized_after_nested_stripped` to
`sqlparser_common.rs`.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: def-

src/sql-parser/src/ast/defs/expr.rs

@@ -302,12 +302,18 @@ impl<T: AstInfo> AstDisplay for Expr<T> {
                     f.write_str("I");
                 }
                 f.write_str("LIKE ");
-                // The pattern and escape parse at `Like` precedence and sit to
-                // the right of the keyword, so an operand exposing a precedence at
-                // or below `Like` on its left spine (e.g. an `IN`/`LIKE`/`BETWEEN`
-                // at equal precedence) re-associates unless parenthesized —
-                // `a LIKE b IN (q)` parses as `(a LIKE b) IN (q)`.
-                write_binary_operand(f, pattern, left_edge(pattern) <= prec::LIKE);
+                // The pattern and escape parse at `Like` precedence and sit to the
+                // right of the keyword, so an operand exposing a precedence at or
+                // below `Like` on its left spine (e.g. an `IN`/`LIKE`/`BETWEEN` at
+                // equal precedence) re-associates unless parenthesized —
+                // `a LIKE b IN (q)` parses as `(a LIKE b) IN (q)`. When an `ESCAPE`
+                // follows, the pattern is *also* immediately left of `ESCAPE`: a
+                // `[I]LIKE` exposed on the pattern's right spine would steal the
+                // `ESCAPE` as its own (`a LIKE NOT b LIKE c ESCAPE d` parses the
+                // escape onto the inner `b LIKE c`), so guard the right edge too.
+                let pattern_parens = left_edge(pattern) <= prec::LIKE
+                    || (escape.is_some() && right_edge(pattern) <= prec::LIKE);
+                write_binary_operand(f, pattern, pattern_parens);
                 if let Some(escape) = escape {
                     f.write_str(" ESCAPE ");
                     write_binary_operand(f, escape, left_edge(escape) <= prec::LIKE);

src/sql-parser/tests/sqlparser_common.rs

@@ -940,3 +940,53 @@ fn is_distinct_from_rhs_reparenthesized_after_nested_stripped() {
         );
     }
 }
+
+#[mz_ore::test]
+fn like_pattern_reparenthesized_after_nested_stripped() {
+    use mz_sql_parser::ast::display::AstDisplay;
+    use mz_sql_parser::ast::visit_mut::{self, VisitMut};
+    use mz_sql_parser::ast::{AstInfo, Expr};
+
+    struct StripNested;
+    impl<'a, T: AstInfo> VisitMut<'a, T> for StripNested {
+        fn visit_expr_mut(&mut self, e: &'a mut Expr<T>) {
+            visit_mut::visit_expr_mut(self, e);
+            if let Expr::Nested(inner) = e {
+                *e = (**inner).clone();
+            }
+        }
+    }
+
+    // A `[I]LIKE` pattern parses at `Like` precedence. When an `ESCAPE` follows,
+    // the pattern is immediately left of the `ESCAPE` keyword, so a `[I]LIKE`
+    // exposed on the pattern's *right* spine steals the `ESCAPE` as its own:
+    // `x LIKE NOT (a LIKE b) ESCAPE c`, printed bare as
+    // `x LIKE NOT a LIKE b ESCAPE c`, binds the escape to the inner `a LIKE b`.
+    // The drift is structural and produces colliding stable strings, so it is
+    // checked structurally.
+    for sql in [
+        "SELECT x LIKE (NOT (a LIKE b)) ESCAPE c",
+        "SELECT x LIKE (a LIKE b) ESCAPE c",
+        "SELECT x ILIKE (a ILIKE b) ESCAPE c",
+        // Left-spine cases (covered with or without escape).
+        "SELECT x LIKE (a IN (SELECT b FROM t))",
+        // No escape: a right-spine LIKE is harmless, so this stays bare.
+        "SELECT x LIKE NOT (a LIKE b)",
+    ] {
+        let mut ast = mz_sql_parser::parser::parse_statements(sql)
+            .unwrap()
+            .remove(0)
+            .ast;
+        StripNested.visit_statement_mut(&mut ast);
+        let displayed = ast.to_ast_string_simple();
+        let mut reparsed = mz_sql_parser::parser::parse_statements(&displayed)
+            .unwrap()
+            .remove(0)
+            .ast;
+        StripNested.visit_statement_mut(&mut reparsed);
+        assert_eq!(
+            ast, reparsed,
+            "LIKE pattern display did not round-trip after Nested was stripped: {sql:?} -> {displayed:?}"
+        );
+    }
+}