Fix precision loss for large bigint PKs in table repair JSON roundtrip

OrderedMap.UnmarshalJSON used Go's default JSON number decoding (float64),
which silently truncates integers exceeding 2^53. For tables with large
bigint primary keys (e.g. snowflake IDs like 415588913294348289), this
caused:

- PK corruption: 415588913294348289 → 415588913294348288 (off by 1)
- PK collisions: adjacent PKs mapped to the same float64, causing rows
  to silently overwrite each other in repair maps
- Wrong upserts/deletes: repairs targeted wrong rows or missed them
- Growing diffs after repair: corrupted values replicated via spock

Fix: add dec.UseNumber() to OrderedMap.UnmarshalJSON so JSON numbers are
preserved as json.Number strings. Update ConvertToPgxType to handle
json.Number for integer types (lossless Int64 parse), numeric/decimal
(exact string via pgtype.Numeric), and float types (Float64 parse).

Replace the three duplicate lossy numeric helpers (toFloat64, asFloat,
asNumber) with a single precision-safe CompareNumeric in pkg/common that
uses an int64 fast path and falls back to math/big.Float (256-bit) for
json.Number decimals, large uint64, and native floats. Also handle
json.Number in repair plan when-expression literals (scanNumber),
pk_in matching, and origin timestamp extraction.

The v4 pgtype dependency will be removed in a follow-on PR.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: 2 people

internal/consistency/repair/executor.go

