fix: Parse ESCAPE clause parameters

Added a escape field to the AST expression struct. This field now stores the node for the ESCAPE clause and gets walked. The SQLite converter fills in the field. Both the default and core analyzer got a new case for recording the ESCAPE parameters.

Author: manuelschoene

internal/compiler/find_params.go

@@ -52,11 +52,27 @@ func (l *limitOffset) Pos() int {
 	return 0
 }
 
+// likeEscape is the parent of a parameter in the ESCAPE clause of a pattern
+// match. It is a string whatever the matched column is, so it must not be
+// typed after the operands as the rest of the A_Expr is.
+type likeEscape struct {
+}
+
+func (l *likeEscape) Pos() int {
+	return 0
+}
+
 func (p paramSearch) Visit(node ast.Node) astutils.Visitor {
 	switch n := node.(type) {
 
 	case *ast.A_Expr:
 		p.parent = node
+		if ref, ok := n.Escape.(*ast.ParamRef); ok {
+			if _, found := p.seen[ref.Location]; !found {
+				*p.refs = append(*p.refs, paramRef{parent: &likeEscape{}, ref: ref, rv: p.rangeVar})
+				p.seen[ref.Location] = struct{}{}
+			}
+		}
 
 	case *ast.BetweenExpr:
 		p.parent = node

internal/compiler/resolve.go

@@ -141,6 +141,19 @@ func (comp *Compiler) resolveCatalogRefs(qc *QueryCatalog, rvs []*ast.RangeVar,
 				},
 			})
 
+		case *likeEscape:
+			defaultP := named.NewInferredParam("escape", true)
+			p, isNamed := params.FetchMerge(ref.ref.Number, defaultP)
+			a = append(a, Parameter{
+				Number: ref.ref.Number,
+				Column: &Column{
+					Name:         p.Name(),
+					DataType:     "text",
+					NotNull:      p.NotNull(),
+					IsNamedParam: isNamed,
+				},
+			})
+
 		case *ast.A_Expr:
 			// TODO: While this works for a wide range of simple expressions,
 			// more complicated expressions will cause this logic to fail.

internal/core/analyzer/expr.go

@@ -331,15 +331,36 @@ func (a *analyzer) typeAExpr(e *ast.A_Expr) (exprType, error) {
 	if err != nil {
 		return exprType{}, err
 	}
+	escapeT, err := a.typeEscape(e.Escape)
+	if err != nil {
+		return exprType{}, err
+	}
 	// An operator's result is NULL when an operand is, except for IS and
 	// IS NOT, which test for NULL rather than propagate it: x IS NULL and
 	// x IS y are never NULL, whatever x and y are.
 	return exprType{
 		typeOID:  overload.ResultTypeOID,
-		nullable: (leftT.nullable || rightT.nullable) && !isNullTest(opName),
+		nullable: (leftT.nullable || rightT.nullable || escapeT.nullable) && !isNullTest(opName),
 	}, nil
 }
 
+// typeEscape types the ESCAPE operand of a pattern match. The escape is a
+// one-character string whatever is being matched, so a placeholder there is
+// text, named after the clause rather than after the matched column.
+func (a *analyzer) typeEscape(n ast.Node) (exprType, error) {
+	if n == nil {
+		return exprType{}, nil
+	}
+	if pr, ok := n.(*ast.ParamRef); ok {
+		a.inferParam(pr, a.namedType("text"))
+		if cur := a.params[pr.Number]; cur.Name == "" && cur.Source == nil {
+			cur.Name = "escape"
+			a.params[pr.Number] = cur
+		}
+	}
+	return a.typeExpr(n)
+}
+
 // castParamRef is the placeholder a cast wraps, as ClickHouse's {p:UInt64}
 // is written, or nil. The cast has typed it already; what it is compared
 // with still names it and says which column it stands in for.

internal/engine/sqlite/convert.go

@@ -1064,6 +1064,7 @@ func (c *cc) convertLikeExpr(n *meyer.LikeExpr) ast.Node {
 		Name:     &ast.List{Items: []ast.Node{&ast.String{Str: name}}},
 		Lexpr:    c.convert(n.X),
 		Rexpr:    c.convert(n.Y),
+		Escape:   c.convertExpr(n.Escape),
 		Location: n.Pos(),
 	}
 }

internal/sql/ast/a_expr.go

@@ -17,10 +17,14 @@ type A_Expr struct {
 	// engine that accepts more than one spelling of the same operator
 	// (SQLite's != for <>, == for =), that is the author's spelling, which
 	// is how the printer preserves it.
-	Name     *List `json:"name,omitempty"`
-	Lexpr    Node  `json:"lexpr,omitempty"`
-	Rexpr    Node  `json:"rexpr,omitempty"`
-	Location int   `json:"location"`
+	Name  *List `json:"name,omitempty"`
+	Lexpr Node  `json:"lexpr,omitempty"`
+	Rexpr Node  `json:"rexpr,omitempty"`
+	// Escape is the ESCAPE operand of a pattern match, as SQLite writes
+	// "x LIKE p ESCAPE e". pg_query folds the escape into the pattern as
+	// like_escape(p, e) instead, so PostgreSQL never sets it.
+	Escape   Node `json:"escape,omitempty"`
+	Location int  `json:"location"`
 }
 
 func (n *A_Expr) Pos() int {
@@ -119,6 +123,7 @@ func (n *A_Expr) Format(buf *TrackedBuffer, d format.Dialect) {
 			buf.WriteString(" LIKE ")
 		}
 		buf.astFormat(n.Rexpr, d)
+		n.formatEscape(buf, d)
 	case A_Expr_Kind_ILIKE:
 		buf.astFormat(n.Lexpr, d)
 		if n.negated() {
@@ -127,6 +132,7 @@ func (n *A_Expr) Format(buf *TrackedBuffer, d format.Dialect) {
 			buf.WriteString(" ILIKE ")
 		}
 		buf.astFormat(n.Rexpr, d)
+		n.formatEscape(buf, d)
 	case A_Expr_Kind_SIMILAR:
 		buf.astFormat(n.Lexpr, d)
 		buf.WriteString(" SIMILAR TO ")
@@ -174,5 +180,14 @@ func (n *A_Expr) Format(buf *TrackedBuffer, d format.Dialect) {
 			}
 			buf.astFormat(n.Rexpr, d)
 		}
+		n.formatEscape(buf, d)
+	}
+}
+
+// formatEscape prints the ESCAPE clause of a pattern match, when it has one.
+func (n *A_Expr) formatEscape(buf *TrackedBuffer, d format.Dialect) {
+	if set(n.Escape) {
+		buf.WriteString(" ESCAPE ")
+		buf.astFormat(n.Escape, d)
 	}
 }

internal/sql/astutils/rewrite.go

@@ -235,6 +235,7 @@ func (a *application) apply(parent ast.Node, name string, iter *iterator, n ast.
 		a.apply(n, "Name", nil, n.Name)
 		a.apply(n, "Lexpr", nil, n.Lexpr)
 		a.apply(n, "Rexpr", nil, n.Rexpr)
+		a.apply(n, "Escape", nil, n.Escape)
 
 	case *ast.A_Indices:
 		a.apply(n, "Lidx", nil, n.Lidx)

internal/sql/astutils/walk.go

@@ -174,6 +174,9 @@ func Walk(f Visitor, node ast.Node) {
 		if n.Rexpr != nil {
 			Walk(f, n.Rexpr)
 		}
+		if n.Escape != nil {
+			Walk(f, n.Escape)
+		}
 
 	case *ast.A_Indices:
 		if n.Lidx != nil {