Support binary expression WITH clauses like (SELECT ...) + (SELECT ...) AS name

- Remove special case for `(SELECT ...) AS name` in parseWithClause, letting it
  go through the expression parser which handles binary expressions
- Add ScalarWith flag to WithElement to distinguish between:
  - "name AS (SELECT ...)" - standard CTE syntax
  - "(SELECT ...) AS name" - ClickHouse scalar WITH syntax
- Update EXPLAIN output to use correct format based on ScalarWith flag

Fixes 03212_variant_dynamic_cast_or_default/stmt51.

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

Author: kyleconroy

ast/ast.go

@@ -1593,9 +1593,10 @@ func (s *Subquery) expressionNode()     {}
 
 // WithElement represents a WITH element (CTE).
 type WithElement struct {
-	Position token.Position `json:"-"`
-	Name     string         `json:"name"`
-	Query    Expression     `json:"query"` // Subquery or Expression
+	Position   token.Position `json:"-"`
+	Name       string         `json:"name"`
+	Query      Expression     `json:"query"`       // Subquery or Expression
+	ScalarWith bool           `json:"scalar_with"` // True for "(expr) AS name" syntax, false for "name AS (SELECT ...)"
 }
 
 func (w *WithElement) Pos() token.Position { return w.Position }

internal/explain/expressions.go

@@ -1195,14 +1195,23 @@ func explainWithElement(sb *strings.Builder, n *ast.WithElement, indent string,
 			Node(sb, e.Right, depth+2)
 		}
 	case *ast.Subquery:
-		// Check if this is "(subquery) AS alias" syntax vs "name AS (subquery)" syntax
-		if e.Alias != "" {
-			// "(subquery) AS alias" syntax: output Subquery with alias directly
-			fmt.Fprintf(sb, "%sSubquery (alias %s) (children 1)\n", indent, e.Alias)
+		// Output format depends on the WITH syntax:
+		// - "name AS (SELECT ...)": Standard CTE - output WithElement wrapping Subquery (no alias)
+		// - "(SELECT ...) AS name": Scalar WITH - output Subquery with alias
+		if n.ScalarWith {
+			// Scalar WITH: show alias on Subquery
+			alias := n.Name
+			if alias == "" {
+				alias = e.Alias
+			}
+			if alias != "" {
+				fmt.Fprintf(sb, "%sSubquery (alias %s) (children 1)\n", indent, alias)
+			} else {
+				fmt.Fprintf(sb, "%sSubquery (children 1)\n", indent)
+			}
 			Node(sb, e.Query, depth+1)
 		} else {
-			// "name AS (subquery)" syntax: output WithElement wrapping the Subquery
-			// The alias/name is not shown in the EXPLAIN AST output
+			// Standard CTE: wrap in WithElement without alias
 			fmt.Fprintf(sb, "%sWithElement (children 1)\n", indent)
 			fmt.Fprintf(sb, "%s Subquery (children 1)\n", indent)
 			Node(sb, e.Query, depth+2)

parser/parser.go

@@ -1447,33 +1447,16 @@ func (p *Parser) parseWithClause() []ast.Expression {
 				elem.Name = name
 				elem.Query = &ast.Identifier{Position: pos, Parts: []string{name}}
 			}
-		} else if p.currentIs(token.LPAREN) && (p.peekIs(token.SELECT) || p.peekIs(token.WITH)) {
-			// Subquery: (SELECT ...) AS name or (WITH ... SELECT ...) AS name
-			// In this syntax, the alias goes on the Subquery, not on WithElement
-			p.nextToken()
-			subquery := p.parseSelectWithUnion()
-			if !p.expect(token.RPAREN) {
-				return nil
-			}
-			sq := &ast.Subquery{Query: subquery}
-
-			if !p.expect(token.AS) {
-				return nil
-			}
-
-			// Alias can be IDENT or certain keywords (VALUES, KEY, etc.)
-			// Set alias on the Subquery for "(subquery) AS name" syntax
-			if p.currentIs(token.IDENT) || p.current.Token.IsKeyword() {
-				sq.Alias = p.current.Value
-				p.nextToken()
-			}
-			elem.Query = sq
 		} else {
 			// Scalar WITH: expr AS name (ClickHouse style)
-			// Examples: WITH 1 AS x, WITH 'hello' AS s, WITH func() AS f
-			// Also handles lambda: WITH x -> toString(x) AS lambda_1
+			// This handles various forms:
+			// - WITH 1 AS x, WITH 'hello' AS s, WITH func() AS f
+			// - WITH (SELECT ...) AS name (subquery expression)
+			// - WITH (SELECT ...) + (SELECT ...) AS name (binary expression of subqueries)
+			// - WITH x -> toString(x) AS lambda_1 (lambda expression)
 			// Arrow has OR_PREC precedence, so it gets parsed with ALIAS_PREC
 			// Note: AS name is optional in ClickHouse, e.g., WITH 1 SELECT 1 is valid
+			elem.ScalarWith = true
 			elem.Query = p.parseExpression(ALIAS_PREC) // Use ALIAS_PREC to stop before AS
 
 			// AS name is optional

parser/testdata/03212_variant_dynamic_cast_or_default/metadata.json

@@ -1,5 +1 @@
-{
-  "explain_todo": {
-    "stmt51": true
-  }
-}
+{}