X-Git-Url: https://plomlompom.com/repos/feed.xml?a=blobdiff_plain;f=plomtask%2Fdb.py;h=fe67e5cc799303efada094f510b537616a30bbd0;hb=4815fe5c7be508e67ceec144968a81bdd6a923d4;hp=bf633e2c9826f464c690b03b75dfda4a33df7234;hpb=89624d5e05480c832a079008bbb9992f411be0dd;p=plomtask diff --git a/plomtask/db.py b/plomtask/db.py index bf633e2..fe67e5c 100644 --- a/plomtask/db.py +++ b/plomtask/db.py @@ -1,11 +1,13 @@ """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 typing import Any, Self, TypeVar, Generic from plomtask.exceptions import HandledException PATH_DB_SCHEMA = 'scripts/init.sql' +EXPECTED_DB_VERSION = 0 class DatabaseFile: # pylint: disable=too-few-public-methods @@ -23,11 +25,22 @@ class DatabaseFile: # pylint: disable=too-few-public-methods self._check() def _check(self) -> None: - """Check file exists, and is of proper schema.""" + """Check file exists, and is of proper DB version and schema.""" self.exists = isfile(self.path) if self.exists: + self._validate_user_version() self._validate_schema() + def _validate_user_version(self) -> None: + """Compare DB user_version with EXPECTED_DB_VERSION.""" + sql_for_db_version = 'PRAGMA user_version' + with sql_connect(self.path) as conn: + db_version = list(conn.execute(sql_for_db_version))[0][0] + if db_version != EXPECTED_DB_VERSION: + msg = f'Wrong DB version, expected '\ + f'{EXPECTED_DB_VERSION}, got {db_version}.' + raise HandledException(msg) + def _validate_schema(self) -> None: """Compare found schema with what's stored at PATH_DB_SCHEMA.""" sql_for_schema = 'SELECT sql FROM sqlite_master ORDER BY sql' @@ -49,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.""" @@ -70,60 +78,138 @@ class DatabaseConnection: def rewrite_relations(self, table_name: str, key: str, target: int, rows: list[list[Any]]) -> None: """Rewrite relations in table_name to target, with rows values.""" - self.exec(f'DELETE FROM {table_name} WHERE {key} = ?', (target,)) + self.delete_where(table_name, key, target) for row in rows: values = tuple([target] + row) q_marks = self.__class__.q_marks_from_values(values) self.exec(f'INSERT INTO {table_name} VALUES {q_marks}', values) + def row_where(self, table_name: str, key: str, + target: int | str) -> list[Row]: + """Return list of Rows at table where key == target.""" + return list(self.exec(f'SELECT * FROM {table_name} WHERE {key} = ?', + (target,))) + + def column_where(self, table_name: str, column: str, key: str, + target: int | str) -> list[Any]: + """Return column of table where key == target.""" + return [row[0] for row in + self.exec(f'SELECT {column} FROM {table_name} ' + f'WHERE {key} = ?', (target,))] + + def column_all(self, table_name: str, column: str) -> list[Any]: + """Return complete column of table.""" + 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: + """Delete from table where key == target.""" + self.exec(f'DELETE FROM {table_name} WHERE {key} = ?', (target,)) + @staticmethod def q_marks_from_values(values: tuple[Any]) -> str: """Return placeholder to insert values into SQL code.""" 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] + + @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 from_table_row(cls, db_conn: DatabaseConnection, - row: Row | list[Any]) -> Any: + 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: 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]: + id_: BaseModelId) -> tuple[Self | None, bool]: """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_] + obj = cls.get_cached(id_) + if obj: from_cache = True else: - for row in db_conn.exec(f'SELECT * FROM {cls.table_name} ' - 'WHERE id = ?', (id_,)): + 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 + @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: + # pylint: disable=no-member + item = cls.by_id(db_conn, id_) # type: ignore[attr-defined] + items[item.id_] = item + return list(items.values()) + 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_ + self.id_ = id_ # type: ignore[assignment] def save_core(self, db_conn: DatabaseConnection, update_with_lastrowid: bool = True) -> None: @@ -135,6 +221,5 @@ 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()