Handle large number overflow and preserve original source text

- For hex numbers that overflow uint64 (like 0x123456789ABCDEF01), convert to Float64
- For decimal numbers that overflow, try float64 parsing
- Preserve original source text in Literal.Source for formatting in CAST expressions
- Update explain for negated uint64 values that overflow int64 to output Float64
- Use Source field in formatElementAsString to preserve exact text in array/tuple casts

Author: claude

internal/explain/expressions.go

@@ -435,8 +435,15 @@ func explainUnaryExpr(sb *strings.Builder, n *ast.UnaryExpr, indent string, dept
 					// ClickHouse normalizes -0 to UInt64_0
 					if val == 0 {
 						fmt.Fprintf(sb, "%sLiteral UInt64_0\n", indent)
-					} else {
+					} else if val <= 9223372036854775808 {
+						// Value fits in int64 when negated
+						// Note: -9223372036854775808 is int64 min, so 9223372036854775808 is included
 						fmt.Fprintf(sb, "%sLiteral Int64_-%d\n", indent, val)
+					} else {
+						// Value too large for int64 - output as Float64
+						f := -float64(val)
+						s := FormatFloat(f)
+						fmt.Fprintf(sb, "%sLiteral Float64_%s\n", indent, s)
 					}
 					return
 				}
@@ -657,7 +664,16 @@ func explainAliasedExpr(sb *strings.Builder, n *ast.AliasedExpr, depth int) {
 						fmt.Fprintf(sb, "%sLiteral Int64_%d (alias %s)\n", indent, -val, escapeAlias(n.Alias))
 						return
 					case uint64:
-						fmt.Fprintf(sb, "%sLiteral Int64_-%d (alias %s)\n", indent, val, escapeAlias(n.Alias))
+						if val <= 9223372036854775808 {
+							// Value fits in int64 when negated
+							// Note: -9223372036854775808 is int64 min, so 9223372036854775808 is included
+							fmt.Fprintf(sb, "%sLiteral Int64_-%d (alias %s)\n", indent, val, escapeAlias(n.Alias))
+						} else {
+							// Value too large for int64 - output as Float64
+							f := -float64(val)
+							s := FormatFloat(f)
+							fmt.Fprintf(sb, "%sLiteral Float64_%s (alias %s)\n", indent, s, escapeAlias(n.Alias))
+						}
 						return
 					}
 				case ast.LiteralFloat:

internal/explain/format.go

@@ -608,6 +608,10 @@ func formatElementAsString(expr ast.Expression) string {
 		case ast.LiteralInteger:
 			return fmt.Sprintf("%d", e.Value)
 		case ast.LiteralFloat:
+			// Use Source if available (preserves original text for large numbers)
+			if e.Source != "" {
+				return e.Source
+			}
 			return fmt.Sprintf("%v", e.Value)
 		case ast.LiteralString:
 			s := e.Value.(string)

parser/expression.go

@@ -2,13 +2,31 @@ package parser
 
 import (
 	"math"
+	"math/big"
 	"strconv"
 	"strings"
 
 	"github.com/sqlc-dev/doubleclick/ast"
 	"github.com/sqlc-dev/doubleclick/token"
 )
 
+// parseHexToFloat converts a hex string (with 0x prefix) to float64
+// Used for hex numbers that overflow uint64
+func parseHexToFloat(s string) (float64, bool) {
+	if !strings.HasPrefix(strings.ToLower(s), "0x") {
+		return 0, false
+	}
+	hexPart := s[2:]
+	bi := new(big.Int)
+	_, ok := bi.SetString(hexPart, 16)
+	if !ok {
+		return 0, false
+	}
+	f := new(big.Float).SetInt(bi)
+	result, _ := f.Float64()
+	return result, true
+}
+
 // Operator precedence levels
 const (
 	LOWEST      = iota
@@ -984,10 +1002,28 @@ func (p *Parser) parseNumber() ast.Expression {
 			// Try unsigned uint64 for large positive numbers
 			u, uerr := strconv.ParseUint(value, base, 64)
 			if uerr != nil {
-				// Too large for int64/uint64, store as string with IsBigInt flag
-				lit.Type = ast.LiteralString
-				lit.Value = value
-				lit.IsBigInt = true
+				// Too large for int64/uint64, try as float64
+				var f float64
+				var ok bool
+				if isHex {
+					// For hex numbers, use parseHexToFloat since strconv.ParseFloat
+					// doesn't handle hex integers without 'p' exponent
+					f, ok = parseHexToFloat(value)
+				} else {
+					var ferr error
+					f, ferr = strconv.ParseFloat(value, 64)
+					ok = ferr == nil
+				}
+				if !ok {
+					// Still can't parse, store as string with IsBigInt flag
+					lit.Type = ast.LiteralString
+					lit.Value = value
+					lit.IsBigInt = true
+				} else {
+					lit.Type = ast.LiteralFloat
+					lit.Value = f
+					lit.Source = value // Preserve original source text
+				}
 			} else {
 				lit.Type = ast.LiteralInteger
 				lit.Value = u // Store as uint64

parser/testdata/00031_parser_number/metadata.json

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

parser/testdata/01036_no_superfluous_dict_reload_on_create_database_2/metadata.json

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

parser/testdata/01065_if_not_finite/metadata.json

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

parser/testdata/01257_dictionary_mismatch_types/metadata.json

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

parser/testdata/01748_dictionary_table_dot/metadata.json

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

parser/testdata/02708_dotProduct/metadata.json

@@ -1,6 +1 @@
-{
-  "explain_todo": {
-    "stmt54": true,
-    "stmt55": true
-  }
-}
+{}

parser/testdata/03071_fix_short_circuit_logic/metadata.json

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