X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=plomtask%2Fdb.py;h=deeb748de0b427b1ff2f999e58713d3cee4e7807;hb=23012cd370777b60a25839788d131173d2abee91;hp=dd2ee2452a7480878c47b38f2669c08cee229ca6;hpb=87505e3be37ad7a208c8f77dc7d7631728d87fa4;p=plomtask

diff --git a/plomtask/db.py b/plomtask/db.py
index dd2ee24..deeb748 100644
--- a/plomtask/db.py
+++ b/plomtask/db.py
@@ -1,9 +1,10 @@
 """Database management."""
+from __future__ import annotations
 from os.path import isfile
 from difflib import Differ
 from sqlite3 import connect as sql_connect, Cursor, Row
-from typing import Any, Dict
-from plomtask.exceptions import HandledException
+from typing import Any, Self, TypeVar, Generic
+from plomtask.exceptions import HandledException, NotFoundException
 
 PATH_DB_SCHEMA = 'scripts/init.sql'
 EXPECTED_DB_VERSION = 0
@@ -61,11 +62,6 @@ class DatabaseConnection:
     def __init__(self, db_file: DatabaseFile) -> None:
         self.file = db_file
         self.conn = sql_connect(self.file.path)
-        self.cached_todos: Dict[int, Any] = {}
-        self.cached_days: Dict[str, Any] = {}
-        self.cached_process_steps: Dict[int, Any] = {}
-        self.cached_processes: Dict[int, Any] = {}
-        self.cached_conditions: Dict[int, Any] = {}
 
     def commit(self) -> None:
         """Commit SQL transaction."""
@@ -106,7 +102,8 @@ class DatabaseConnection:
         return [row[0] for row in
                 self.exec(f'SELECT {column} FROM {table_name}')]
 
-    def delete_where(self, table_name: str, key: str, target: int) -> None:
+    def delete_where(self, table_name: str, key: str,
+                     target: int | str) -> None:
         """Delete from table where key == target."""
         self.exec(f'DELETE FROM {table_name} WHERE {key} = ?', (target,))
 
@@ -116,47 +113,115 @@ class DatabaseConnection:
         return '(' + ','.join(['?'] * len(values)) + ')'
 
 
-class BaseModel:
+BaseModelId = TypeVar('BaseModelId', int, str)
+BaseModelInstance = TypeVar('BaseModelInstance', bound='BaseModel[Any]')
+
+
+class BaseModel(Generic[BaseModelId]):
     """Template for most of the models we use/derive from the DB."""
     table_name = ''
     to_save: list[str] = []
-    id_: None | int | str
-    id_type: type[Any] = int
+    id_: None | BaseModelId
+    cache_: dict[BaseModelId, Self]
+
+    def __init__(self, id_: BaseModelId | None) -> None:
+        if isinstance(id_, int) and id_ < 1:
+            msg = f'illegal {self.__class__.__name__} ID, must be >=1: {id_}'
+            raise HandledException(msg)
+        self.id_ = id_
+
+    @classmethod
+    def get_cached(cls: type[BaseModelInstance],
+                   id_: BaseModelId) -> BaseModelInstance | None:
+        """Get object of id_ from class's cache, or None if not found."""
+        # pylint: disable=consider-iterating-dictionary
+        cache = cls.get_cache()
+        if id_ in cache.keys():
+            obj = cache[id_]
+            assert isinstance(obj, cls)
+            return obj
+        return None
+
+    @classmethod
+    def empty_cache(cls) -> None:
+        """Empty class's cache."""
+        cls.cache_ = {}
+
+    @classmethod
+    def get_cache(cls: type[BaseModelInstance]) -> dict[Any, BaseModel[Any]]:
+        """Get cache dictionary, create it if not yet existing."""
+        if not hasattr(cls, 'cache_'):
+            d: dict[Any, BaseModel[Any]] = {}
+            cls.cache_ = d
+        return cls.cache_
+
+    def cache(self) -> None:
+        """Update object in class's cache."""
+        if self.id_ is None:
+            raise HandledException('Cannot cache object without ID.')
+        cache = self.__class__.get_cache()
+        cache[self.id_] = self
+
+    def uncache(self) -> None:
+        """Remove self from cache."""
+        if self.id_ is None:
+            raise HandledException('Cannot un-cache object without ID.')
+        cache = self.__class__.get_cache()
+        del cache[self.id_]
 
     @classmethod
