sqlalchemy-dqlite 0.2.0__tar.gz → 0.2.1__tar.gz

{sqlalchemy_dqlite-0.2.0 → sqlalchemy_dqlite-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlalchemy-dqlite
-Version: 0.2.0
+Version: 0.2.1
 Summary: SQLAlchemy 2.0 dialect for dqlite distributed SQLite
 Project-URL: Homepage, https://github.com/letsdiscodev/sqlalchemy-dqlite
 Project-URL: Repository, https://github.com/letsdiscodev/sqlalchemy-dqlite
@@ -22,9 +22,9 @@ Classifier: Topic :: Database :: Database Engines/Servers
 Classifier: Topic :: Database :: Front-Ends
 Classifier: Typing :: Typed
 Requires-Python: >=3.13
-Requires-Dist: dqlite-client<0.3.0,>=0.2.0
-Requires-Dist: dqlite-dbapi<0.3.0,>=0.2.0
-Requires-Dist: dqlite-wire<0.3.0,>=0.2.0
+Requires-Dist: dqlite-client<0.3.0,>=0.2.1
+Requires-Dist: dqlite-dbapi<0.3.0,>=0.2.1
+Requires-Dist: dqlite-wire<0.3.0,>=0.2.1
 Requires-Dist: sqlalchemy<3.0,>=2.0
 Provides-Extra: dev
 Requires-Dist: mypy>=1.0; extra == 'dev'

{sqlalchemy_dqlite-0.2.0 → sqlalchemy_dqlite-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlalchemy-dqlite"
-version = "0.2.0"
+version = "0.2.1"
 description = "SQLAlchemy 2.0 dialect for dqlite distributed SQLite"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -26,15 +26,15 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "dqlite-dbapi>=0.2.0,<0.3.0",
+    "dqlite-dbapi>=0.2.1,<0.3.0",
     # The SA dialect imports dqliteclient and dqlitewire directly
     # (base.py / aio.py reach into client exception classes for
     # is_disconnect, and into dqlitewire for shared helpers). Pin
     # both transitively so a future major-version bump in either
     # package surfaces at install time, not at module-import time
     # in user code.
-    "dqlite-client>=0.2.0,<0.3.0",
-    "dqlite-wire>=0.2.0,<0.3.0",
+    "dqlite-client>=0.2.1,<0.3.0",
+    "dqlite-wire>=0.2.1,<0.3.0",
     "sqlalchemy>=2.0,<3.0",
 ]
 

{sqlalchemy_dqlite-0.2.0 → sqlalchemy_dqlite-0.2.1}/src/sqlalchemydqlite/__init__.py

@@ -27,7 +27,7 @@ from sqlalchemy.dialects.sqlite import (
 from sqlalchemydqlite.aio import DqliteDialect_aio
 from sqlalchemydqlite.base import DqliteCompiler, DqliteDialect
 
-__version__: _Final[str] = "0.2.0"
+__version__: _Final[str] = "0.2.1"
 
 # SA convention (every shipped dialect package — sqlite, mysql, mssql,
 # oracle, postgresql): expose ``<package>.dialect`` pointing at the

{sqlalchemy_dqlite-0.2.0 → sqlalchemy_dqlite-0.2.1}/src/sqlalchemydqlite/base.py

@@ -1515,6 +1515,27 @@ class DqliteDialect(SQLiteDialect_pysqlite):
             # always a typo, so it stays out of ``_URL_QUERY_ALLOWED``
             # below.
             "dial_func",
+            # ``busy_timeout`` (seconds, float) — stdlib sqlite3
+            # parity. Default ``5.0`` matches sqlite3's C-library
+            # default; SA users can override via
+            # ``create_engine(connect_args={"busy_timeout": 30.0})``
+            # or via the URL form ``?busy_timeout=30.0``. Forwards
+            # to ``dqlitedbapi.connect()`` which validates the
+            # value (non-negative finite number, non-bool).
+            "busy_timeout",
+            # ``check_same_thread`` (bool) — stdlib sqlite3 parity.
+            # Default ``True`` (dbapi side); set ``False`` to share
+            # a Connection across threads. The dialect pins
+            # ``pool.QueuePool``; SA's QueuePool checkout/checkin
+            # plus the ``_finalize_fairy`` weakref-finalizer (which
+            # runs from arbitrary GC threads) both produce cross-
+            # thread Connection access patterns. The pool self-
+            # heals via ``force_close_transport`` (no _check_thread)
+            # even today, but the GC-finalize raise produces a noisy
+            # ``logger.error("Exception during reset or similar")``
+            # line; passing ``check_same_thread=False`` quiets that
+            # and matches the established SA + sqlite3 pattern.
+            "check_same_thread",
         }
     )
 
