Fix 27 parser and explain output issues

- Add MarshalJSON for Literal to handle NaN/Inf values in JSON serialization
- Support INTERVAL and FORMAT keywords as identifiers when not used as keywords
- Handle uint64 numbers that exceed int64 range
- Add InsertQuery explain output support
- Expand nested DataType parameters in explain output (e.g., Array(DateTime))
- Fix FormatLiteral to handle both int64 and uint64 integer types

Test count: 5488 passing (up from 5461)

Author: claude

ast/ast.go

@@ -2,6 +2,9 @@
 package ast
 
 import (
+	"encoding/json"
+	"math"
+
 	"github.com/kyleconroy/doubleclick/token"
 )
 
@@ -589,6 +592,42 @@ func (l *Literal) Pos() token.Position { return l.Position }
 func (l *Literal) End() token.Position { return l.Position }
 func (l *Literal) expressionNode()     {}
 
+// MarshalJSON handles special float values (NaN, +Inf, -Inf) that JSON doesn't support.
+func (l *Literal) MarshalJSON() ([]byte, error) {
+	type literalAlias Literal
+	// Handle special float values
+	if f, ok := l.Value.(float64); ok {
+		if math.IsNaN(f) {
+			return json.Marshal(&struct {
+				*literalAlias
+				Value string `json:"value"`
+			}{
+				literalAlias: (*literalAlias)(l),
+				Value:        "NaN",
+			})
+		}
+		if math.IsInf(f, 1) {
+			return json.Marshal(&struct {
+				*literalAlias
+				Value string `json:"value"`
+			}{
+				literalAlias: (*literalAlias)(l),
+				Value:        "+Inf",
+			})
+		}
+		if math.IsInf(f, -1) {
+			return json.Marshal(&struct {
+				*literalAlias
+				Value string `json:"value"`
+			}{
+				literalAlias: (*literalAlias)(l),
+				Value:        "-Inf",
+			})
+		}
+	}
+	return json.Marshal((*literalAlias)(l))
+}
+
 // LiteralType represents the type of a literal.
 type LiteralType string
 

internal/explain/explain.go

