dclassql 0.1.0__tar.gz → 0.1.2__tar.gz

{dclassql-0.1.0 → dclassql-0.1.2}/PKG-INFO

@@ -1,11 +1,22 @@
 Metadata-Version: 2.3
 Name: dclassql
-Version: 0.1.0
-Summary: Add your description here
+Version: 0.1.2
+Summary: A type-safe ORM generator for Python, creating fully type-hinted database clients from plain dataclass definitions.
+Keywords: orm,codegen,sqlite,dataclass,typed
 Author: myuanz
 Author-email: myuanz <provefars@gmail.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Typing :: Typed
+Requires-Dist: jinja2>=3.1.6
 Requires-Dist: pypika>=0.48.9
+Requires-Dist: typing-extensions>=4.12.2
 Requires-Python: >=3.12
+Project-URL: Homepage, https://github.com/myuanz/dataclassql
 Description-Content-Type: text/markdown
 
 # DataclassQL

dclassql-0.1.2/pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+name = "dclassql"
+version = "0.1.2"
+description = "A type-safe ORM generator for Python, creating fully type-hinted database clients from plain dataclass definitions."
+readme = "README.md"
+authors = [
+    { name = "myuanz", email = "provefars@gmail.com" }
+]
+license = { text = "MIT" }
+keywords = ["orm", "codegen", "sqlite", "dataclass", "typed"]
+classifiers = [
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+
+    "License :: OSI Approved :: MIT License",
+    "Intended Audience :: Developers",
+    "Typing :: Typed",
+]
+urls = { "Homepage" = "https://github.com/myuanz/dataclassql" }
+requires-python = ">=3.12"
+dependencies = [
+    "jinja2>=3.1.6",
+    "pypika>=0.48.9",
+    "typing_extensions>=4.12.2",
+]
+
+[project.scripts]
+"dql" = "dclassql.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.8.22,<0.9.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pyright>=1.1.407",
+    "pytest>=8.4.2",
+]

dclassql-0.1.2/src/dclassql/.gitignore

@@ -0,0 +1,2 @@
+client.py
+generated_models/

dclassql-0.1.2/src/dclassql/__init__.py

@@ -0,0 +1,27 @@
+from .db_pool import BaseDBPool, save_local
+from .push import db_push
+from .runtime.backends.lazy import eager
+from .unwarp import unwarp, unwarp_or, unwarp_or_raise
+
+class _MissingClient:
+    def __init__(self, *args: object, **kwargs: object) -> None:
+        raise RuntimeError(
+            "dclassql.Client 尚未生成。请先运行 `dql -m <model.py> generate` 生成客户端后再导入。"
+        )
+
+try:  # pragma: no cover - exercised in integration tests
+    from .client import Client  # type: ignore
+except ModuleNotFoundError:  # pragma: no cover - fallback when未生成
+    Client = _MissingClient  # type: ignore[assignment]
+
+
+__all__ = [
+    'Client',
+    'db_push',
+    'eager',
+    'unwarp',
+    'unwarp_or',
+    'unwarp_or_raise',
+    'BaseDBPool',
+    'save_local',
+]

{dclassql-0.1.0 → dclassql-0.1.2}/src/dclassql/cli.py

@@ -2,17 +2,22 @@ from __future__ import annotations
 
 import argparse
 import importlib.util
+import re
+import shutil
 import sys
+import warnings
 from pathlib import Path
 from types import ModuleType
 from typing import Any, Sequence
 
 from .codegen import generate_client
 from .push import db_push
-from .runtime.datasource import open_sqlite_connection, resolve_sqlite_path
+from .runtime.datasource import open_sqlite_connection
 
 
 DEFAULT_MODEL_FILE = "model.py"
+GENERATED_CLIENT_FILENAME = "client.py"
+GENERATED_MODELS_DIRNAME = "generated_models"
 
 
 def load_module(module_path: Path) -> ModuleType:
@@ -33,6 +38,54 @@ def load_module(module_path: Path) -> ModuleType:
     return module
 
 
