Recursively check nested arrays for non-literal expressions in EXPLAIN AST

When array literals contain nested arrays with non-literal expressions
(like identifiers or binary operations), they should be output as nested
Function array calls, not as a single Literal node. This adds a recursive
check containsNonLiteralExpressionsRecursive that properly detects
expressions like [[[number]],[[number + 1],...]] at any nesting depth.

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

Author: kyleconroy

internal/explain/expressions.go

@@ -222,6 +222,10 @@ func explainLiteral(sb *strings.Builder, n *ast.Literal, indent string, depth in
 			if hasNestedArrays && containsTuplesRecursive(exprs) {
 				shouldUseFunctionArray = true
 			}
+			// Also check for non-literal expressions at any depth within nested arrays
+			if hasNestedArrays && containsNonLiteralExpressionsRecursive(exprs) {
+				shouldUseFunctionArray = true
+			}
 
 			if shouldUseFunctionArray {
 				// Render as Function array instead of Literal
@@ -410,6 +414,36 @@ func containsTuplesRecursive(exprs []ast.Expression) bool {
 	return false
 }
 
+// containsNonLiteralExpressionsRecursive checks if any nested array contains non-literal expressions at any depth
+func containsNonLiteralExpressionsRecursive(exprs []ast.Expression) bool {
+	for _, e := range exprs {
+		if lit, ok := e.(*ast.Literal); ok {
+			// Parenthesized literals need Function array format
+			if lit.Parenthesized {
+				return true
+			}
+			if lit.Type == ast.LiteralArray {
+				if innerExprs, ok := lit.Value.([]ast.Expression); ok {
+					// Recursively check nested arrays
+					if containsNonLiteralExpressionsRecursive(innerExprs) {
+						return true
+					}
+				}
+			}
+			continue
+		}
+		// Unary minus of a literal (negative number) is also acceptable
+		if unary, ok := e.(*ast.UnaryExpr); ok && unary.Op == "-" {
+			if _, ok := unary.Operand.(*ast.Literal); ok {
+				continue
+			}
+		}
+		// Any other expression type means we have non-literal expressions
+		return true
+	}
+	return false
+}
+
 func explainBinaryExpr(sb *strings.Builder, n *ast.BinaryExpr, indent string, depth int) {
 	// Convert operator to function name
 	fnName := OperatorToFunction(n.Op)

parser/testdata/00504_mergetree_arrays_rw/metadata.json

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

parser/testdata/01656_test_query_log_factories_info/metadata.json

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

parser/testdata/02183_array_tuple_literals_remote/metadata.json

@@ -1 +1 @@
-{"explain_todo":{"stmt11":true}}
+{}