-    def from_table_row(cls, db_conn: DatabaseConnection,
-                       row: Row | list[Any]) -> Any:
+    def from_table_row(cls: type[BaseModelInstance],
+                       # pylint: disable=unused-argument
+                       db_conn: DatabaseConnection,
+                       row: Row | list[Any]) -> BaseModelInstance:
         """Make from DB row, write to DB cache."""
         obj = cls(*row)
-        assert isinstance(obj.id_, cls.id_type)
-        cache = getattr(db_conn, f'cached_{cls.table_name}')
-        cache[obj.id_] = obj
+        obj.cache()
         return obj
 
     @classmethod
-    def _by_id(cls,
-               db_conn: DatabaseConnection,
-               id_: int | str) -> tuple[Any, bool]:
+    def _by_id(cls, db_conn: DatabaseConnection,
+               id_: BaseModelId) -> Self | None:
         """Return instance found by ID, or None, and if from cache or not."""
-        from_cache = False
-        obj = None
-        cache = getattr(db_conn, f'cached_{cls.table_name}')
-        if id_ in cache.keys():
-            obj = cache[id_]
-            from_cache = True
-        else:
+        obj = cls.get_cached(id_)
+        if not obj:
             for row in db_conn.row_where(cls.table_name, 'id', id_):
                 obj = cls.from_table_row(db_conn, row)
-                cache[id_] = obj
+                obj.cache()
                 break
-        return obj, from_cache
+        return obj
 
-    def set_int_id(self, id_: int | None) -> None:
-        """Set id_ if >= 1 or None, else fail."""
-        if (id_ is not None) and id_ < 1:
-            msg = f'illegal {self.__class__.__name__} ID, must be >=1: {id_}'
-            raise HandledException(msg)
-        self.id_ = id_
+    @classmethod
+    def by_id(cls, db_conn: DatabaseConnection,
+              id_: BaseModelId | None,
+              # pylint: disable=unused-argument
+              create: bool = False) -> Self:
+        """Retrieve by id_, on failure throw NotFoundException."""
+        obj = None
+        if id_ is not None:
+            obj = cls._by_id(db_conn, id_)
+        if obj:
+            return obj
+        if create:
+            obj = cls(id_)
+            return obj
+        raise NotFoundException(f'found no object of ID {id_}')
+
+    @classmethod
+    def all(cls: type[BaseModelInstance],
+            db_conn: DatabaseConnection) -> list[BaseModelInstance]:
+        """Collect all objects of class."""
+        items: dict[BaseModelId, BaseModelInstance] = {}
+        for k, v in cls.get_cache().items():
+            assert isinstance(v, cls)
+            items[k] = v
+        already_recorded = items.keys()
+        for id_ in db_conn.column_all(cls.table_name, 'id'):
+            if id_ not in already_recorded:
+                item = cls.by_id(db_conn, id_)
+                assert item.id_ is not None
+                items[item.id_] = item
+        return list(items.values())
 
     def save_core(self, db_conn: DatabaseConnection,
                   update_with_lastrowid: bool = True) -> None:
@@ -168,6 +233,11 @@ class BaseModel:
         cursor = db_conn.exec(f'REPLACE INTO {table_name} VALUES {q_marks}',
                               values)
         if update_with_lastrowid:
-            self.id_ = cursor.lastrowid
-        cache = getattr(db_conn, f'cached_{table_name}')
-        cache[self.id_] = self
+            self.id_ = cursor.lastrowid  # type: ignore[assignment]
+        self.cache()
+
+    def remove(self, db_conn: DatabaseConnection) -> None:
+        """Remove from DB."""
+        assert isinstance(self.id_, int | str)
+        self.uncache()
+        db_conn.delete_where(self.table_name, 'id', self.id_)