+def _find_package_directory() -> Path:
+    spec = importlib.util.find_spec("dclassql")
+    if spec is None or not spec.submodule_search_locations:
+        raise RuntimeError("Cannot locate installed dclassql package to write generated client")
+    return Path(next(iter(spec.submodule_search_locations))).resolve()
+
+
+def resolve_generated_path() -> Path:
+    return _find_package_directory() / GENERATED_CLIENT_FILENAME
+
+
+def resolve_models_directory() -> Path:
+    return _find_package_directory() / GENERATED_MODELS_DIRNAME
+
+
+def _sanitize_name(name: str) -> str:
+    sanitized = re.sub(r"[^0-9a-zA-Z_]+", "_", name).strip("_")
+    return sanitized.lower() or "models"
+
+
+def compute_model_target(module_path: Path) -> tuple[Path, str]:
+    base_dir = resolve_models_directory()
+    base_dir.mkdir(parents=True, exist_ok=True)
+    (base_dir / "__init__.py").touch()
+
+    module_name = _sanitize_name(module_path.stem)
+
+    target_path = base_dir / f"{module_name}.py"
+    import_path = f"dclassql.{GENERATED_MODELS_DIRNAME}.{module_name}"
+    return target_path, import_path
+
+
+def materialize_model_module(module_path: Path) -> str:
+    target_path, import_path = compute_model_target(module_path)
+    if target_path.exists() or target_path.is_symlink():
+        target_path.unlink()
+    try:
+        target_path.symlink_to(module_path.resolve())
+    except OSError as exc:
+        warnings.warn(
+            f"Unable to create symlink for model '{module_path}'; falling back to copy. ({exc})",
+            RuntimeWarning,
+            stacklevel=2,
+        )
+        shutil.copy2(module_path, target_path)
+    return import_path
+
+
 def collect_models(module: ModuleType) -> list[type[Any]]:
     from dataclasses import is_dataclass
 
@@ -74,8 +127,17 @@ def push_database(models: Sequence[type[Any]]) -> None:
 def command_generate(module_path: Path) -> None:
     module = load_module(module_path)
     models = collect_models(module)
+    generated_models_module = materialize_model_module(module_path)
+    original_modules = {model: model.__module__ for model in models}
+    for model in models:
+        model.__module__ = generated_models_module
     generated = generate_client(models)
-    sys.stdout.write(generated.code)
+    for model, original in original_modules.items():
+        model.__module__ = original
+    output_path = resolve_generated_path()
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(generated.code, encoding="utf-8")
+    sys.stdout.write(f"Client written to {output_path}\n")
 
 
 def command_push_db(module_path: Path) -> None:

dclassql-0.1.2/src/dclassql/client.py