@@ -1605,6 +1626,34 @@ class DqliteDialect(SQLiteDialect_pysqlite):
         # timeout floor's rationale does not apply.
         "dial_timeout": (float, _validate_dial_timeout_url),
         "attempt_timeout": (float, _validate_attempt_timeout_url),
+        # ``busy_timeout`` (seconds, float) — stdlib sqlite3 parity.
+        # Validator mirrors the dbapi-side ``Connection.__init__``
+        # check: non-negative (zero accepted, meaning "no retry"),
+        # finite, non-bool. The URL converter is ``float`` (per
+        # the same shape as ``timeout`` / ``close_timeout``); the
+        # validator's accept criterion is the canonical floor
+        # because connect_args= bypasses the converter.
+        "busy_timeout": (
+            float,
+            lambda v: (
+                not isinstance(v, bool)
+                and isinstance(v, int | float)
+                and math.isfinite(v)
+                and v >= 0
+            ),
+        ),
+        # ``check_same_thread`` (bool) — stdlib sqlite3 parity. The
+        # URL parser uses ``_parse_url_bool`` (same as
+        # ``trust_server_heartbeat``) to accept ``true``/``false``/
+        # ``1``/``0``/``yes``/``no`` case-insensitive. The
+        # validator gate on the connect_args= path requires strict
+        # bool (rejecting int 0/1 explicitly because
+        # ``isinstance(True, int)`` is True and the dbapi-side
+        # strict-bool validation would otherwise silently re-fire).
+        "check_same_thread": (
+            lambda s: _parse_url_bool("check_same_thread", s),
+            lambda v: isinstance(v, bool),
+        ),
     }
 
     def create_connect_args(self, url: URL) -> tuple[list[Any], dict[str, Any]]:
@@ -2646,7 +2695,29 @@ class DqliteDialect(SQLiteDialect_pysqlite):
                 # silently activate disconnect classification on
                 # caller bugs. ``type is`` makes the scope explicit
                 # and matches the docstring intent above.
-                applies_substring = getattr(cause, "code", None) in _BARE_DBE_DISCONNECT_CODES
+                if getattr(cause, "code", None) in _BARE_DBE_DISCONNECT_CODES:
+                    # Short-circuit ``return True`` mirrors ``do_ping``'s
+                    # classification at base.py:2935-2945. A bare
+                    # DatabaseError under one of the slot-fatal codes
+                    # IS slot-fatal regardless of the message text —
+                    # the substring scan exists for the
+                    # ``OperationalError`` arm above where ``code`` is
+                    # None and the message IS the load-bearing
+                    # classification signal. The canonical engine
+                    # wordings for CORRUPT / FORMAT / NOTADB
+                    # ("database disk image is malformed", "file is
+                    # not a database", "file is encrypted or is not a
+                    # database") are NOT in ``_dqlite_disconnect_
+                    # messages`` by design — those messages are caller
+                    # diagnostics, not transport-state signals. Without
+                    # this short-circuit, ``is_disconnect`` returned
+                    # False on a real CORRUPT response, SA's pool
+                    # returned the slot to the queue, and every
+                    # subsequent checkout re-tripped the same fault.
+                    # ``_BARE_DBE_DISCONNECT_CODES`` is the SSOT both
+                    # classifiers gate on.
+                    return True
+                applies_substring = False
             elif isinstance(cause, _dbapi_exc.InterfaceError):
                 # The dedicated-phrase arm at the top of this loop
                 # (lines 2461-2539) already handles the

sqlalchemy_dqlite-0.2.1/tests/test_busy_timeout_url_and_connect_args.py

