Add support for WITH...INSERT...SELECT syntax

- Store inherited WITH clause in InsertQuery.With instead of propagating to SelectQuery.With
- Add recursive explain functions to handle inherited WITH in select trees
- Output inherited WITH at the end of each SelectQuery's children (after tables)
- Handle SelectWithUnionQuery and SelectIntersectExceptQuery with inherited WITH

Fixes 3 statements in 03248_with_insert and 5 additional statements in other tests.

Author: claude

ast/ast.go

@@ -254,6 +254,7 @@ type InsertQuery struct {
 	Compression       string           `json:"compression,omitempty"`        // For COMPRESSION clause
 	Values            [][]Expression   `json:"-"`                            // For VALUES clause (format only, not in AST JSON)
 	Select            Statement        `json:"select,omitempty"`
+	With              []Expression     `json:"with,omitempty"` // For WITH ... INSERT ... SELECT syntax
 	Format            *Identifier      `json:"format,omitempty"`
 	HasSettings       bool             `json:"has_settings,omitempty"` // For SETTINGS clause
 	Settings          []*SettingExpr   `json:"settings,omitempty"`     // For SETTINGS clause in INSERT

internal/explain/select.go

@@ -61,7 +61,7 @@ func extractWithClause(stmt ast.Statement) []ast.Expression {
 }
 
 // explainSelectQueryWithInheritedWith outputs a SELECT with an inherited WITH clause
-// The inherited WITH clause is output AFTER the columns (not before, like a regular WITH)
+// The inherited WITH clause is output at the END of children (after columns and tables)
 func explainSelectQueryWithInheritedWith(sb *strings.Builder, stmt ast.Statement, inheritedWith []ast.Expression, depth int) {
 	sq, ok := stmt.(*ast.SelectQuery)
 	if !ok {
@@ -76,23 +76,17 @@ func explainSelectQueryWithInheritedWith(sb *strings.Builder, stmt ast.Statement
 		return
 	}
 
-	// Output SelectQuery with inherited WITH clause after columns
+	// Output SelectQuery with inherited WITH clause at the end
 	indent := strings.Repeat(" ", depth)
 	children := countSelectQueryChildren(sq) + 1 // +1 for inherited WITH clause
 	fmt.Fprintf(sb, "%sSelectQuery (children %d)\n", indent, children)
 
-	// Columns (ExpressionList) - output BEFORE inherited WITH
+	// Columns (ExpressionList) - output first
 	fmt.Fprintf(sb, "%s ExpressionList (children %d)\n", indent, len(sq.Columns))
 	for _, col := range sq.Columns {
 		Node(sb, col, depth+2)
 	}
 
-	// Inherited WITH clause (ExpressionList) - output AFTER columns
-	fmt.Fprintf(sb, "%s ExpressionList (children %d)\n", indent, len(inheritedWith))
-	for _, w := range inheritedWith {
-		Node(sb, w, depth+2)
-	}
-
 	// FROM (including ARRAY JOIN as part of TablesInSelectQuery)
 	if sq.From != nil || sq.ArrayJoin != nil {
 		TablesWithArrayJoin(sb, sq.From, sq.ArrayJoin, depth+1)
@@ -180,6 +174,105 @@ func explainSelectQueryWithInheritedWith(sb *strings.Builder, stmt ast.Statement
 	if sq.Top != nil {
 		Node(sb, sq.Top, depth+1)
 	}
+
+	// Inherited WITH clause (ExpressionList) - output at the END
+	fmt.Fprintf(sb, "%s ExpressionList (children %d)\n", indent, len(inheritedWith))
+	for _, w := range inheritedWith {
+		Node(sb, w, depth+2)
+	}
+}
+
+// ExplainSelectWithInheritedWith recursively explains a select statement with inherited WITH clause
+// This is used for WITH ... INSERT ... SELECT where the WITH clause belongs to the INSERT
+// but needs to be output at the end of each SelectQuery in the tree
+func ExplainSelectWithInheritedWith(sb *strings.Builder, stmt ast.Statement, inheritedWith []ast.Expression, depth int) {
+	switch s := stmt.(type) {
+	case *ast.SelectWithUnionQuery:
+		explainSelectWithUnionQueryWithInheritedWith(sb, s, inheritedWith, depth)
+	case *ast.SelectIntersectExceptQuery:
+		explainSelectIntersectExceptQueryWithInheritedWith(sb, s, inheritedWith, depth)
+	case *ast.SelectQuery:
+		explainSelectQueryWithInheritedWith(sb, s, inheritedWith, depth)
+	default:
+		Node(sb, stmt, depth)
+	}
+}
+
+// explainSelectWithUnionQueryWithInheritedWith explains a SelectWithUnionQuery with inherited WITH
+func explainSelectWithUnionQueryWithInheritedWith(sb *strings.Builder, n *ast.SelectWithUnionQuery, inheritedWith []ast.Expression, depth int) {
+	if n == nil {
+		return
+	}
+	indent := strings.Repeat(" ", depth)
+	children := countSelectUnionChildren(n)
+	fmt.Fprintf(sb, "%sSelectWithUnionQuery (children %d)\n", indent, children)
+
+	selects := simplifyUnionSelects(n.Selects)
+	fmt.Fprintf(sb, "%s ExpressionList (children %d)\n", indent, len(selects))
+	for _, sel := range selects {
+		ExplainSelectWithInheritedWith(sb, sel, inheritedWith, depth+2)
+	}
+
+	// INTO OUTFILE clause
+	for _, sel := range n.Selects {
+		if sq, ok := sel.(*ast.SelectQuery); ok && sq.IntoOutfile != nil {
+			fmt.Fprintf(sb, "%s Literal \\'%s\\'\n", indent, sq.IntoOutfile.Filename)
+			break
+		}
+	}
+	// SETTINGS before FORMAT
+	if n.SettingsBeforeFormat && len(n.Settings) > 0 {
+		fmt.Fprintf(sb, "%s Set\n", indent)
+	}
+	// FORMAT clause - check individual SelectQuery nodes
+	for _, sel := range n.Selects {
+		if sq, ok := sel.(*ast.SelectQuery); ok && sq.Format != nil {
+			Node(sb, sq.Format, depth+1)
+			break
+		}
+	}
+	// SETTINGS after FORMAT
+	if n.SettingsAfterFormat && len(n.Settings) > 0 {
+		fmt.Fprintf(sb, "%s Set\n", indent)
+	} else {
+		for _, sel := range n.Selects {
+			if sq, ok := sel.(*ast.SelectQuery); ok && sq.SettingsAfterFormat && len(sq.Settings) > 0 {
+				fmt.Fprintf(sb, "%s Set\n", indent)
+				break
+			}
+		}
+	}
+}
+
+// explainSelectIntersectExceptQueryWithInheritedWith explains a SelectIntersectExceptQuery with inherited WITH
+func explainSelectIntersectExceptQueryWithInheritedWith(sb *strings.Builder, n *ast.SelectIntersectExceptQuery, inheritedWith []ast.Expression, depth int) {
+	indent := strings.Repeat(" ", depth)
+	fmt.Fprintf(sb, "%sSelectIntersectExceptQuery (children %d)\n", indent, len(n.Selects))
+
+	// Check if EXCEPT is present - affects how first operand is wrapped
+	hasExcept := false
+	for _, op := range n.Operators {
+		if strings.HasPrefix(op, "EXCEPT") {
+			hasExcept = true
+			break
+		}
+	}
+
+	for i, sel := range n.Selects {
+		if hasExcept && i == 0 {
+			// Wrap first operand in SelectWithUnionQuery format
+			if _, isUnion := sel.(*ast.SelectWithUnionQuery); isUnion {
+				ExplainSelectWithInheritedWith(sb, sel, inheritedWith, depth+1)
+			} else {
+				childIndent := strings.Repeat(" ", depth+1)
+				fmt.Fprintf(sb, "%sSelectWithUnionQuery (children 1)\n", childIndent)
+				fmt.Fprintf(sb, "%s ExpressionList (children 1)\n", childIndent)
+				ExplainSelectWithInheritedWith(sb, sel, inheritedWith, depth+3)
+			}
+		} else {
+			ExplainSelectWithInheritedWith(sb, sel, inheritedWith, depth+1)
+		}
+	}
 }
 
 func explainSelectWithUnionQuery(sb *strings.Builder, n *ast.SelectWithUnionQuery, indent string, depth int) {

internal/explain/statements.go

@@ -97,7 +97,13 @@ func explainInsertQuery(sb *strings.Builder, n *ast.InsertQuery, indent string,
 				}
 			}
 		}
-		Node(sb, n.Select, depth+1)
+		// If this INSERT has an inherited WITH clause (from WITH ... INSERT syntax),
+		// use the special explain function that outputs WITH at the end of each SelectQuery
+		if len(n.With) > 0 {
+			ExplainSelectWithInheritedWith(sb, n.Select, n.With, depth+1)
+		} else {
+			Node(sb, n.Select, depth+1)
+		}
 	}
 
 	if n.HasSettings {