Fix nested tuple literal formatting in EXPLAIN output

When a tuple contains only primitive literals (including nested tuples
with primitive literals), it should be rendered as a single
Literal Tuple_(...) rather than Function tuple with children.

Add containsOnlyPrimitiveLiteralsWithUnary helper that checks if a
tuple contains only primitive literals, including handling unary
negation of numeric literals (e.g., -0., -123).

Fixes 17 statements across 11 tests.

Author: claude

internal/explain/expressions.go

@@ -65,8 +65,16 @@ func explainLiteral(sb *strings.Builder, n *ast.Literal, indent string, depth in
 			for _, e := range exprs {
 				// Simple literals (numbers, strings, etc.) are OK
 				if lit, isLit := e.(*ast.Literal); isLit {
-					// Nested tuples/arrays are complex
-					if lit.Type == ast.LiteralTuple || lit.Type == ast.LiteralArray {
+					// Nested tuples that contain only primitive literals are OK
+					if lit.Type == ast.LiteralTuple {
+						if !containsOnlyPrimitiveLiteralsWithUnary(lit) {
+							hasComplexExpr = true
+							break
+						}
+						continue
+					}
+					// Arrays are always complex in tuple context
+					if lit.Type == ast.LiteralArray {
 						hasComplexExpr = true
 						break
 					}

internal/explain/functions.go

@@ -322,6 +322,46 @@ func containsOnlyPrimitiveLiterals(lit *ast.Literal) bool {
 	return true
 }
 
+// containsOnlyPrimitiveLiteralsWithUnary is like containsOnlyPrimitiveLiterals but also handles
+// unary negation of numeric literals (e.g., -0., -123)
+func containsOnlyPrimitiveLiteralsWithUnary(lit *ast.Literal) bool {
+	if lit.Type != ast.LiteralTuple {
+		// Non-tuple literals are primitive
+		return true
+	}
+	exprs, ok := lit.Value.([]ast.Expression)
+	if !ok {
+		return false
+	}
+	for _, e := range exprs {
+		// Direct literal
+		if innerLit, ok := e.(*ast.Literal); ok {
+			// Recursively check nested tuples
+			if innerLit.Type == ast.LiteralTuple {
+				if !containsOnlyPrimitiveLiteralsWithUnary(innerLit) {
+					return false
+				}
+			}
+			// Arrays inside tuples make it complex
+			if innerLit.Type == ast.LiteralArray {
+				return false
+			}
+			continue
+		}
+		// Unary negation of numeric literal is also primitive
+		if unary, ok := e.(*ast.UnaryExpr); ok && unary.Op == "-" {
+			if innerLit, ok := unary.Operand.(*ast.Literal); ok {
+				if innerLit.Type == ast.LiteralInteger || innerLit.Type == ast.LiteralFloat {
+					continue
+				}
+			}
+		}
+		// Non-literal expression in tuple
+		return false
+	}
+	return true
+}
+
 // exprToLiteral converts a numeric expression to a literal (handles unary minus)
 func exprToLiteral(expr ast.Expression) *ast.Literal {
 	if lit, ok := expr.(*ast.Literal); ok {

parser/testdata/00132_sets/metadata.json

@@ -1,6 +1,5 @@
 {
   "explain_todo": {
-    "stmt11": true,
     "stmt12": true,
     "stmt6": true,
     "stmt9": true

parser/testdata/00626_in_syntax/metadata.json

@@ -1,8 +1 @@
-{
-  "explain_todo": {
-    "stmt3": true,
-    "stmt4": true,
-    "stmt5": true,
-    "stmt6": true
-  }
-}
+{}

parser/testdata/00945_bloom_filter_index/metadata.json

@@ -1,6 +1,5 @@
 {
   "explain_todo": {
-    "stmt10": true,
     "stmt152": true,
     "stmt19": true,
     "stmt20": true,

parser/testdata/01398_in_tuple_func/metadata.json

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

parser/testdata/01653_tuple_hamming_distance_2/metadata.json

@@ -1,7 +1 @@
-{
-  "explain_todo": {
-    "stmt16": true,
-    "stmt17": true,
-    "stmt18": true
-  }
-}
+{}

parser/testdata/01803_untuple_subquery/metadata.json

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

parser/testdata/02011_tuple_vector_functions/metadata.json

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

parser/testdata/02030_tuple_filter/metadata.json

@@ -1 +1 @@
-{"explain_todo":{"stmt10":true,"stmt11":true,"stmt13":true}}
+{}