@@ -0,0 +1,138 @@
+"""Pin: ``busy_timeout`` works via both URL query and connect_args=
+on the SA dialect, forwarding to the dbapi layer.
+
+The dbapi-side feature defaults ``busy_timeout=5.0`` (stdlib parity);
+SA-side users tune via:
+
+  - URL: ``dqlite://host:9001/db?busy_timeout=30.0``
+  - connect_args: ``create_engine(..., connect_args={"busy_timeout": 30.0})``
+
+Both routes go through the dialect's ``create_connect_args`` /
+allowlist machinery and end up as a kwarg on ``dqlitedbapi.connect``.
+
+Validation:
+- Negative / non-finite / non-numeric values raise ``ArgumentError`` at
+  URL-parse or first-checkout time (NOT at runtime when the contended
+  write hits BUSY).
+- bool is rejected (would silently coerce True→1.0).
+- Zero is accepted (stdlib parity — "no retry").
+"""
+
+from __future__ import annotations
+
+import pytest
+from sqlalchemy import create_engine
+from sqlalchemy.engine import URL
+from sqlalchemy.exc import ArgumentError
+
+from sqlalchemydqlite.base import DqliteDialect
+
+
+def test_url_query_busy_timeout_forwards_to_connect_kwargs() -> None:
+    """``?busy_timeout=30.0`` in the URL ends up in the dialect's
+    connect kwargs."""
+    url = URL.create(
+        "dqlite",
+        host="localhost",
+        port=9001,
+        database="default",
+        query={"busy_timeout": "30.0"},
+    )
+    dialect = DqliteDialect()
+    _args, kwargs = dialect.create_connect_args(url)
+    assert kwargs.get("busy_timeout") == 30.0
+
+
+def test_url_query_busy_timeout_zero_accepted() -> None:
+    """``?busy_timeout=0`` is the canonical "no retry" — must be
+    accepted at URL-parse time (stdlib parity for timeout=0)."""
+    url = URL.create(
+        "dqlite",
+        host="localhost",
+        port=9001,
+        database="default",
+        query={"busy_timeout": "0"},
+    )
+    dialect = DqliteDialect()
+    _args, kwargs = dialect.create_connect_args(url)
+    assert kwargs.get("busy_timeout") == 0.0
+
+
+def test_url_query_busy_timeout_negative_rejected() -> None:
+    """Negative values are rejected at URL-parse time as
+    ``ArgumentError`` (not at first-checkout time)."""
+    url = URL.create(
+        "dqlite",
+        host="localhost",
+        port=9001,
+        database="default",
+        query={"busy_timeout": "-1"},
+    )
+    dialect = DqliteDialect()
+    with pytest.raises(ArgumentError):
+        dialect.create_connect_args(url)
+
+
+def test_url_query_busy_timeout_non_numeric_rejected() -> None:
+    """``?busy_timeout=abc`` raises at URL-parse time (the URL
+    converter is ``float`` and rejects non-numeric strings)."""
+    url = URL.create(
+        "dqlite",
+        host="localhost",
+        port=9001,
+        database="default",
+        query={"busy_timeout": "abc"},
+    )
+    dialect = DqliteDialect()
+    with pytest.raises(ArgumentError):
+        dialect.create_connect_args(url)
+
+
+def test_connect_args_busy_timeout_accepted() -> None:
+    """``create_engine(..., connect_args={"busy_timeout": N})`` works
+    — the kwarg is in the allowlist."""
+    engine = create_engine(
+        "dqlite://localhost:9001/default",
+        connect_args={"busy_timeout": 30.0},
+    )
+    # Engine construction must succeed without ArgumentError. We can't
+    # actually connect (no server) — the kwarg validation happens at
+    # first checkout / dispose. The fact that create_engine returned
+    # without raising means the dialect accepted the kwarg.
+    assert engine is not None
+    engine.dispose()
+
+
+def test_connect_args_busy_timeout_zero_accepted() -> None:
+    """Zero accepted via connect_args= same as URL."""
+    engine = create_engine(
+        "dqlite://localhost:9001/default",
+        connect_args={"busy_timeout": 0.0},
+    )
+    assert engine is not None
+    engine.dispose()
+
+
+def test_connect_args_busy_timeout_negative_rejected() -> None:
+    """Negative busy_timeout in connect_args= is rejected. The
+    validator runs at first connection-arg merge (in the dialect's
+    connect() override)."""
+    engine = create_engine(
+        "dqlite://localhost:9001/default",
+        connect_args={"busy_timeout": -1.0},
+    )
+    # The allowlist's validator runs at first checkout time.
+    with pytest.raises(ArgumentError):
+        engine.connect()
+    engine.dispose()
+
+
+def test_connect_args_busy_timeout_bool_rejected() -> None:
+    """bool is rejected (would silently coerce True→1.0)."""
+    engine = create_engine(
+        "dqlite://localhost:9001/default",
+        connect_args={"busy_timeout": True},
+    )
+    with pytest.raises(ArgumentError):
+        engine.connect()
+    engine.dispose()

