TypeDAL 4.9.6__tar.gz → 4.9.8__tar.gz

{typedal-4.9.6 → typedal-4.9.8}/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 <!--next-version-placeholder-->
 
+## v4.9.8 (2026-07-14)
+
+### Fix
+
+* **core:** Clear table hooks and field validators on close ([`3a3fe7b`](https://github.com/trialandsuccess/TypeDAL/commit/3a3fe7b3387476a9ee50f85d492dea067f218069))
+
+## v4.9.8-beta.2 (2026-07-14)
+
+### Fix
+
+* **core:** Fully detach tables and fields when closing TypeDAL ([`469e0cb`](https://github.com/trialandsuccess/TypeDAL/commit/469e0cbc5b4f1584849040735ced0232adc18b65))
+
+## v4.9.8-beta.1 (2026-07-14)
+
+### Fix
+
+* **core:** Purge dialect expressions when closing TypeDAL ([`d848cf7`](https://github.com/trialandsuccess/TypeDAL/commit/d848cf72ca0ecee24ba857d6b5e03d3cacce7693))
+
+## v4.9.7 (2026-07-14)
+
+### Fix
+
+* **fields:** Clear field requirements during unbind ([`7e054f9`](https://github.com/trialandsuccess/TypeDAL/commit/7e054f947358a3fbb491db0d777410433da43d44))
+
 ## v4.9.6 (2026-07-14)
 
 ### Fix

{typedal-4.9.6 → typedal-4.9.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TypeDAL
-Version: 4.9.6
+Version: 4.9.8
 Summary: Typing support for PyDAL
 Project-URL: Documentation, https://typedal.readthedocs.io/
 Project-URL: Issues, https://github.com/trialandsuccess/TypeDAL/issues

{typedal-4.9.6 → typedal-4.9.8}/pyproject.toml

@@ -193,8 +193,7 @@ exclude = ["venv", ".bak"]
 target-version = "py314"
 line-length = 120
 
-extend-exclude = ["*.bak/", "venv*/"]
-
+extend-exclude = ["*.bak/", "venv*/", "tests/", "example_*.py"]
 [tool.ruff.lint]
 
 select = [

{typedal-4.9.6 → typedal-4.9.8}/src/typedal/__about__.py

@@ -5,4 +5,4 @@ This file contains the Version info for this package.
 # SPDX-FileCopyrightText: 2023-present Robin van der Noord <robinvandernoord@gmail.com>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "4.9.6"
+__version__ = "4.9.8"

{typedal-4.9.6 → typedal-4.9.8}/src/typedal/cli.py

@@ -425,8 +425,7 @@ def fake_migrations(
 
     previously_migrated = (
         db(
-            db.ewh_implemented_features.name.belongs(to_fake)
-            & (db.ewh_implemented_features.installed == True),  # noqa E712
+            db.ewh_implemented_features.name.belongs(to_fake) & (db.ewh_implemented_features.installed == True),  # noqa E712
         )
         .select(db.ewh_implemented_features.name)
         .column("name")

{typedal-4.9.6 → typedal-4.9.8}/src/typedal/core.py

@@ -40,6 +40,53 @@ if t.TYPE_CHECKING:
     from .types import AnyDict, DefineKwargs, Expression, Rows, Set, T_Query, Table
 
 
+def _expression_subclasses() -> t.Iterator[type]:
+    """
+    Yield pydal.objects.Expression and every (nested) subclass currently loaded, e.g. Field and TypedField.
+    """
+    seen = {pydal.objects.Expression}
+    stack = [pydal.objects.Expression]
+    while stack:
+        for subclass in stack.pop().__subclasses__():
+            if subclass not in seen:
+                seen.add(subclass)
+                stack.append(subclass)
+
+    return iter(seen)
+
+
+def _purge_dialect_expressions(adapter: t.Any) -> None:
+    """
+    Undo pydal's global dialect-expression registration for a closed adapter.
+
+    Some dialects (currently Postgres and Snowflake) register extra Expression methods
+    (e.g. `.dow`, `.doy`) by stashing a wrapper per name in the process-wide, class-level
+    `Expression._dialect_expressions_` dict. `Expression.__new__` then copies each wrapper
+    onto every instantiated Expression subclass (Field, TypedField, ...) as a bound method.
+    Both of those are permanent references living outside of any object graph tied to a
+    specific db, so they are not reference cycles: closing the adapter and even running
+    `gc.collect()` will not free it, and with it the entire db (tables, fields, models)
+    it belongs to, for the lifetime of the process, unless explicitly undone here.
+    """
+    expressions = pydal.objects.Expression._dialect_expressions_
+    stale = [
+        name
+        for name, wrapper in expressions.items()
+        if getattr(getattr(wrapper, "dialect", None), "adapter", None) is adapter
+    ]
+
+    if not stale:
+        return
+
+    for name in stale:
+        del expressions[name]
+
+    for cls in _expression_subclasses():
+        for name in stale:
+            if name in cls.__dict__:
+                delattr(cls, name)
+
+
 # note: these functions can not be moved to a different file,
 #  because then they will have different globals and it breaks!
 
@@ -282,6 +329,7 @@ class TypeDAL(_TypeDALBase):
 
     def close(self) -> None:
         """Close the database connection and unbind all defined TypedTable models."""
+        adapter = self._adapter
         try:
             super().close()
         finally:
@@ -289,6 +337,46 @@ class TypeDAL(_TypeDALBase):
                 model.unbind()
             self._builder.class_map.clear()
 
+            if adapter is not None:
+                adapter.db = None
+                _purge_dialect_expressions(adapter)
+
+            for table_name in tuple(getattr(self, "tables", ())):
+                table: Table | None = getattr(self, table_name, None)
+                if table is None:  # pragma: no cover
+                    continue
+
+                for hook_name in (
+                    "_before_insert",
+                    "_after_insert",
+                    "_before_update",
+                    "_after_update",
+                    "_before_delete",
+                    "_after_delete",
+                ):
+                    hooks = getattr(table, hook_name, None)
+                    if isinstance(hooks, list):
+                        hooks.clear()
+
+                if hasattr(table, "_db"):
+                    table._db = None
+
+                for field_name in getattr(table, "fields", ()):
+                    field: Field | None = getattr(table, field_name, None)
+                    if field is None:  # pragma: no cover
+                        continue
+
+                    if hasattr(field, "_db"):
+                        field._db = None
+                    if hasattr(field, "db"):
+                        field.db = None
+                    if hasattr(field, "table"):
+                        field.table = None
+                    if hasattr(field, "_table"):
+                        field._table = None
+                    if hasattr(field, "requires"):
+                        field.requires = []
+
     def try_define[T: t.Any](self, model: t.Type[T], verbose: bool = False) -> t.Type[T]:
         """
         Try to define a model with migrate or fall back to fake migrate.

{typedal-4.9.6 → typedal-4.9.8}/src/typedal/fields.py

@@ -199,7 +199,14 @@ class TypedField[T_Value](Expression):  # pragma: no cover
 
     def unbind(self) -> None:
         """Remove references to the pydal objects created during ``bind``."""
+        if getattr(self, "requires", None):
+            if isinstance(self.requires, list):
+                self.requires.clear()
+            else:
+                self.requires = []
+
         self._table = None
+        self._db = None
         self._field = None
 
     def __getattr__(self, key: str) -> t.Any:

{typedal-4.9.6 → typedal-4.9.8}/tasks.py

@@ -33,7 +33,7 @@ def generate_nav_entries() -> list[str]:
 
 
 @task
-def update_docs_nav(ctx: Context) -> None:
+def update_docs_nav(_: Context) -> None:
     """Update mkdocs.yml nav section from actual markdown files to prevent sync issues."""
     mkdocs_file = Path(__file__).parent / "mkdocs.yml"
 

{typedal-4.9.6 → typedal-4.9.8}/tests/conftest.py

@@ -21,10 +21,12 @@ def psql(request):
     request.addfinalizer(postgres.stop)
     postgres.start()
 
-
 @pytest.fixture
-def dal_psql(psql):
+def dal_psql_uri(psql) -> str:
     conn_str = postgres.get_connection_url()
-    uri = "postgres://" + conn_str.split("://")[-1]
+    return "postgres://" + conn_str.split("://")[-1]
+
+@pytest.fixture
+def dal_psql(dal_psql_uri: str):
     with tempfile.TemporaryDirectory() as d:
-        yield TypeDAL(uri, attempts=1, migrate=True, enable_typedal_caching=False, folder=d)
+        yield TypeDAL(dal_psql_uri, attempts=1, migrate=True, enable_typedal_caching=False, folder=d)

{typedal-4.9.6 → typedal-4.9.8}/tests/test_main.py

@@ -3,17 +3,21 @@ import gc
 import re
 import sys
 import typing
+import types
 import weakref
+from contextlib import contextmanager
 from copy import copy
 from sqlite3 import IntegrityError
 from typing import ForwardRef
 
 import pytest
+from pydal.validators import IS_NOT_IN_DB
 
-from src.typedal import TypedRows
+from src.typedal import TypeDAL, TypedRows
 from src.typedal.__about__ import __version__
 from src.typedal.enum_helpers import InvalidEnumValue
 from src.typedal.fields import *
+from src.typedal.web2py_py4web_shared import AuthUser
 
 
 def test_about():
@@ -47,6 +51,97 @@ def test_database_is_garbage_collected_after_close():
     assert db_ref() is None
 
 
+def test_database_is_garbage_collected_after_context_manager():
+
+    @contextmanager
+    def typedal_context():
+        db = TypeDAL("sqlite:memory", enable_typedal_caching=False)
+        try:
+            yield db
+            db.commit()
+        except:
+            db.rollback()
+        finally:
+            db.close()
+
+    def in_scope():
+        with typedal_context() as db:
+            @db.define
+            class RelatedTable(TypedTable):
+                value = TypedField(str)
+
+            @db.define
+            class TemporaryTable(TypedTable):
+                related: RelatedTable
+                value = TypedField(str)
+
+                @classmethod
+                def __on_define__(cls, db):
+                    cls.id.requires = IS_NOT_IN_DB(db, cls.id)
+                    cls.after_insert(lambda _row, _id, db=db: None)
+
+            query = TemporaryTable.where(id=0)
+            assert not query.paginate(limit=1)
+
+            return weakref.ref(db)
+
+    db_ref = in_scope()
+
+    gc.collect()
+
+    assert db_ref() is None
+
+
+def test_database_with_auth_user_is_garbage_collected_after_close():
+    db = TypeDAL("sqlite:memory", enable_typedal_caching=False)
+    db.define(AuthUser, redefine=True)
+
+    AuthUser.after_insert(lambda row, db=db: print(db))
+
+    db_ref = weakref.ref(db)
+
+    db.close()
+
+    assert AuthUser._db is None
+    assert AuthUser._table is None
+
+    del db
+    gc.collect()
+
+    assert db_ref() is None
+
+
+def test_database_is_garbage_collected_after_close_postgres(dal_psql_uri, tmp_path):
+    # Postgres (and Snowflake) dialects register extra Expression methods (e.g. `.dow`) in the
+    # process-wide, class-level `Expression._dialect_expressions_` dict. That's a permanent
+    # reference living outside of any db-specific object graph, so unlike the sqlite case above,
+    # gc.collect() alone can't free it - close() has to explicitly undo the registration.
+    # (built directly from the conftest `postgres` container, not the `dal_psql` fixture: a
+    # suspended fixture generator would itself keep `db` alive for the duration of the test)
+
+    db = TypeDAL(dal_psql_uri, attempts=1, migrate=True, enable_typedal_caching=False, folder=str(tmp_path))
+
+    @db.define
+    class TemporaryPsqlTable(TypedTable):
+        value = TypedField(str)
+
+    db_ref = weakref.ref(db)
+    adapter_ref = weakref.ref(db._adapter)
+
+    db.close()
+
+    assert TemporaryPsqlTable._db is None
+    assert TemporaryPsqlTable._table is None
+
+    del db
+    gc.collect()
+
+    assert db_ref() is None
+    # the adapter itself is allowed to leak (pydal has no public API to fully undo the global
+    # dialect registration) as long as it no longer drags the rest of the db graph with it:
+    assert adapter_ref() is None or adapter_ref().db is None
+
+
 def test_mixed_defines(capsys):
     ### DEFINE
 

{typedal-4.9.6 → typedal-4.9.8}/tests/test_mypy.py

@@ -178,12 +178,12 @@ def mypy_test_mixin_typed_table_argument() -> None:
 
 @pytest.mark.mypy_testing
 def mypy_test_cachefn() -> None:
-    def cache_model(key: str, fn: CacheFn, expire: int) -> Rows:
+    def cache_model(_key: str, fn: CacheFn, _expire: int) -> Rows:
         return fn()
 
-    cache_valid: CacheTuple = (cache_model, 3000)
+    _cache_valid: CacheTuple = (cache_model, 3000)
 
-    def invalid_cache_model(key: str, fn: typing.Callable[..., list[str]], _: int = None) -> list[str]:
+    def invalid_cache_model(_key: str, fn: typing.Callable[..., list[str]], _expire: int = None) -> list[str]:
         return fn()
 
-    cache_invalid: CacheTuple = (invalid_cache_model, 3000)  # E: [assignment]
+    _cache_invalid: CacheTuple = (invalid_cache_model, 3000)  # E: [assignment]

typedal-4.9.8/tests/test_py4web.py

@@ -0,0 +1,91 @@
+import json
+import tempfile
+
+from contextlib_chdir import chdir
+from pydal.validators import IS_EMAIL, IS_NOT_IN_DB
+
+from src.typedal import TypedTable
+from src.typedal.for_py4web import DAL, AuthUser, setup_py4web_tables
+from src.typedal.serializers import as_json
+from typedal.config import TypeDALConfig
+
+db = DAL("sqlite:memory")
+
+
+def test_P4W():
+    assert hasattr(DAL, "on_request")
+    assert hasattr(db, "on_request")
+
+
+def test_serialize():
+    @db.define()
+    class JsonTable(TypedTable):
+        field: str
+
+    row = JsonTable.insert(field="Hey")
+
+    loaded_data = json.loads(as_json.encode(JsonTable))
+    assert loaded_data
+    assert isinstance(loaded_data, dict)
+    loaded_data = json.loads(as_json.encode(row))
+    assert isinstance(loaded_data, dict)
+    assert loaded_data
+
+    loaded_data = json.loads(as_json.encode(JsonTable.paginate(limit=1)))
+
+    assert loaded_data["pagination"]
+    assert loaded_data["data"]
+
+
+def test_auth_user():
+    setup_py4web_tables(db)
+    requirements = AuthUser.email.requires
+
+    assert requirements
+    assert isinstance(requirements, list)
+    assert len(requirements) == 2
+
+    assert isinstance(requirements[0], IS_EMAIL)
+    assert isinstance(requirements[1], IS_NOT_IN_DB)
+
+
+def test_py4web_dal_singleton():
+    with tempfile.TemporaryDirectory() as d, chdir(d):
+        # note: typedal caching is disabled here because otherwise the cache table might send logs to {d}/log.sql
+        # which can lead to problems in other tests :(
+        db_1a = DAL("sqlite:memory", enable_typedal_caching=False)
+        db_1b = DAL("sqlite:memory", enable_typedal_caching=False)
+
+        db_2a = DAL("sqlite://test_py4web_dal_singleton", folder=d, enable_typedal_caching=False)
+        db_2b = DAL("sqlite://test_py4web_dal_singleton", folder=d, enable_typedal_caching=False)
+
+        conf = {"database": "sqlite:memory", "dialect": "sqlite", "pyproject": "", "flag_location": f"{d}/flags"}
+        db_3a = DAL(config=TypeDALConfig.load(conf))
+        db_3b = DAL(config=TypeDALConfig.load(conf))
+
+        assert db_1a is db_1b
+        assert db_1a._uri == db_1b._uri
+        assert db_1a._db_uid == db_1b._db_uid
+
+        assert db_2a is db_2b
+        assert db_2a._uri == db_2b._uri
+        assert db_2a._db_uid == db_2b._db_uid
+
+        assert db_1a is not db_2a
+        assert db_1a._uri != db_2a._uri
+        assert db_1a._db_uid != db_2a._db_uid
+
+        assert db_1b is not db_2b
+        assert db_1b._uri != db_2b._uri
+        assert db_1b._db_uid != db_2b._db_uid
+
+        assert db_3a is db_3b
+        assert db_3a is not db_1a
+        assert db_3a is not db_2a
+
+        assert db_1a._uri == db_1b._uri
+        assert db_3a._uri == db_1a._uri
+        assert db_3a._uri != db_2a._uri
+
+    # reset singletons for later use:
+    DAL._clear()

{typedal-4.9.6 → typedal-4.9.8}/tests/test_relationships.py

@@ -129,8 +129,8 @@ def _setup_data():
 
     # no relationships:
     new_author = User.insert(name="Untagged Author", roles=[], main_role=writer, extra_roles=[])
-    untagged1 = Article.insert(title="Untagged Article 1", author=new_author)
-    untagged2 = Article.insert(title="Untagged Article 2", author=new_author)
+    _untagged1 = Article.insert(title="Untagged Article 1", author=new_author)
+    _untagged2 = Article.insert(title="Untagged Article 2", author=new_author)
 
     # articles
 
@@ -355,10 +355,9 @@ def test_reprs():
 
     assert "AND" not in repr(relation)
 
-    relation = Article.join("author", condition_and=lambda article, author: author.name != "Hank").relationships[
+    relation = Article.join("author", condition_and=lambda _article, author: author.name != "Hank").relationships[
         "author"
     ]
-
     assert "AND" in repr(relation) and "Hank" in repr(relation)
 
 
@@ -436,7 +435,7 @@ def test_join_with_different_condition():
     role_with_users = Role.join(
         "users",
         method="inner",
-        condition_and=lambda role, user: ~user.name.like("Reader%"),
+        condition_and=lambda _role, user: ~user.name.like("Reader%"),
     ).first()
 
     assert role_with_users.users
@@ -446,7 +445,7 @@ def test_join_with_different_condition():
     role_with_users = Role.join(
         "users",
         method="left",
-        condition_and=lambda role, user: ~user.name.like("Reader%"),
+        condition_and=lambda _role, user: ~user.name.like("Reader%"),
     ).first()
 
     assert role_with_users.users
@@ -729,11 +728,11 @@ def test_memoize_nested_dependencies():
     assert len(users) > 0
 
     # First memoize - should be fresh
-    result1, status = db.memoize(process_users, users)
+    _result1, status = db.memoize(process_users, users)
     assert status == "fresh"
 
     # Second call - should be cached
-    result2, status = db.memoize(process_users, users)
+    _result2, status = db.memoize(process_users, users)
     assert status == "cached"
 
     # Update a Role that was accessed inside process_users
@@ -742,7 +741,7 @@ def test_memoize_nested_dependencies():
 
     # Third call - should be fresh (invalidated by Role change)
     # but currently will still be "cached" because we only tracked User deps
-    result3, status = db.memoize(process_users, users)
+    _result3, status = db.memoize(process_users, users)
     assert status == "fresh"
 
 
@@ -755,25 +754,25 @@ def test_memoize_nested_dependencies2():
         # (which happens when using _determine_dependencies_auto)
         return list(User.join())
 
-    bogus, status = db.memoize(something_slow)
+    _bogus, status = db.memoize(something_slow)
     assert status == "fresh"
 
     # no change
-    bogus, status = db.memoize(something_slow)
+    _bogus, status = db.memoize(something_slow)
     assert status == "cached"
 
     # user change
     User.first().update_record(name="New Name :)")
-    bogus, status = db.memoize(something_slow)
+    _bogus, status = db.memoize(something_slow)
     assert status == "fresh"
 
     # role change
     Role.first().update_record(name="New Role Name :)")
-    bogus, status = db.memoize(something_slow)
+    _bogus, status = db.memoize(something_slow)
     assert status == "fresh"
 
     # no change
-    bogus, status = db.memoize(something_slow)
+    _bogus, status = db.memoize(something_slow)
     assert status == "cached"
 
 
@@ -931,7 +930,8 @@ def test_accessing_raw_data():
 
     user = User.where(id=4).join("articles").first()
 
-    # <User({"id": 4, "name": "Untagged Author", "roles": [], "gid": "967da807-eb13-46dc-a0f3-d5c04751edf4", "main_role": 2, "extra_roles": []}) + ['articles']>
+    # <User({"id": 4, "name": "Untagged Author", "roles": [],
+    #        "gid": "967da807-eb13-46dc-a0f3-d5c04751edf4", "main_role": 2, "extra_roles": []}) + ['articles']>
     assert user._row
 
     # one row per user+article combination like how postgres returns it:
@@ -1031,9 +1031,9 @@ def test_nested_join_with_shared_foreign_key():
     tech_corp = Company.insert(name="Tech Corp")
 
     # Create multiple offices in the same city for the same company
-    office1 = Office.insert(address="123 Market St", city_id=san_francisco.id, company=tech_corp.id)
-    office2 = Office.insert(address="456 Mission St", city_id=san_francisco.id, company=tech_corp.id)
-    office3 = Office.insert(address="789 Howard St", city_id=san_francisco.id, company=tech_corp.id)
+    _office1 = Office.insert(address="123 Market St", city_id=san_francisco.id, company=tech_corp.id)
+    _office2 = Office.insert(address="456 Mission St", city_id=san_francisco.id, company=tech_corp.id)
+    _office3 = Office.insert(address="789 Howard St", city_id=san_francisco.id, company=tech_corp.id)
 
     db.commit()
 
@@ -1072,7 +1072,8 @@ def test_nested_join_with_shared_foreign_key():
             f"Office {idx} ('{office.address}'): city relationship is None (BUG!)"
         )
         assert isinstance(office.city_alternative, City), (
-            f"Office {idx}: city ({office.city_alternative}) is not a City instance but a {type(office.city_alternative)}"
+            f"Office {idx}: city ({office.city_alternative}) "
+            f"is not a City instance but a {type(office.city_alternative)}"
         )
         assert office.city_alternative.name == "San Francisco", (
             f"Office {idx}: expected 'San Francisco', got '{office.city_alternative.name}'"

typedal-4.9.6/tests/test_py4web.py

@@ -1,92 +0,0 @@
-import json
-import tempfile
-
-from contextlib_chdir import chdir
-from pydal.validators import IS_EMAIL, IS_NOT_IN_DB
-
-from src.typedal import TypedTable
-from src.typedal.for_py4web import DAL, AuthUser, setup_py4web_tables
-from src.typedal.serializers import as_json
-from typedal.config import TypeDALConfig
-
-db = DAL("sqlite:memory")
-
-
-def test_P4W():
-    assert hasattr(DAL, "on_request")
-    assert hasattr(db, "on_request")
-
-
-def test_serialize():
-    @db.define()
-    class JsonTable(TypedTable):
-        field: str
-
-    row = JsonTable.insert(field="Hey")
-
-    l = json.loads(as_json.encode(JsonTable))
-    assert l
-    assert isinstance(l, dict)
-    l = json.loads(as_json.encode(row))
-    assert isinstance(l, dict)
-    assert l
-
-    l = json.loads(as_json.encode(JsonTable.paginate(limit=1)))
-
-    assert l["pagination"]
-    assert l["data"]
-
-
-def test_auth_user():
-    setup_py4web_tables(db)
-    requirements = AuthUser.email.requires
-
-    assert requirements
-    assert isinstance(requirements, list)
-    assert len(requirements) == 2
-
-    assert isinstance(requirements[0], IS_EMAIL)
-    assert isinstance(requirements[1], IS_NOT_IN_DB)
-
-
-def test_py4web_dal_singleton():
-    with tempfile.TemporaryDirectory() as d:
-        with chdir(d):
-            # note: typedal caching is disabled here because otherwise the cache table might send logs to {d}/log.sql
-            # which can lead to problems in other tests :(
-            db_1a = DAL("sqlite:memory", enable_typedal_caching=False)
-            db_1b = DAL("sqlite:memory", enable_typedal_caching=False)
-
-            db_2a = DAL("sqlite://test_py4web_dal_singleton", folder=d, enable_typedal_caching=False)
-            db_2b = DAL("sqlite://test_py4web_dal_singleton", folder=d, enable_typedal_caching=False)
-
-            conf = {"database": "sqlite:memory", "dialect": "sqlite", "pyproject": "", "flag_location": f"{d}/flags"}
-            db_3a = DAL(config=TypeDALConfig.load(conf))
-            db_3b = DAL(config=TypeDALConfig.load(conf))
-
-            assert db_1a is db_1b
-            assert db_1a._uri == db_1b._uri
-            assert db_1a._db_uid == db_1b._db_uid
-
-            assert db_2a is db_2b
-            assert db_2a._uri == db_2b._uri
-            assert db_2a._db_uid == db_2b._db_uid
-
-            assert db_1a is not db_2a
-            assert db_1a._uri != db_2a._uri
-            assert db_1a._db_uid != db_2a._db_uid
-
-            assert db_1b is not db_2b
-            assert db_1b._uri != db_2b._uri
-            assert db_1b._db_uid != db_2b._db_uid
-
-            assert db_3a is db_3b
-            assert db_3a is not db_1a
-            assert db_3a is not db_2a
-
-            assert db_1a._uri == db_1b._uri
-            assert db_3a._uri == db_1a._uri
-            assert db_3a._uri != db_2a._uri
-
-    # reset singletons for later use:
-    DAL._clear()