@@ -0,0 +1,496 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from types import MappingProxyType
+from typing import Any, Literal, Mapping, Sequence, NotRequired
+from typing_extensions import TypedDict
+
+from dclassql.db_pool import BaseDBPool, save_local
+from dclassql.runtime.backends import BackendProtocol, ColumnSpec, ForeignKeySpec, RelationSpec
+from dclassql.runtime.datasource import open_sqlite_connection
+
+from datetime import datetime
+from dclassql.generated_models.test_models import Address, BirthDay, Book, User, UserBook
+
+@dataclass(slots=True)
+class DataSourceConfig:
+    provider: str
+    url: str | None
+    name: str | None = None
+
+    @property
+    def key(self) -> str:
+        return self.name or self.provider
+
+
+
+TAddressIncludeCol = Literal['user']
+TAddressSortableCol = Literal['id', 'location', 'user_id']
+
+@dataclass(slots=True, kw_only=True)
+class AddressInsert:
+    id: int | None = None
+    location: str
+    user_id: int
+
+
+class AddressInsertDict(TypedDict, closed=True):
+    id: NotRequired[int]
+    location: str
+    user_id: int
+
+
+class AddressWhereDict(TypedDict, total=False, closed=True):
+    id: int | None
+    location: str | None
+    user_id: int | None
+
+
+class AddressIncludeDict(TypedDict, total=False, closed=True):
+    user: bool
+
+class AddressOrderByDict(TypedDict, total=False, closed=True):
+    id: Literal['asc', 'desc']
+    location: Literal['asc', 'desc']
+    user_id: Literal['asc', 'desc']
+
+class AddressTable:
+    model = Address
+    insert_model = AddressInsert
+    datasource = DataSourceConfig(provider='sqlite', url='sqlite:///test.db', name=None)
+    column_specs: tuple[ColumnSpec, ...] = (
+        ColumnSpec(name='id', optional=False, auto_increment=True, has_default=False, has_default_factory=False),
+        ColumnSpec(name='location', optional=False, auto_increment=False, has_default=False, has_default_factory=False),
+        ColumnSpec(name='user_id', optional=False, auto_increment=False, has_default=False, has_default_factory=False),
+    )
+    column_specs_by_name: Mapping[str, ColumnSpec] = MappingProxyType({spec.name: spec for spec in column_specs})
+    primary_key: tuple[str, ...] = ('id',)
+    indexes: tuple[tuple[str, ...], ...] = ()
+    unique_indexes: tuple[tuple[str, ...], ...] = ()
+    foreign_keys: tuple[ForeignKeySpec, ...] = (
+        ForeignKeySpec(
+            local_columns=('user_id',),
+            remote_model=User,
+            remote_columns=('id',),
+            backref='addresses',
+        ),
+    )
+
+    relations: tuple[RelationSpec, ...] = (
+        RelationSpec(name='user', table_name='UserTable', table_module=__name__, many=False, mapping=(('user_id', 'id'),), table_factory=lambda: UserTable),
+    )
+
+
+    def __init__(self, backend: BackendProtocol) -> None:
+        self._backend = backend
+
+    def insert(self, data: AddressInsert | AddressInsertDict) -> Address:
+        return self._backend.insert(self, data)
+
+    def insert_many(self, data: Sequence[AddressInsert | AddressInsertDict], *, batch_size: int | None = None) -> list[Address]:
+        return self._backend.insert_many(self, data, batch_size=batch_size)
+
+    def find_many(self, *, where: AddressWhereDict | None = None, include: AddressIncludeDict | None = None, order_by: AddressOrderByDict | None = None, take: int | None = None, skip: int | None = None) -> list[Address]:
+        return self._backend.find_many(
+            self, 
+            where=where, include=include, order_by=order_by, 
+            take=take, skip=skip
+        )
+
+    def find_first(self, *, where: AddressWhereDict | None = None, include: AddressIncludeDict | None = None, order_by: AddressOrderByDict | None = None, skip: int | None = None) -> Address | None:
+        return self._backend.find_first(
+            self, 
+            where=where, include=include, order_by=order_by, 
+            skip=skip
+        )
+
+TBirthDayIncludeCol = Literal['user']
+TBirthDaySortableCol = Literal['user_id', 'date']
+
+@dataclass(slots=True, kw_only=True)
+class BirthDayInsert:
+    user_id: int
+    date: datetime
+
+
+class BirthDayInsertDict(TypedDict, closed=True):
+    user_id: int
+    date: datetime
+
+
+class BirthDayWhereDict(TypedDict, total=False, closed=True):
+    user_id: int | None
+    date: datetime | None
+
+
+class BirthDayIncludeDict(TypedDict, total=False, closed=True):
+    user: bool
+
+class BirthDayOrderByDict(TypedDict, total=False, closed=True):
+    user_id: Literal['asc', 'desc']
+    date: Literal['asc', 'desc']
+
+class BirthDayTable:
+    model = BirthDay
+    insert_model = BirthDayInsert
+    datasource = DataSourceConfig(provider='sqlite', url='sqlite:///test.db', name=None)
+    column_specs: tuple[ColumnSpec, ...] = (
+        ColumnSpec(name='user_id', optional=False, auto_increment=False, has_default=False, has_default_factory=False),
+        ColumnSpec(name='date', optional=False, auto_increment=False, has_default=False, has_default_factory=False),
+    )
+    column_specs_by_name: Mapping[str, ColumnSpec] = MappingProxyType({spec.name: spec for spec in column_specs})
+    primary_key: tuple[str, ...] = ('user_id',)
+    indexes: tuple[tuple[str, ...], ...] = ()
+    unique_indexes: tuple[tuple[str, ...], ...] = ()
+    foreign_keys: tuple[ForeignKeySpec, ...] = (
+        ForeignKeySpec(
+            local_columns=('user_id',),
+            remote_model=User,
+            remote_columns=('id',),
+            backref='birthday',
+        ),
+    )
+
+    relations: tuple[RelationSpec, ...] = (
+        RelationSpec(name='user', table_name='UserTable', table_module=__name__, many=False, mapping=(('user_id', 'id'),), table_factory=lambda: UserTable),
+    )
+
+
+    def __init__(self, backend: BackendProtocol) -> None:
+        self._backend = backend
+
+    def insert(self, data: BirthDayInsert | BirthDayInsertDict) -> BirthDay:
+        return self._backend.insert(self, data)
+
+    def insert_many(self, data: Sequence[BirthDayInsert | BirthDayInsertDict], *, batch_size: int | None = None) -> list[BirthDay]:
+        return self._backend.insert_many(self, data, batch_size=batch_size)
+
+    def find_many(self, *, where: BirthDayWhereDict | None = None, include: BirthDayIncludeDict | None = None, order_by: BirthDayOrderByDict | None = None, take: int | None = None, skip: int | None = None) -> list[BirthDay]:
+        return self._backend.find_many(
+            self, 
+            where=where, include=include, order_by=order_by, 
+            take=take, skip=skip
+        )
+
+    def find_first(self, *, where: BirthDayWhereDict | None = None, include: BirthDayIncludeDict | None = None, order_by: BirthDayOrderByDict | None = None, skip: int | None = None) -> BirthDay | None:
+        return self._backend.find_first(
+            self, 
+            where=where, include=include, order_by=order_by, 
+            skip=skip
+        )
+
+TBookIncludeCol = Literal['users']
+TBookSortableCol = Literal['id', 'name']
+
+@dataclass(slots=True, kw_only=True)
+class BookInsert:
+    id: int | None = None
+    name: str
+
+
+class BookInsertDict(TypedDict, closed=True):
+    id: NotRequired[int]
+    name: str
+
+
+class BookWhereDict(TypedDict, total=False, closed=True):
+    id: int | None
+    name: str | None
+
+
+class BookIncludeDict(TypedDict, total=False, closed=True):
+    users: bool
+
+class BookOrderByDict(TypedDict, total=False, closed=True):
+    id: Literal['asc', 'desc']
+    name: Literal['asc', 'desc']
+
+class BookTable:
+    model = Book
+    insert_model = BookInsert
+    datasource = DataSourceConfig(provider='sqlite', url='sqlite:///test.db', name=None)
+    column_specs: tuple[ColumnSpec, ...] = (
+        ColumnSpec(name='id', optional=False, auto_increment=True, has_default=False, has_default_factory=False),
+        ColumnSpec(name='name', optional=False, auto_increment=False, has_default=False, has_default_factory=False),
+    )
+    column_specs_by_name: Mapping[str, ColumnSpec] = MappingProxyType({spec.name: spec for spec in column_specs})
+    primary_key: tuple[str, ...] = ('id',)
+    indexes: tuple[tuple[str, ...], ...] = (('name',),)
+    unique_indexes: tuple[tuple[str, ...], ...] = ()
+    foreign_keys: tuple[ForeignKeySpec, ...] = ()
+
+    relations: tuple[RelationSpec, ...] = (
+        RelationSpec(name='users', table_name='UserBookTable', table_module=__name__, many=True, mapping=(('id', 'book_id'),), table_factory=lambda: UserBookTable),
+    )
+
+
+    def __init__(self, backend: BackendProtocol) -> None:
+        self._backend = backend
+
+    def insert(self, data: BookInsert | BookInsertDict) -> Book:
+        return self._backend.insert(self, data)
+
+    def insert_many(self, data: Sequence[BookInsert | BookInsertDict], *, batch_size: int | None = None) -> list[Book]:
+        return self._backend.insert_many(self, data, batch_size=batch_size)
+
+    def find_many(self, *, where: BookWhereDict | None = None, include: BookIncludeDict | None = None, order_by: BookOrderByDict | None = None, take: int | None = None, skip: int | None = None) -> list[Book]:
+        return self._backend.find_many(
+            self, 
+            where=where, include=include, order_by=order_by, 
+            take=take, skip=skip
+        )
+
+    def find_first(self, *, where: BookWhereDict | None = None, include: BookIncludeDict | None = None, order_by: BookOrderByDict | None = None, skip: int | None = None) -> Book | None:
+        return self._backend.find_first(
+            self, 
+            where=where, include=include, order_by=order_by, 
+            skip=skip
+        )
+
+TUserIncludeCol = Literal['addresses', 'birthday', 'books']
+TUserSortableCol = Literal['id', 'name', 'email', 'last_login']
+
+@dataclass(slots=True, kw_only=True)
+class UserInsert:
+    id: int | None = None
+    name: str
+    email: str
+    last_login: datetime
+
+
+class UserInsertDict(TypedDict, closed=True):
+    id: NotRequired[int]
+    name: str
+    email: str
+    last_login: datetime
+
+
+class UserWhereDict(TypedDict, total=False, closed=True):
+    id: int | None
+    name: str | None
+    email: str | None
+    last_login: datetime | None
+
+
+class UserIncludeDict(TypedDict, total=False, closed=True):
+    addresses: bool
+    birthday: bool
+    books: bool
+
+class UserOrderByDict(TypedDict, total=False, closed=True):
+    id: Literal['asc', 'desc']
+    name: Literal['asc', 'desc']
+    email: Literal['asc', 'desc']
+    last_login: Literal['asc', 'desc']
+
+class UserTable:
+    model = User
+    insert_model = UserInsert
+    datasource = DataSourceConfig(provider='sqlite', url='sqlite:///test.db', name=None)
+    column_specs: tuple[ColumnSpec, ...] = (
+        ColumnSpec(name='id', optional=False, auto_increment=True, has_default=False, has_default_factory=False),
+        ColumnSpec(name='name', optional=False, auto_increment=False, has_default=False, has_default_factory=False),
+        ColumnSpec(name='email', optional=False, auto_increment=False, has_default=False, has_default_factory=False),
+        ColumnSpec(name='last_login', optional=False, auto_increment=False, has_default=False, has_default_factory=False),
+    )
+    column_specs_by_name: Mapping[str, ColumnSpec] = MappingProxyType({spec.name: spec for spec in column_specs})
+    primary_key: tuple[str, ...] = ('id',)
+    indexes: tuple[tuple[str, ...], ...] = (('name',), ('name', 'email'), ('last_login',),)
+    unique_indexes: tuple[tuple[str, ...], ...] = (('name', 'email'),)
+    foreign_keys: tuple[ForeignKeySpec, ...] = ()
+
+    relations: tuple[RelationSpec, ...] = (
+        RelationSpec(name='birthday', table_name='BirthDayTable', table_module=__name__, many=False, mapping=(('id', 'user_id'),), table_factory=lambda: BirthDayTable),
+        RelationSpec(name='addresses', table_name='AddressTable', table_module=__name__, many=True, mapping=(('id', 'user_id'),), table_factory=lambda: AddressTable),
+        RelationSpec(name='books', table_name='UserBookTable', table_module=__name__, many=True, mapping=(('id', 'user_id'),), table_factory=lambda: UserBookTable),
+    )
+
+
+    def __init__(self, backend: BackendProtocol) -> None:
+        self._backend = backend
+
+    def insert(self, data: UserInsert | UserInsertDict) -> User:
+        return self._backend.insert(self, data)
+
+    def insert_many(self, data: Sequence[UserInsert | UserInsertDict], *, batch_size: int | None = None) -> list[User]:
+        return self._backend.insert_many(self, data, batch_size=batch_size)
+
+    def find_many(self, *, where: UserWhereDict | None = None, include: UserIncludeDict | None = None, order_by: UserOrderByDict | None = None, take: int | None = None, skip: int | None = None) -> list[User]:
+        return self._backend.find_many(
+            self, 
+            where=where, include=include, order_by=order_by, 
+            take=take, skip=skip
+        )
+
+    def find_first(self, *, where: UserWhereDict | None = None, include: UserIncludeDict | None = None, order_by: UserOrderByDict | None = None, skip: int | None = None) -> User | None:
+        return self._backend.find_first(
+            self, 
+            where=where, include=include, order_by=order_by, 
+            skip=skip
+        )
+
+TUserBookIncludeCol = Literal['book', 'user']
+TUserBookSortableCol = Literal['user_id', 'book_id', 'created_at']
+
+@dataclass(slots=True, kw_only=True)
+class UserBookInsert:
+    user_id: int
+    book_id: int
+    created_at: datetime
+
+
+class UserBookInsertDict(TypedDict, closed=True):
+    user_id: int
+    book_id: int
+    created_at: datetime
+
+
+class UserBookWhereDict(TypedDict, total=False, closed=True):
+    user_id: int | None
+    book_id: int | None
+    created_at: datetime | None
+
+
+class UserBookIncludeDict(TypedDict, total=False, closed=True):
+    book: bool
+    user: bool
+
+class UserBookOrderByDict(TypedDict, total=False, closed=True):
+    user_id: Literal['asc', 'desc']
+    book_id: Literal['asc', 'desc']
+    created_at: Literal['asc', 'desc']
+
+class UserBookTable:
+    model = UserBook
+    insert_model = UserBookInsert
+    datasource = DataSourceConfig(provider='sqlite', url='sqlite:///test.db', name=None)
+    column_specs: tuple[ColumnSpec, ...] = (
+        ColumnSpec(name='user_id', optional=False, auto_increment=False, has_default=False, has_default_factory=False),
+        ColumnSpec(name='book_id', optional=False, auto_increment=False, has_default=False, has_default_factory=False),
+        ColumnSpec(name='created_at', optional=False, auto_increment=False, has_default=False, has_default_factory=False),
+    )
+    column_specs_by_name: Mapping[str, ColumnSpec] = MappingProxyType({spec.name: spec for spec in column_specs})
+    primary_key: tuple[str, ...] = ('user_id', 'book_id')
+    indexes: tuple[tuple[str, ...], ...] = (('created_at',),)
+    unique_indexes: tuple[tuple[str, ...], ...] = ()
+    foreign_keys: tuple[ForeignKeySpec, ...] = (
+        ForeignKeySpec(
+            local_columns=('user_id',),
+            remote_model=User,
+            remote_columns=('id',),
+            backref='books',
+        ),
+        ForeignKeySpec(
+            local_columns=('book_id',),
+            remote_model=Book,
+            remote_columns=('id',),
+            backref='users',
+        ),
+    )
+
+    relations: tuple[RelationSpec, ...] = (
+        RelationSpec(name='user', table_name='UserTable', table_module=__name__, many=False, mapping=(('user_id', 'id'),), table_factory=lambda: UserTable),
+        RelationSpec(name='book', table_name='BookTable', table_module=__name__, many=False, mapping=(('book_id', 'id'),), table_factory=lambda: BookTable),
+    )
+
+
+    def __init__(self, backend: BackendProtocol) -> None:
+        self._backend = backend
+
+    def insert(self, data: UserBookInsert | UserBookInsertDict) -> UserBook:
+        return self._backend.insert(self, data)
+
+    def insert_many(self, data: Sequence[UserBookInsert | UserBookInsertDict], *, batch_size: int | None = None) -> list[UserBook]:
+        return self._backend.insert_many(self, data, batch_size=batch_size)
+
+    def find_many(self, *, where: UserBookWhereDict | None = None, include: UserBookIncludeDict | None = None, order_by: UserBookOrderByDict | None = None, take: int | None = None, skip: int | None = None) -> list[UserBook]:
+        return self._backend.find_many(
+            self, 
+            where=where, include=include, order_by=order_by, 
+            take=take, skip=skip
+        )
+
+    def find_first(self, *, where: UserBookWhereDict | None = None, include: UserBookIncludeDict | None = None, order_by: UserBookOrderByDict | None = None, skip: int | None = None) -> UserBook | None:
+        return self._backend.find_first(
+            self, 
+            where=where, include=include, order_by=order_by, 
+            skip=skip
+        )
+
+class Client(BaseDBPool):
+    datasources = {
+        'sqlite': DataSourceConfig(provider='sqlite', url='sqlite:///test.db', name=None),
+    }
+
+    @classmethod
+    @save_local
+    def _backend_sqlite(cls) -> BackendProtocol:
+        config = cls.datasources['sqlite']
+        if config.provider == 'sqlite':
+            from dclassql.runtime.backends.sqlite import SQLiteBackend
+            conn = open_sqlite_connection(config.url)
+            cls._setup_sqlite_db(conn)
+            return SQLiteBackend(conn)
+        raise ValueError(f"Unsupported provider '{config.provider}' for datasource 'sqlite'")
+
+    def __init__(self) -> None:
+        self.address = AddressTable(self._backend_sqlite())
+        self.birth_day = BirthDayTable(self._backend_sqlite())
+        self.book = BookTable(self._backend_sqlite())
+        self.user = UserTable(self._backend_sqlite())
+        self.user_book = UserBookTable(self._backend_sqlite())
+
+    @classmethod
+    def close_all(cls, verbose: bool = False) -> None:
+        super().close_all(verbose=verbose)
+        if hasattr(cls._local, '_backend_sqlite'):
+            backend = getattr(cls._local, '_backend_sqlite')
+            if hasattr(backend, 'close') and callable(getattr(backend, 'close')):
+                backend.close()
+            delattr(cls._local, '_backend_sqlite')
+
+__all__ = (
+    "DataSourceConfig",
+    "ForeignKeySpec",
+    "Client",
+    "TAddressIncludeCol",
+    "TAddressSortableCol",
+    "AddressIncludeDict",
+    "AddressOrderByDict",
+    "AddressInsert",
+    "AddressInsertDict",
+    "AddressWhereDict",
+    "AddressTable",
+    "TBirthDayIncludeCol",
+    "TBirthDaySortableCol",
+    "BirthDayIncludeDict",
+    "BirthDayOrderByDict",
+    "BirthDayInsert",
+    "BirthDayInsertDict",
+    "BirthDayWhereDict",
+    "BirthDayTable",
+    "TBookIncludeCol",
+    "TBookSortableCol",
+    "BookIncludeDict",
+    "BookOrderByDict",
+    "BookInsert",
+    "BookInsertDict",
+    "BookWhereDict",
+    "BookTable",
+    "TUserIncludeCol",
+    "TUserSortableCol",
+    "UserIncludeDict",
+    "UserOrderByDict",
+    "UserInsert",
+    "UserInsertDict",
+    "UserWhereDict",
+    "UserTable",
+    "TUserBookIncludeCol",
+    "TUserBookSortableCol",
+    "UserBookIncludeDict",
+    "UserBookOrderByDict",
+    "UserBookInsert",
+    "UserBookInsertDict",
+    "UserBookWhereDict",
+    "UserBookTable",
+)