sqlalchemy_dqlite-0.2.1/tests/test_check_same_thread_url_and_connect_args.py

@@ -0,0 +1,177 @@
+"""Pin: SA dialect accepts ``check_same_thread`` via both the URL
+query string and the ``connect_args=`` kwarg on
+``create_engine()``, forwarding to ``dqlitedbapi.connect()``.
+
+Stdlib sqlite3 parity. SA users porting from sqlite use:
+
+    create_engine(
+        "sqlite:///app.db",
+        connect_args={"check_same_thread": False},
+    )
+
+The same incantation against dqlite now works:
+
+    create_engine(
+        "dqlite://node:9001/default",
+        connect_args={"check_same_thread": False},
+    )
+
+Plus the URL form:
+
+    create_engine("dqlite://node:9001/default?check_same_thread=false")
+
+Pinned behaviours:
+- Both surfaces (URL + connect_args) reach the dbapi connect kwarg.
+- Boolean parsing via URL accepts the standard tokens.
+- Validation gates: bool required on connect_args; URL parser
+  rejects unknown tokens.
+- The aio dialect rejects the kwarg via the dbapi-layer sync-only
+  message (the aio surface is loop-bound).
+"""
+
+from __future__ import annotations
+
+import pytest
+from sqlalchemy import create_engine
+from sqlalchemy.engine import URL
+from sqlalchemy.exc import ArgumentError
+
+from sqlalchemydqlite.base import DqliteDialect
+
+
+def test_url_query_check_same_thread_false_forwards_to_kwargs() -> None:
+    """``?check_same_thread=false`` parses to the kwarg."""
+    url = URL.create(
+        "dqlite",
+        host="localhost",
+        port=9001,
+        database="default",
+        query={"check_same_thread": "false"},
+    )
+    dialect = DqliteDialect()
+    _args, kwargs = dialect.create_connect_args(url)
+    assert kwargs.get("check_same_thread") is False
+
+
+def test_url_query_check_same_thread_true_forwards_to_kwargs() -> None:
+    """``?check_same_thread=true`` parses to the kwarg."""
+    url = URL.create(
+        "dqlite",
+        host="localhost",
+        port=9001,
+        database="default",
+        query={"check_same_thread": "true"},
+    )
+    dialect = DqliteDialect()
+    _args, kwargs = dialect.create_connect_args(url)
+    assert kwargs.get("check_same_thread") is True
+
+
+@pytest.mark.parametrize(
+    "token,expected",
+    [
+        ("true", True),
+        ("True", True),
+        ("TRUE", True),
+        ("1", True),
+        ("yes", True),
+        ("false", False),
+        ("False", False),
+        ("FALSE", False),
+        ("0", False),
+        ("no", False),
+    ],
+)
+def test_url_query_bool_tokens_accepted(token: str, expected: bool) -> None:
+    """The URL bool parser accepts the standard token set
+    case-insensitively, same shape as the ``trust_server_heartbeat``
+    URL knob (which uses the same ``_parse_url_bool`` helper)."""
+    url = URL.create(
+        "dqlite",
+        host="localhost",
+        port=9001,
+        database="default",
+        query={"check_same_thread": token},
+    )
+    dialect = DqliteDialect()
+    _args, kwargs = dialect.create_connect_args(url)
+    assert kwargs.get("check_same_thread") is expected
+
+
+def test_url_query_invalid_token_rejected() -> None:
+    """``?check_same_thread=notabool`` raises at URL-parse time."""
+    url = URL.create(
+        "dqlite",
+        host="localhost",
+        port=9001,
+        database="default",
+        query={"check_same_thread": "notabool"},
+    )
+    dialect = DqliteDialect()
+    with pytest.raises(ArgumentError):
+        dialect.create_connect_args(url)
+
+
+def test_connect_args_check_same_thread_false_accepted() -> None:
+    """``connect_args={"check_same_thread": False}`` works — the
+    canonical SA + sqlite incantation transparently ports to
+    dqlite."""
+    engine = create_engine(
+        "dqlite://localhost:9001/default",
+        connect_args={"check_same_thread": False},
+    )
+    # Engine construction succeeds without ArgumentError. We can't
+    # actually connect (no server) — the kwarg validation happens
+    # at first checkout.
+    assert engine is not None
+    engine.dispose()
+
+
+def test_connect_args_check_same_thread_true_accepted() -> None:
+    """Explicit ``True`` also works (no-op vs default)."""
+    engine = create_engine(
+        "dqlite://localhost:9001/default",
+        connect_args={"check_same_thread": True},
+    )
+    assert engine is not None
+    engine.dispose()
+
+
+def test_connect_args_check_same_thread_rejects_int_zero() -> None:
+    """Strict bool: ``0`` is not ``False`` for this kwarg
+    (mirrors the dbapi-side strict-bool validation)."""
+    engine = create_engine(
+        "dqlite://localhost:9001/default",
+        connect_args={"check_same_thread": 0},
+    )
+    with pytest.raises(ArgumentError):
+        engine.connect()
+    engine.dispose()
+
+
+def test_connect_args_check_same_thread_rejects_string() -> None:
+    """Strict bool: string ``"false"`` rejected via the dbapi
+    surface (the SA validator catches non-bool too)."""
+    engine = create_engine(
+        "dqlite://localhost:9001/default",
+        connect_args={"check_same_thread": "false"},
+    )
+    with pytest.raises(ArgumentError):
+        engine.connect()
+    engine.dispose()
+
+
+def test_url_query_combined_with_other_knobs() -> None:
+    """Combine check_same_thread with other URL knobs (busy_timeout)
+    to confirm they don't interfere."""
+    url = URL.create(
+        "dqlite",
+        host="localhost",
+        port=9001,
+        database="default",
+        query={"check_same_thread": "false", "busy_timeout": "10.0"},
+    )
+    dialect = DqliteDialect()
+    _args, kwargs = dialect.create_connect_args(url)
+    assert kwargs.get("check_same_thread") is False
+    assert kwargs.get("busy_timeout") == 10.0

