Add ColumnsListMatcher support for COLUMNS(id, col) syntax

Previously the parser only handled COLUMNS('pattern') as a regex matcher.
Now it also handles COLUMNS(col1, col2) as a list matcher, which is
output as ColumnsListMatcher in EXPLAIN AST.

Changes:
- Added Columns field to ColumnsMatcher AST type
- Added Qualifier field for qualified matchers like table.COLUMNS(...)
- Updated parseColumnsMatcher to parse column lists
- Added explainColumnsMatcher function for proper EXPLAIN output

Author: claude

ast/ast.go

@@ -1137,11 +1137,15 @@ type ReplaceExpr struct {
 func (r *ReplaceExpr) Pos() token.Position { return r.Position }
 func (r *ReplaceExpr) End() token.Position { return r.Position }
 
-// ColumnsMatcher represents COLUMNS('pattern') expression.
+// ColumnsMatcher represents COLUMNS('pattern') or COLUMNS(col1, col2) expression.
+// When Pattern is set, it's a regex matcher (ColumnsRegexpMatcher in explain).
+// When Columns is set, it's a list matcher (ColumnsListMatcher in explain).
 type ColumnsMatcher struct {
-	Position token.Position `json:"-"`
-	Pattern  string         `json:"pattern"`
-	Except   []string       `json:"except,omitempty"`
+	Position  token.Position `json:"-"`
+	Pattern   string         `json:"pattern,omitempty"`
+	Columns   []Expression   `json:"columns,omitempty"` // For COLUMNS(id, name) syntax
+	Except    []string       `json:"except,omitempty"`
+	Qualifier string         `json:"qualifier,omitempty"` // For qualified matchers like table.COLUMNS(...)
 }
 
 func (c *ColumnsMatcher) Pos() token.Position { return c.Position }

internal/explain/explain.go

@@ -74,7 +74,7 @@ func Node(sb *strings.Builder, node interface{}, depth int) {
 	case *ast.Asterisk:
 		explainAsterisk(sb, n, indent, depth)
 	case *ast.ColumnsMatcher:
-		fmt.Fprintf(sb, "%sColumnsRegexpMatcher\n", indent)
+		explainColumnsMatcher(sb, n, indent, depth)
 
 	// Functions
 	case *ast.FunctionCall:

internal/explain/expressions.go

@@ -585,6 +585,41 @@ func explainColumnsTransformers(sb *strings.Builder, n *ast.Asterisk, indent str
 	}
 }
 
+func explainColumnsMatcher(sb *strings.Builder, n *ast.ColumnsMatcher, indent string, depth int) {
+	// Determine the matcher type based on whether it's a pattern or a list
+	if len(n.Columns) > 0 {
+		// ColumnsListMatcher for COLUMNS(col1, col2, ...)
+		typeName := "ColumnsListMatcher"
+		if n.Qualifier != "" {
+			typeName = "QualifiedColumnsListMatcher"
+		}
+		if n.Qualifier != "" {
+			// QualifiedColumnsListMatcher has qualifier as a child
+			fmt.Fprintf(sb, "%s%s (children %d)\n", indent, typeName, 2)
+			fmt.Fprintf(sb, "%s Identifier %s\n", indent, n.Qualifier)
+		} else {
+			fmt.Fprintf(sb, "%s%s (children %d)\n", indent, typeName, 1)
+		}
+		// Output the columns as ExpressionList
+		fmt.Fprintf(sb, "%s ExpressionList (children %d)\n", indent, len(n.Columns))
+		for _, col := range n.Columns {
+			Node(sb, col, depth+2)
+		}
+	} else {
+		// ColumnsRegexpMatcher for COLUMNS('pattern')
+		typeName := "ColumnsRegexpMatcher"
+		if n.Qualifier != "" {
+			typeName = "QualifiedColumnsRegexpMatcher"
+		}
+		if n.Qualifier != "" {
+			fmt.Fprintf(sb, "%s%s (children %d)\n", indent, typeName, 1)
+			fmt.Fprintf(sb, "%s Identifier %s\n", indent, n.Qualifier)
+		} else {
+			fmt.Fprintf(sb, "%s%s\n", indent, typeName)
+		}
+	}
+}
+
 func explainWithElement(sb *strings.Builder, n *ast.WithElement, indent string, depth int) {
 	// For WITH elements, we need to show the underlying expression with the name as alias
 	// When name is empty, don't show the alias part

parser/expression.go

@@ -1868,10 +1868,24 @@ func (p *Parser) parseColumnsMatcher() ast.Expression {
 		return nil
 	}
 
-	// Parse the pattern (string)
+	// Parse the arguments - either a string pattern or a list of identifiers
 	if p.currentIs(token.STRING) {
+		// String pattern: COLUMNS('pattern')
 		matcher.Pattern = p.current.Value
 		p.nextToken()
+	} else {
+		// Column list: COLUMNS(col1, col2, ...)
+		for !p.currentIs(token.RPAREN) && !p.currentIs(token.EOF) {
+			col := p.parseExpression(LOWEST)
+			if col != nil {
+				matcher.Columns = append(matcher.Columns, col)
+			}
+			if p.currentIs(token.COMMA) {
+				p.nextToken()
+			} else {
+				break
+			}
+		}
 	}
 
 	p.expect(token.RPAREN)

parser/testdata/02339_analyzer_matcher_basic/metadata.json

@@ -4,10 +4,6 @@
     "stmt103": true,
     "stmt105": true,
     "stmt106": true,
-    "stmt18": true,
-    "stmt19": true,
-    "stmt21": true,
-    "stmt22": true,
     "stmt30": true,
     "stmt31": true,
     "stmt33": true,
@@ -20,15 +16,13 @@
     "stmt52": true,
     "stmt54": true,
     "stmt55": true,
-    "stmt6": true,
     "stmt60": true,
     "stmt61": true,
     "stmt63": true,
     "stmt64": true,
     "stmt66": true,
     "stmt67": true,
     "stmt69": true,
-    "stmt7": true,
     "stmt70": true,
     "stmt79": true,
     "stmt80": true,