fix(eval): normalise Decimal to float — Postgres numeric scored as a miss

psycopg returns `numeric` — every AVG, SUM and division — as `Decimal`; SQLite
returns float. `_hashable` quantised only floats onto the tolerance grid and let
Decimal through untouched, so a correct answer of Decimal('1.3070996799810359')
never landed in the same bucket as gold 1.307099679981036 and was scored wrong.

`_normalise_row`'s docstring has always claimed "Decimal → float"; the line was
simply never there. The cost was 4 EA points on the Postgres run (40.8% → 49.0%)
— a comparator bug being read as model error. Invisible on SQLite, which never
hands back a Decimal.

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

Author: JuliaEdom

src/nl_sql/eval/metrics/execution_accuracy.py

@@ -23,6 +23,7 @@
 import re
 from collections.abc import Sequence
 from dataclasses import dataclass
+from decimal import Decimal
 from typing import Any
 
 _FLOAT_TOLERANCE = 1e-6
@@ -177,6 +178,14 @@ def _normalise_cell(value: Any) -> Any:
         return value
     if isinstance(value, int):
         return value
+    if isinstance(value, Decimal):
+        # Postgres hands back numeric — AVG, SUM, any division — as Decimal, while
+        # SQLite hands back float. Left as Decimal it skips the float tolerance
+        # grid in `_hashable`, so a correct answer that differs from gold in the
+        # 16th decimal lands in a different bucket and scores a miss. This line is
+        # what the docstring above always claimed; it was never actually here, and
+        # every Postgres ratio/average question paid for it.
+        return float(value)
     if isinstance(value, float):
         # NaN compares unequal to itself; map all NaN to a sentinel so two
         # NaN rows from the same query compare equal.

tests/eval/test_metrics.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+from decimal import Decimal
+
 from nl_sql.eval.metrics.execution_accuracy import (
     compare_results,
     execution_accuracy,
@@ -124,6 +126,31 @@ def test_float_outside_tolerance_fails(self) -> None:
         c = compare_results(gold, pred, gold_sql="SELECT x FROM t ORDER BY x")
         assert not c.match
 
+    def test_decimal_compares_equal_to_the_same_number_as_float(self) -> None:
+        """Postgres returns numeric (AVG, SUM, division) as Decimal; SQLite as float.
+
+        A correct Postgres answer and BIRD's gold therefore come back as
+        Decimal('1.3070996799810359') vs 1.307099679981036 — the same number to
+        1e-16. The set path quantised the float onto the tolerance grid but let
+        the Decimal through untouched, so the two never landed in the same
+        bucket and a correct answer scored a miss. That silently deflated every
+        Postgres run computing a ratio or an average (seen on BIRD qids 629
+        "ratio of votes in 2010 and 2011" and 598 "percentage difference").
+        """
+        gold = [(1.307099679981036,)]
+        pred = [(Decimal("1.3070996799810359"),)]
+
+        assert compare_results(gold, pred, gold_sql="SELECT ratio FROM t").match
+        assert compare_results(gold, pred, gold_sql="SELECT ratio FROM t ORDER BY 1").match
+
+    def test_decimal_outside_tolerance_still_fails(self) -> None:
+        """The Decimal path must not become a blanket pass — 1.0 vs 1.001 is wrong."""
+        gold = [(1.0,)]
+        pred = [(Decimal("1.001"),)]
+
+        assert not compare_results(gold, pred, gold_sql="SELECT x FROM t").match
+        assert not compare_results(gold, pred, gold_sql="SELECT x FROM t ORDER BY 1").match
+
     def test_bytes_decoded_as_utf8(self) -> None:
         gold = [("hello",)]
         pred = [(b"hello",)]