@@ -97,6 +97,8 @@ func Node(sb *strings.Builder, node interface{}, depth int) {
 		explainExtractExpr(sb, n, indent, depth)
 
 	// DDL statements
+	case *ast.InsertQuery:
+		explainInsertQuery(sb, n, indent, depth)
 	case *ast.CreateQuery:
 		explainCreateQuery(sb, n, indent, depth)
 	case *ast.DropQuery:

internal/explain/format.go

@@ -11,11 +11,18 @@ import (
 func FormatLiteral(lit *ast.Literal) string {
 	switch lit.Type {
 	case ast.LiteralInteger:
-		val := lit.Value.(int64)
-		if val >= 0 {
+		// Handle both int64 and uint64 values
+		switch val := lit.Value.(type) {
+		case int64:
+			if val >= 0 {
+				return fmt.Sprintf("UInt64_%d", val)
+			}
+			return fmt.Sprintf("Int64_%d", val)
+		case uint64:
 			return fmt.Sprintf("UInt64_%d", val)
+		default:
+			return fmt.Sprintf("UInt64_%v", lit.Value)
 		}
-		return fmt.Sprintf("Int64_%d", val)
 	case ast.LiteralFloat:
 		val := lit.Value.(float64)
 		return fmt.Sprintf("Float64_%v", val)

internal/explain/statements.go

@@ -7,6 +7,35 @@ import (
 	"github.com/kyleconroy/doubleclick/ast"
 )
 
+func explainInsertQuery(sb *strings.Builder, n *ast.InsertQuery, indent string, depth int) {
+	// Count children
+	children := 0
+	if n.Function != nil {
+		children++
+	} else if n.Table != "" {
+		children++ // Table identifier
+	}
+	if n.Select != nil {
+		children++
+	}
+	// Note: InsertQuery uses 3 spaces after name in ClickHouse explain
+	fmt.Fprintf(sb, "%sInsertQuery   (children %d)\n", indent, children)
+
+	if n.Function != nil {
+		Node(sb, n.Function, depth+1)
+	} else if n.Table != "" {
+		name := n.Table
+		if n.Database != "" {
+			name = n.Database + "." + n.Table
+		}
+		fmt.Fprintf(sb, "%s Identifier %s\n", indent, name)
+	}
+
+	if n.Select != nil {
+		Node(sb, n.Select, depth+1)
+	}
+}
+
 func explainCreateQuery(sb *strings.Builder, n *ast.CreateQuery, indent string, depth int) {
 	name := n.Table
 	if n.View != "" {
@@ -139,6 +168,15 @@ func explainDescribeQuery(sb *strings.Builder, n *ast.DescribeQuery, indent stri
 }
 
 func explainDataType(sb *strings.Builder, n *ast.DataType, indent string, depth int) {
+	// Check if type has nested DataType parameters that should be expanded
+	hasNestedTypes := false
+	for _, p := range n.Parameters {
+		if _, ok := p.(*ast.DataType); ok {
+			hasNestedTypes = true
+			break
+		}
+	}
+
 	// Check if type has complex parameters (expressions, not just literals/types)
 	hasComplexParams := false
 	for _, p := range n.Parameters {
@@ -152,8 +190,8 @@ func explainDataType(sb *strings.Builder, n *ast.DataType, indent string, depth
 		break
 	}
 
-	if hasComplexParams && len(n.Parameters) > 0 {
-		// Complex parameters need to be output as children
+	if (hasNestedTypes || hasComplexParams) && len(n.Parameters) > 0 {
+		// Nested types and complex parameters need to be output as children
 		fmt.Fprintf(sb, "%sDataType %s (children %d)\n", indent, n.Name, 1)
 		fmt.Fprintf(sb, "%s ExpressionList (children %d)\n", indent, len(n.Parameters))
 		for _, p := range n.Parameters {

parser/expression.go

@@ -206,7 +206,13 @@ func (p *Parser) parsePrefixExpression() ast.Expression {
 	case token.EXTRACT:
 		return p.parseExtract()
 	case token.INTERVAL:
-		return p.parseInterval()
+		// INTERVAL can be a literal (INTERVAL 1 DAY) or identifier reference
+		// Check if next token can start an interval value
+		if p.peekIs(token.NUMBER) || p.peekIs(token.LPAREN) || p.peekIs(token.MINUS) || p.peekIs(token.STRING) {
+			return p.parseInterval()
+		}
+		// Otherwise treat as identifier
+		return p.parseKeywordAsIdentifier()
 	case token.EXISTS:
 		return p.parseExists()
 	case token.PARAM:
@@ -230,7 +236,8 @@ func (p *Parser) parsePrefixExpression() ast.Expression {
 		if p.peekIs(token.LPAREN) {
 			return p.parseKeywordAsFunction()
 		}
-		return nil
+		// format as identifier (e.g., format='Parquet' in function args)
+		return p.parseKeywordAsIdentifier()
 	default:
 		// Handle other keywords that can be used as function names or identifiers
 		if p.current.Token.IsKeyword() {
@@ -572,10 +579,18 @@ func (p *Parser) parseNumber() ast.Expression {
 			lit.Value = f
 		}
 	} else {
+		// Try signed int64 first
 		i, err := strconv.ParseInt(value, 10, 64)
 		if err != nil {
-			lit.Type = ast.LiteralString
-			lit.Value = value
+			// Try unsigned uint64 for large positive numbers
+			u, uerr := strconv.ParseUint(value, 10, 64)
+			if uerr != nil {
+				lit.Type = ast.LiteralString
+				lit.Value = value
+			} else {
+				lit.Type = ast.LiteralInteger
+				lit.Value = u // Store as uint64
+			}
 		} else {
 			lit.Type = ast.LiteralInteger
 			lit.Value = i