Handle INSERT VALUES followed by SELECT on same line (#118)

ClickHouse has special handling where INSERT VALUES followed by SELECT on the
same line outputs the INSERT AST and then executes the SELECT, printing its result.

- Add ExplainStatements() function to handle multi-statement explain output
- When first statement is INSERT and subsequent are SELECT with simple literals,
  append the literal values to match ClickHouse behavior
- Update test to use ExplainStatements() for all explain output

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

Author: kyleconroy

internal/explain/explain.go

@@ -23,6 +23,85 @@ func Explain(stmt ast.Statement) string {
 	return sb.String()
 }
 
+// ExplainStatements returns the EXPLAIN AST output for multiple statements.
+// This handles the special ClickHouse behavior where INSERT VALUES followed by SELECT
+// on the same line outputs the INSERT AST and then executes the SELECT, printing its result.
+func ExplainStatements(stmts []ast.Statement) string {
+	if len(stmts) == 0 {
+		return ""
+	}
+
+	var sb strings.Builder
+	Node(&sb, stmts[0], 0)
+
+	// If the first statement is an INSERT and there are subsequent SELECT statements
+	// with simple literals, append those literal values (matching ClickHouse's behavior)
+	if _, isInsert := stmts[0].(*ast.InsertQuery); isInsert {
+		for i := 1; i < len(stmts); i++ {
+			if result := getSimpleSelectResult(stmts[i]); result != "" {
+				sb.WriteString(result)
+				sb.WriteString("\n")
+			}
+		}
+	}
+
+	return sb.String()
+}
+
+// getSimpleSelectResult extracts the literal value from a simple SELECT statement
+// like "SELECT 11111" and returns it as a string. Returns empty string if not a simple SELECT.
+func getSimpleSelectResult(stmt ast.Statement) string {
+	// Check if it's a SelectWithUnionQuery
+	selectUnion, ok := stmt.(*ast.SelectWithUnionQuery)
+	if !ok {
+		return ""
+	}
+
+	// Must have exactly one select query
+	if len(selectUnion.Selects) != 1 {
+		return ""
+	}
+
+	// Get the inner select query
+	selectQuery, ok := selectUnion.Selects[0].(*ast.SelectQuery)
+	if !ok {
+		return ""
+	}
+
+	// Must have exactly one expression in the select list
+	if len(selectQuery.Columns) != 1 {
+		return ""
+	}
+
+	// Must be a literal
+	literal, ok := selectQuery.Columns[0].(*ast.Literal)
+	if !ok {
+		return ""
+	}
+
+	// Format the literal value
+	return formatLiteralValue(literal)
+}
+
+// formatLiteralValue formats a literal value as it would appear in query results
+func formatLiteralValue(lit *ast.Literal) string {
+	switch v := lit.Value.(type) {
+	case int64:
+		return fmt.Sprintf("%d", v)
+	case float64:
+		return fmt.Sprintf("%v", v)
+	case string:
+		return v
+	case bool:
+		if v {
+			return "1"
+		}
+		return "0"
+	default:
+		return fmt.Sprintf("%v", v)
+	}
+}
+
 // Node writes the EXPLAIN AST output for an AST node.
 func Node(sb *strings.Builder, node interface{}, depth int) {
 	if node == nil {

parser/explain.go

@@ -9,3 +9,10 @@ import (
 func Explain(stmt ast.Statement) string {
 	return explain.Explain(stmt)
 }
+
+// ExplainStatements returns the EXPLAIN AST output for multiple statements.
+// This handles the special ClickHouse behavior where INSERT VALUES followed by SELECT
+// on the same line outputs the INSERT AST and then executes the SELECT, printing its result.
+func ExplainStatements(stmts []ast.Statement) string {
+	return explain.ExplainStatements(stmts)
+}

parser/parser_test.go

@@ -307,7 +307,7 @@ func TestParser(t *testing.T) {
 							t.Skipf("Skipping: empty expected output with clientError annotation")
 							return
 						}
-						actual := strings.TrimSpace(parser.Explain(stmts[0]))
+						actual := strings.TrimSpace(parser.ExplainStatements(stmts))
 						// Use case-insensitive comparison since ClickHouse EXPLAIN AST has inconsistent casing
 						if !strings.EqualFold(actual, expected) {
 							if isExplainTodo && *checkExplain {

parser/testdata/00306_insert_values_and_expressions/metadata.json

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