Say "type not supported" when no adapter ran for a bind param

Binding a value of an unsupported type with no registered adapter and no
__conform__ hook (e.g. Decimal) raised a DataError claiming "adapter for
X produced non-primitive X" — but no adapter ever ran, so the message
sent operators hunting for a buggy adapter that does not exist. Track
whether an adapter or __conform__ actually transformed the value and emit
"type X is not supported" in the no-transform case (mirroring stdlib),
reserving the "adapter for X produced ..." wording for a real adapter
that returned a non-primitive. The DataError class is unchanged.

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

Author: antoineleclair

src/dqlitedbapi/types.py

@@ -1055,8 +1055,14 @@ def _convert_bind_param(value: Any) -> Any:
     # ``sqlite3.register_adapter``.
     original_type = type(value)
     adapter = _ADAPTERS.get(original_type)
+    # Track whether an adapter or ``__conform__`` actually transformed the
+    # value, so the post-chain validation below can tell "a registered
+    # adapter returned a non-primitive" apart from "no adapter exists for
+    # this type" and emit an accurate diagnostic for each.
+    transformed = False
     if adapter is not None:
         value = adapter(value)
+        transformed = True
     else:
         # Stdlib parity: fall back to the value's ``__conform__``
         # hook with ``PrepareProtocol`` as the requested protocol
@@ -1108,6 +1114,7 @@ def _convert_bind_param(value: Any) -> Any:
                 raise
             if adapted is not None:
                 value = adapted
+                transformed = True
     # ``datetime.datetime`` is a subclass of ``datetime.date`` but not
     # of ``datetime.time``, so the datetime/date check must fire first
     # for datetime inputs. ``datetime.time`` falls through to its own
@@ -1130,11 +1137,24 @@ def _convert_bind_param(value: Any) -> Any:
     # the diagnostic clarity is the substantive improvement, not the
     # class flip.
     if not isinstance(value, _WIRE_PRIMITIVES):
+        if transformed:
+            # A registered adapter (or ``__conform__``) ran and returned a
+            # non-wire-primitive — name both the input type and the
+            # adapter-produced type so the operator can fix the adapter.
+            raise DataError(
+                f"adapter for {original_type.__name__} produced "
+                f"non-primitive {type(value).__name__}; wire layer accepts "
+                f"only int / float / str / bytes / bytearray / memoryview / "
+                f"bool / None. Register an adapter that returns one of those."
+            )
+        # No adapter / ``__conform__`` for this type — the value was never
+        # transformed. Say so plainly (mirroring stdlib's "type X is not
+        # supported") rather than blaming a non-existent adapter.
         raise DataError(
-            f"adapter for {original_type.__name__} produced "
-            f"non-primitive {type(value).__name__}; wire layer accepts "
-            f"only int / float / str / bytes / bytearray / memoryview / "
-            f"bool / None. Register an adapter that returns one of those."
+            f"type {original_type.__name__} is not supported; wire layer "
+            f"accepts only int / float / str / bytes / bytearray / "
+            f"memoryview / bool / None. Register an adapter that returns "
+            f"one of those."
         )
     # Pre-wire NUL guard: dqlite's wire TEXT is NUL-terminated UTF-8
     # (see ``dqlitewire.encode_text``), so embedded NULs cannot

tests/test_convert_bind_param_unsupported_vs_bad_adapter_message.py

@@ -0,0 +1,48 @@
+"""``_convert_bind_param`` distinguishes "no adapter for this type" from
+"a registered adapter returned a non-primitive" in its ``DataError``
+diagnostic.
+
+A value of an unsupported type with no registered adapter (e.g.
+``Decimal``) was never transformed, so the error must say the type is
+not supported — NOT falsely claim an adapter ran and misbehaved
+(which would send an operator hunting for a non-existent adapter). The
+"adapter for X produced non-primitive" wording is reserved for the case
+where a real registered adapter (or ``__conform__``) actually returned a
+non-wire-primitive. Both wordings keep the ``DataError`` class (a prior
+intentional pin); only the message text differs.
+"""
+
+from __future__ import annotations
+
+from decimal import Decimal
+
+import pytest
+
+from dqlitedbapi import DataError, register_adapter, unregister_adapter
+from dqlitedbapi.types import _convert_bind_param
+
+
+def test_unsupported_type_with_no_adapter_says_not_supported() -> None:
+    with pytest.raises(DataError) as exc:
+        _convert_bind_param(Decimal("1.5"))
+    msg = str(exc.value)
+    assert "is not supported" in msg
+    # Must NOT falsely blame an adapter that never ran.
+    assert "adapter for" not in msg
+    assert "produced" not in msg
+
+
+def test_registered_adapter_returning_non_primitive_blames_the_adapter() -> None:
+    class _Custom:
+        pass
+
+    # A genuinely registered adapter that returns a non-wire-primitive.
+    register_adapter(_Custom, lambda _v: ["not", "primitive"])
+    try:
+        with pytest.raises(DataError) as exc:
+            _convert_bind_param(_Custom())
+    finally:
+        unregister_adapter(_Custom)
+    msg = str(exc.value)
+    assert "adapter for _Custom produced" in msg
+    assert "non-primitive list" in msg

tests/test_convert_params_async_cooperative_yield.py

@@ -131,15 +131,17 @@ def __conform__(self, _protocol: object) -> object:
 
 
 @pytest.mark.asyncio
-async def test_convert_params_async_adapter_failure_wraps_as_data_error() -> None:
-    """Exception parity: a documented adapter-misuse failure still wraps
-    as ``DataError`` on the async path."""
+async def test_convert_params_async_unsupported_type_wraps_as_data_error() -> None:
+    """Exception parity: an unsupported type (a None-returning
+    ``__conform__`` declines adaptation, so no adapter runs) wraps as
+    ``DataError`` with the "type X is not supported" diagnostic on the
+    async path — not the "adapter for X produced ..." wording."""
 
     class WithFailingConform:
         def __conform__(self, _protocol: object) -> object:
             return None
 
-    with pytest.raises(DataError, match="adapter for"):
+    with pytest.raises(DataError, match="is not supported"):
         await cursor_mod._convert_params_async([WithFailingConform()])
 
 

tests/test_convert_params_conform_raise_propagates_unwrapped.py

@@ -74,8 +74,11 @@ def __conform__(self, _protocol: object) -> object:
             # then falls back to its own checks.
             return None
 
-    # An unknown type with a None-returning conform forces the
-    # fallback adapter chain to ultimately raise TypeError, which
-    # the new narrow arm still wraps.
-    with pytest.raises(DataError, match="adapter for"):
+    # A None-returning ``__conform__`` declines adaptation, so no
+    # transform runs and the value reaches the post-chain check as an
+    # unsupported type — wrapped as ``DataError`` with the "type X is
+    # not supported" diagnostic (NOT the "adapter for X produced ..."
+    # wording, which is reserved for a real adapter returning a
+    # non-primitive).
+    with pytest.raises(DataError, match="is not supported"):
         _convert_params([WithFailingConform()])