@@ -286,10 +286,8 @@ func pkMatchesOverride(pkOrder []string, rowPk map[string]any, overridePk map[st
 	}
 
 	equal := func(a, b any) bool {
-		if af, ok := asFloat(a); ok {
-			if bf, ok2 := asFloat(b); ok2 {
-				return af == bf
-			}
+		if cmp, ok := utils.CompareNumeric(a, b); ok {
+			return cmp == 0
 		}
 		return reflect.DeepEqual(a, b)
 	}
@@ -308,10 +306,8 @@ func matchPKIn(matchers []planner.RepairPKMatcher, rowPk map[string]any, pkOrder
 	}
 
 	equal := func(a, b any) bool {
-		if af, ok := asFloat(a); ok {
-			if bf, ok2 := asFloat(b); ok2 {
-				return af == bf
-			}
+		if cmp, ok := utils.CompareNumeric(a, b); ok {
+			return cmp == 0
 		}
 		return reflect.DeepEqual(a, b)
 	}
@@ -353,11 +349,10 @@ func matchPKIn(matchers []planner.RepairPKMatcher, rowPk map[string]any, pkOrder
 }
 
 func compareRange(val, from, to any) bool {
-	ln, lok := asFloat(val)
-	fn, fok := asFloat(from)
-	tn, tok := asFloat(to)
-	if lok && fok && tok {
-		return ln >= fn && ln <= tn
+	cmpFrom, okFrom := utils.CompareNumeric(val, from)
+	cmpTo, okTo := utils.CompareNumeric(val, to)
+	if okFrom && okTo {
+		return cmpFrom >= 0 && cmpTo <= 0
 	}
 
 	ls, lsok := val.(string)
@@ -369,37 +364,6 @@ func compareRange(val, from, to any) bool {
 	return false
 }
 
-func asFloat(v any) (float64, bool) {
-	switch n := v.(type) {
-	case int:
-		return float64(n), true
-	case int8:
-		return float64(n), true
-	case int16:
-		return float64(n), true
-	case int32:
-		return float64(n), true
-	case int64:
-		return float64(n), true
-	case uint:
-		return float64(n), true
-	case uint8:
-		return float64(n), true
-	case uint16:
-		return float64(n), true
-	case uint32:
-		return float64(n), true
-	case uint64:
-		return float64(n), true
-	case float32:
-		return float64(n), true
-	case float64:
-		return n, true
-	default:
-		return 0, false
-	}
-}
-
 func columnsIntersect(a, b []string) bool {
 	if len(a) == 0 || len(b) == 0 {
 		return false
@@ -780,15 +744,13 @@ func freshestSide(key string, tie string, row planDiffRow) string {
 		return strings.TrimSpace(strings.ToLower(tie))
 	}
 
-	if f1, ok := asFloat(k1); ok {
-		if f2, ok2 := asFloat(k2); ok2 {
-			if f1 > f2 {
-				return "n1"
-			} else if f2 > f1 {
-				return "n2"
-			}
-			return strings.TrimSpace(strings.ToLower(tie))
+	if cmp, ok := utils.CompareNumeric(k1, k2); ok {
+		if cmp > 0 {
+			return "n1"
+		} else if cmp < 0 {
+			return "n2"
 		}
+		return strings.TrimSpace(strings.ToLower(tie))
 	}
 
 	if s1, ok := k1.(string); ok {

internal/consistency/repair/plan/parser/parser.go

@@ -12,10 +12,12 @@
 package parser
 
 import (
+	"encoding/json"
 	"fmt"
-	"strconv"
 	"strings"
 	"unicode"
+
+	utils "github.com/pgedge/ace/pkg/common"
 )
 
 // WhenExpr represents a compiled predicate over diff row values (n1./n2.).
@@ -227,11 +229,13 @@ func (l *lexer) scanNumber() (token, error) {
 		l.pos++
 	}
 	text := l.input[start:l.pos]
-	num, err := strconv.ParseFloat(text, 64)
-	if err != nil {
+	// Store as json.Number to preserve full precision for large integers
+	// and high-precision decimals. CompareNumeric handles json.Number natively.
+	n := json.Number(text)
+	if _, err := n.Float64(); err != nil {
 		return token{}, fmt.Errorf("invalid number %q at pos %d", text, start)
 	}
-	return token{typ: tokNumber, lit: text, pos: start, value: num}, nil
+	return token{typ: tokNumber, lit: text, pos: start, value: n}, nil
 }
 
 func (l *lexer) scanIdent() (token, error) {
@@ -612,22 +616,20 @@ func compareValues(op tokenType, left any, right any) (bool, error) {
 		}
 	}
 
-	ln, lok := asNumber(left)
-	rn, rok := asNumber(right)
-	if lok && rok {
+	if cmp, ok := utils.CompareNumeric(left, right); ok {
 		switch op {
 		case tokEq:
-			return ln == rn, nil
+			return cmp == 0, nil
 		case tokNeq:
-			return ln != rn, nil
+			return cmp != 0, nil
 		case tokLt:
-			return ln < rn, nil
+			return cmp < 0, nil
 		case tokLte:
-			return ln <= rn, nil
+			return cmp <= 0, nil
 		case tokGt:
-			return ln > rn, nil
+			return cmp > 0, nil
 		case tokGte:
-			return ln >= rn, nil
+			return cmp >= 0, nil
 		default:
 			return false, fmt.Errorf("unsupported numeric operator %v", op)
 		}
@@ -670,33 +672,3 @@ func compareValues(op tokenType, left any, right any) (bool, error) {
 	return false, fmt.Errorf("cannot compare values of different or unsupported types (%T vs %T)", left, right)
 }
 
-func asNumber(v any) (float64, bool) {
-	switch n := v.(type) {
-	case int:
-		return float64(n), true
-	case int8:
-		return float64(n), true
-	case int16:
-		return float64(n), true
-	case int32:
-		return float64(n), true
-	case int64:
-		return float64(n), true
-	case uint:
-		return float64(n), true
-	case uint8:
-		return float64(n), true
-	case uint16:
-		return float64(n), true
-	case uint32:
-		return float64(n), true
-	case uint64:
-		return float64(n), true
-	case float32:
-		return float64(n), true
-	case float64:
-		return n, true
-	default:
-		return 0, false
-	}
-}

internal/consistency/repair/table_repair.go

@@ -2258,6 +2258,13 @@ func extractOriginInfoFromRow(row types.OrderedMap) *rowOriginInfo {
 			ts = parseNumericTimestamp(int64(v))
 		case float64:
 			ts = parseNumericTimestamp(int64(v))
+		case json.Number:
+			if i64, err := v.Int64(); err == nil {
+				ts = parseNumericTimestamp(i64)
+			} else {
+				logger.Warn("extractOriginInfoFromRow: failed to parse json.Number commit_ts %q: %v", v.String(), err)
+				return nil
+			}
 		default:
 			logger.Warn("extractOriginInfoFromRow: unhandled commit_ts type %T, skipping origin preservation", tsVal)
 			return nil