{sqlalchemy_dqlite-0.2.0 → sqlalchemy_dqlite-0.2.1}/tests/test_dialect.py

@@ -315,7 +315,12 @@ class TestDqliteDialectAio:
         """Async dbapi module must expose PEP 249 attributes for SQLAlchemy."""
         dbapi = DqliteDialect_aio.import_dbapi()
         assert dbapi.apilevel == "2.0"
-        assert dbapi.threadsafety == 1
+        # threadsafety=2 = "threads may share the module AND
+        # connections" — the dbapi opts into Tier 2 once the user
+        # passes ``check_same_thread=False``. Cursors are NOT
+        # shareable per the documented contract. See
+        # ``dqlitedbapi.__init__:108-149`` for the full rationale.
+        assert dbapi.threadsafety == 2
 
     def test_create_async_engine(self) -> None:
         """create_async_engine must not raise during dialect initialization."""

{sqlalchemy_dqlite-0.2.0 → sqlalchemy_dqlite-0.2.1}/tests/test_is_disconnect_bare_databaseerror_type_identity.py

@@ -96,20 +96,27 @@ def test_bare_databaseerror_with_disconnect_code_and_substring_does_classify(
     code: int,
 ) -> None:
     """Sanity: a BARE ``DatabaseError`` (not a subclass) with a code in
-    ``_BARE_DBE_DISCONNECT_CODES`` and a disconnect-style message DOES
-    classify as disconnect — pin the type-identity arm's positive
-    side too."""
+    ``_BARE_DBE_DISCONNECT_CODES`` classifies as disconnect — pin the
+    type-identity arm's positive side. After the substring-gate fix,
+    the disconnect-style message is no longer required (mirrors
+    do_ping's code-only classification)."""
     exc = DatabaseError("wire decode failed validation", code=code)
     dialect = _dialect()
     assert dialect.is_disconnect(exc, None, None) is True
 
 
 @pytest.mark.parametrize("code", list(_BARE_DBE_DISCONNECT_CODES))
-def test_bare_databaseerror_with_disconnect_code_no_substring_does_not_classify(
+def test_bare_databaseerror_with_disconnect_code_classifies_regardless_of_message(
     code: int,
 ) -> None:
-    """Sanity: bare ``DatabaseError`` with disconnect code but a
-    non-matching message does NOT classify (substring is required)."""
+    """Sanity: bare ``DatabaseError`` with disconnect code classifies
+    as disconnect regardless of message — the code is the load-bearing
+    signal. Pre-fix this returned False (the substring gate blocked
+    classification on the canonical engine wordings); post-fix it
+    short-circuits ``return True`` mirroring ``do_ping``'s arm at
+    base.py:2935-2945. See
+    ``test_is_disconnect_bare_dbe_short_circuits_on_slot_fatal_codes.py``
+    for the full parametrised coverage."""
     exc = DatabaseError("some unrelated server message", code=code)
     dialect = _dialect()
-    assert dialect.is_disconnect(exc, None, None) is False
+    assert dialect.is_disconnect(exc, None, None) is True

sqlalchemy_dqlite-0.2.1/tests/test_is_disconnect_bare_dbe_short_circuits_on_slot_fatal_codes.py

@@ -0,0 +1,115 @@
+"""Pin: ``is_disconnect``'s bare-``DatabaseError`` arm short-circuits
+``return True`` for codes in ``_BARE_DBE_DISCONNECT_CODES``
+(SQLITE_CORRUPT=11, SQLITE_FORMAT=24, SQLITE_NOTADB=26), regardless
+of the message text. Mirrors ``do_ping``'s classification (base.py:
+2935-2945).
+
+Before the fix, the bare-``DatabaseError`` arm set
+``applies_substring = True`` and then routed through the same
+substring scan used for the ``OperationalError`` arm. The substring
+list (``_dqlite_disconnect_messages``) contains transport-state
+phrases ("connection closed", "wire decode failed", "timed out",
+"failed to connect", ...) but NONE of the canonical engine wordings
+for the three slot-fatal codes:
+
+  - SQLITE_CORRUPT (11) → "database disk image is malformed"
+  - SQLITE_NOTADB (26) → "file is not a database"
+  - SQLITE_FORMAT (24) → "unsupported file format" / "file is
+    encrypted or is not a database"
+
+So a real CORRUPT response from the engine returned False from
+``is_disconnect``, SA's pool returned the slot to the queue, and
+the next checkout reused the same slot — re-tripping the same
+fault on every subsequent query. The companion ``do_ping`` arm
+correctly short-circuits ``return False`` for the same code set
+WITHOUT a substring filter; this restores parity.
+
+This is a HIGH-severity silent data-correctness hazard for any
+user running without ``pool_pre_ping=True``.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from dqlitedbapi.exceptions import DatabaseError
+from dqlitewire.constants import SQLITE_CORRUPT, SQLITE_FORMAT, SQLITE_NOTADB
+from sqlalchemydqlite.base import DqliteDialect
+
+
+@pytest.mark.parametrize(
+    "code,message",
+    [
+        (SQLITE_CORRUPT, "database disk image is malformed"),
+        (SQLITE_NOTADB, "file is not a database"),
+        (SQLITE_FORMAT, "unsupported file format"),
+        (SQLITE_FORMAT, "file is encrypted or is not a database"),
+        # Hostile-control: message that explicitly avoids any
+        # substring in _dqlite_disconnect_messages.
+        (SQLITE_CORRUPT, "irrecoverable on-disk page"),
+        (SQLITE_NOTADB, "header check failed"),
+    ],
+)
+def test_bare_database_error_with_slot_fatal_code_classifies_as_disconnect(
+    code: int, message: str
+) -> None:
+    """Every (code, message) shape in the bare-DBE slot-fatal set
+    classifies as disconnect, regardless of substring."""
+    exc = DatabaseError(message, code=code)
+    assert DqliteDialect().is_disconnect(exc, None, None) is True
+
+
+def test_bare_database_error_with_non_slot_fatal_code_does_not_classify() -> None:
+    """Regression: a bare ``DatabaseError`` whose code is NOT in
+    ``_BARE_DBE_DISCONNECT_CODES`` must not be classified as
+    disconnect, even with a transport-shaped message. Per the
+    `_BARE_DBE_DISCONNECT_CODES` SSOT and ``do_ping`` arm precedent."""
+    exc = DatabaseError("wire decode failed near column 42", code=99)
+    assert DqliteDialect().is_disconnect(exc, None, None) is False
+
+
+def test_subclasses_of_database_error_are_not_routed_through_bare_arm() -> None:
+    """Regression: ``IntegrityError`` / ``DataError`` (subclasses of
+    DatabaseError) take the ``type(cause) is DatabaseError`` arm via
+    type-identity check — they MUST NOT match the slot-fatal
+    short-circuit even when they happen to carry a transport-shaped
+    message. SA's retry path would otherwise duplicate non-idempotent
+    INSERTs."""
+    from dqlitedbapi.exceptions import DataError, IntegrityError
+
+    integrity = IntegrityError(
+        "constraint failed: timed out validating peer",
+        code=19,
+    )
+    assert DqliteDialect().is_disconnect(integrity, None, None) is False
+
+    data = DataError(
+        "datatype mismatch: connection closed in payload",
+        code=20,
+    )
+    assert DqliteDialect().is_disconnect(data, None, None) is False
+
+
+def test_is_disconnect_and_do_ping_agree_on_slot_fatal_codes() -> None:
+    """Cross-classifier parity pin: for every code in
+    ``_BARE_DBE_DISCONNECT_CODES``, ``is_disconnect`` returns True AND
+    ``do_ping`` returns False (False == "slot dead, invalidate"). The
+    two classifiers MUST agree on the slot-fatal code set — that's
+    the whole point of extracting ``_BARE_DBE_DISCONNECT_CODES`` as
+    a shared constant.
+
+    do_ping's classifier is tested separately in the do_ping test
+    suite; this test pins the is_disconnect side and asserts the
+    invariant relation: is_disconnect(exc) == True iff do_ping
+    would return False on the same exc-raising path."""
+    from sqlalchemydqlite.base import _BARE_DBE_DISCONNECT_CODES
+
+    dialect = DqliteDialect()
+    for code in _BARE_DBE_DISCONNECT_CODES:
+        exc = DatabaseError(f"engine error with code {code}", code=code)
+        assert dialect.is_disconnect(exc, None, None) is True, (
+            f"is_disconnect must classify bare DatabaseError(code={code}) as "
+            f"disconnect; got False. The do_ping arm at base.py:2935-2945 "
+            f"already short-circuits this code set — the two classifiers "
+            f"must agree (_BARE_DBE_DISCONNECT_CODES is the SSOT)."
+        )

{sqlalchemy_dqlite-0.2.0 → sqlalchemy_dqlite-0.2.1}/tests/test_is_disconnect_database_error_substring.py

@@ -27,14 +27,20 @@ def test_database_error_with_wire_decode_substring_classifies_as_disconnect() ->
     assert DqliteDialect().is_disconnect(e, None, None) is True
 
 
-def test_database_error_without_disconnect_substring_not_classified() -> None:
-    """Negative pin: a bare ``DatabaseError`` whose message does NOT
-    contain a disconnect substring must NOT be classified as a
-    disconnect — the widening only wires the substring branch to the
-    larger class hierarchy; it does not turn every ``DatabaseError``
-    into a disconnect."""
+def test_database_error_with_slot_fatal_code_classifies_even_without_substring() -> None:
+    """A bare ``DatabaseError`` carrying one of the slot-fatal codes
+    (CORRUPT=11 / FORMAT=24 / NOTADB=26) classifies as disconnect
+    regardless of message — pre-fix this returned False (the substring
+    gate blocked classification on the canonical engine wording);
+    post-fix the bare-DBE arm short-circuits ``return True`` for the
+    code set, mirroring ``do_ping``'s arm at base.py:2935-2945. See
+    ``test_is_disconnect_bare_dbe_short_circuits_on_slot_fatal_codes.py``
+    for the full pin set explaining the HIGH-severity hazard the
+    pre-fix behaviour created (without ``pool_pre_ping=True``, a slot
+    surfacing CORRUPT stayed in the pool and re-tripped on every
+    subsequent checkout)."""
     e = DatabaseError("database disk image is malformed", code=11)
-    assert DqliteDialect().is_disconnect(e, None, None) is False
+    assert DqliteDialect().is_disconnect(e, None, None) is True
 
 
 def test_database_error_via_cause_walk() -> None: