Add WITH clause element explain output support

- Add explainWithElement function to handle WITH clause expressions
- Add explainFunctionCallWithAlias helper for function calls with aliases
- Update select.go to output WITH clause ExpressionList
- Update explain.go to handle *ast.WithElement nodes

Test count: 5505 -> 5517 (+12 tests)

Author: claude

internal/explain/explain.go

@@ -63,6 +63,8 @@ func Node(sb *strings.Builder, node interface{}, depth int) {
 		explainSubquery(sb, n, indent, depth)
 	case *ast.AliasedExpr:
 		explainAliasedExpr(sb, n, depth)
+	case *ast.WithElement:
+		explainWithElement(sb, n, indent, depth)
 	case *ast.Asterisk:
 		explainAsterisk(sb, n, indent)
 

internal/explain/expressions.go

@@ -149,3 +149,28 @@ func explainAsterisk(sb *strings.Builder, n *ast.Asterisk, indent string) {
 		fmt.Fprintf(sb, "%sAsterisk\n", indent)
 	}
 }
+
+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
+	switch e := n.Query.(type) {
+	case *ast.Literal:
+		fmt.Fprintf(sb, "%sLiteral %s (alias %s)\n", indent, FormatLiteral(e), n.Name)
+	case *ast.Identifier:
+		fmt.Fprintf(sb, "%sIdentifier %s (alias %s)\n", indent, e.Name(), n.Name)
+	case *ast.FunctionCall:
+		explainFunctionCallWithAlias(sb, e, n.Name, indent, depth)
+	case *ast.BinaryExpr:
+		// Binary expressions become functions
+		fnName := OperatorToFunction(e.Op)
+		fmt.Fprintf(sb, "%sFunction %s (alias %s) (children %d)\n", indent, fnName, n.Name, 1)
+		fmt.Fprintf(sb, "%s ExpressionList (children %d)\n", indent, 2)
+		Node(sb, e.Left, depth+2)
+		Node(sb, e.Right, depth+2)
+	case *ast.Subquery:
+		fmt.Fprintf(sb, "%sSubquery (alias %s) (children %d)\n", indent, n.Name, 1)
+		Node(sb, e.Query, depth+1)
+	default:
+		// For other types, just output the expression (alias may be lost)
+		Node(sb, n.Query, depth)
+	}
+}

internal/explain/functions.go

@@ -8,14 +8,18 @@ import (
 )
 
 func explainFunctionCall(sb *strings.Builder, n *ast.FunctionCall, indent string, depth int) {
+	explainFunctionCallWithAlias(sb, n, n.Alias, indent, depth)
+}
+
+func explainFunctionCallWithAlias(sb *strings.Builder, n *ast.FunctionCall, alias string, indent string, depth int) {
 	children := 1 // arguments ExpressionList
 	if len(n.Parameters) > 0 {
 		children++ // parameters ExpressionList
 	}
 	// Normalize function name
 	fnName := NormalizeFunctionName(n.Name)
-	if n.Alias != "" {
-		fmt.Fprintf(sb, "%sFunction %s (alias %s) (children %d)\n", indent, fnName, n.Alias, children)
+	if alias != "" {
+		fmt.Fprintf(sb, "%sFunction %s (alias %s) (children %d)\n", indent, fnName, alias, children)
 	} else {
 		fmt.Fprintf(sb, "%sFunction %s (children %d)\n", indent, fnName, children)
 	}

internal/explain/select.go

@@ -27,6 +27,13 @@ func explainSelectWithUnionQuery(sb *strings.Builder, n *ast.SelectWithUnionQuer
 func explainSelectQuery(sb *strings.Builder, n *ast.SelectQuery, indent string, depth int) {
 	children := countSelectQueryChildren(n)
 	fmt.Fprintf(sb, "%sSelectQuery (children %d)\n", indent, children)
+	// WITH clause (ExpressionList) - output before columns
+	if len(n.With) > 0 {
+		fmt.Fprintf(sb, "%s ExpressionList (children %d)\n", indent, len(n.With))
+		for _, w := range n.With {
+			Node(sb, w, depth+2)
+		}
+	}
 	// Columns (ExpressionList)
 	fmt.Fprintf(sb, "%s ExpressionList (children %d)\n", indent, len(n.Columns))
 	for _, col := range n.Columns {
@@ -95,6 +102,10 @@ func countSelectUnionChildren(n *ast.SelectWithUnionQuery) int {
 
 func countSelectQueryChildren(n *ast.SelectQuery) int {
 	count := 1 // columns ExpressionList
+	// WITH clause
+	if len(n.With) > 0 {
+		count++
+	}
 	// FROM and ARRAY JOIN together count as one child (TablesInSelectQuery)
 	if n.From != nil || n.ArrayJoin != nil {
 		count++