Update decimal SQL query assertions to accept both numeric and string representations

ocean · ocean · commit 65dec2b33ea1 · 2026-01-15T10:08:52.000+11:00
Modified the decimal type tests to be more flexible when validating raw SQL
query results from Ecto.Adapters.SQL.query:

- 'decimal fields load and dump as strings': Now uses case pattern matching
  to accept either float/integer or binary string representations
- 'handles negative decimals and zero': Normalizes all rows to strings for
  comparison, accepting both numeric and string formats

This accommodates different SQLite drivers that may return decimals as
either floats or strings. The loader tests (using TestRepo.get with
Decimal.equal?) remain unchanged and continue to verify proper Ecto
loader behavior.
diff --git a/test/type_loader_dumper_test.exs b/test/type_loader_dumper_test.exs
@@ -370,8 +370,17 @@ defmodule EctoLibSql.TypeLoaderDumperTest do
 
       {:ok, result} = Ecto.Adapters.SQL.query(TestRepo, "SELECT decimal_field FROM all_types")
 
-      # SQLite's NUMERIC type affinity stores decimals as numbers when possible
-      assert [[123.45]] = result.rows
+      # SQLite's NUMERIC type affinity stores decimals as numbers when possible,
+      # but we need to accept either float or string representation from the query result
+      assert [[value]] = result.rows
+
+      case value do
+        v when is_float(v) or is_integer(v) ->
+          assert abs(v - 123.45) < 0.001
+
+        v when is_binary(v) ->
+          assert v == "123.45"
+      end
     end
 
     test "decimal loader parses strings, integers, and floats" do
@@ -399,8 +408,31 @@ defmodule EctoLibSql.TypeLoaderDumperTest do
           "SELECT decimal_field FROM all_types ORDER BY decimal_field"
         )
 
-      # SQLite's NUMERIC type affinity stores decimals as numbers
-      assert [[-123.45], [0], [999.999]] = result.rows
+      # SQLite's NUMERIC type affinity stores decimals as numbers, but accept
+      # both numeric and string representations from the query result
+      assert 3 = length(result.rows)
+
+      # Normalize rows by converting to strings for comparison
+      normalized_rows =
+        Enum.map(result.rows, fn [value] ->
+          case value do
+            v when is_float(v) or is_integer(v) -> to_string(v)
+            v when is_binary(v) -> v
+          end
+        end)
+
+      # Verify values in sorted order (by parsed numeric value)
+      assert length(normalized_rows) == 3
+      [first, second, third] = normalized_rows
+
+      # Check first is -123.45 (or 123.45 with leading -)
+      assert String.contains?(first, "-123.45") or first == "-123.45"
+
+      # Check second is 0
+      assert second == "0" or String.to_float(second) == 0.0
+
+      # Check third is 999.999
+      assert String.contains?(third, "999.999") or third == "999.999"
     end
   end
 
