1 """Database management."""
2 from os.path import isfile
3 from difflib import Differ
4 from sqlite3 import connect as sql_connect, Cursor, Row
5 from typing import Any, Dict
6 from plomtask.exceptions import HandledException
8 PATH_DB_SCHEMA = 'scripts/init.sql'
11 class DatabaseFile: # pylint: disable=too-few-public-methods
12 """Represents the sqlite3 database's file."""
14 def __init__(self, path: str) -> None:
18 def remake(self) -> None:
19 """Create tables in self.path file as per PATH_DB_SCHEMA sql file."""
20 with sql_connect(self.path) as conn:
21 with open(PATH_DB_SCHEMA, 'r', encoding='utf-8') as f:
22 conn.executescript(f.read())
25 def _check(self) -> None:
26 """Check file exists, and is of proper schema."""
27 self.exists = isfile(self.path)
29 self._validate_schema()
31 def _validate_schema(self) -> None:
32 """Compare found schema with what's stored at PATH_DB_SCHEMA."""
33 sql_for_schema = 'SELECT sql FROM sqlite_master ORDER BY sql'
34 msg_err = 'Database has wrong tables schema. Diff:\n'
35 with sql_connect(self.path) as conn:
36 schema_rows = [r[0] for r in conn.execute(sql_for_schema) if r[0]]
37 retrieved_schema = ';\n'.join(schema_rows) + ';'
38 with open(PATH_DB_SCHEMA, 'r', encoding='utf-8') as f:
39 stored_schema = f.read().rstrip()
40 if stored_schema != retrieved_schema:
41 diff_msg = Differ().compare(retrieved_schema.splitlines(),
42 stored_schema.splitlines())
43 raise HandledException(msg_err + '\n'.join(diff_msg))
46 class DatabaseConnection:
47 """A single connection to the database."""
49 def __init__(self, db_file: DatabaseFile) -> None:
51 self.conn = sql_connect(self.file.path)
52 self.cached_todos: Dict[int, Any] = {}
53 self.cached_days: Dict[str, Any] = {}
54 self.cached_process_steps: Dict[int, Any] = {}
55 self.cached_processes: Dict[int, Any] = {}
56 self.cached_conditions: Dict[int, Any] = {}
58 def commit(self) -> None:
59 """Commit SQL transaction."""
62 def exec(self, code: str, inputs: tuple[Any, ...] = tuple()) -> Cursor:
63 """Add commands to SQL transaction."""
64 return self.conn.execute(code, inputs)
66 def close(self) -> None:
67 """Close DB connection."""
70 def rewrite_relations(self, table_name: str, key: str, target: int,
71 rows: list[list[Any]]) -> None:
72 """Rewrite relations in table_name to target, with rows values."""
73 self.exec(f'DELETE FROM {table_name} WHERE {key} = ?', (target,))
75 values = tuple([target] + row)
76 q_marks = self.__class__.q_marks_from_values(values)
77 self.exec(f'INSERT INTO {table_name} VALUES {q_marks}', values)
79 def all_where(self, table_name: str, key: str, target: int) -> list[Row]:
80 """Return list of Rows at table where key == target."""
81 return list(self.exec(f'SELECT * FROM {table_name} WHERE {key} = ?',
85 def q_marks_from_values(values: tuple[Any]) -> str:
86 """Return placeholder to insert values into SQL code."""
87 return '(' + ','.join(['?'] * len(values)) + ')'
91 """Template for most of the models we use/derive from the DB."""
93 to_save: list[str] = []
95 id_type: type[Any] = int
98 def from_table_row(cls, db_conn: DatabaseConnection,
99 row: Row | list[Any]) -> Any:
100 """Make from DB row, write to DB cache."""
102 assert isinstance(obj.id_, cls.id_type)
103 cache = getattr(db_conn, f'cached_{cls.table_name}')
109 db_conn: DatabaseConnection,
110 id_: int | str) -> tuple[Any, bool]:
111 """Return instance found by ID, or None, and if from cache or not."""
114 cache = getattr(db_conn, f'cached_{cls.table_name}')
115 if id_ in cache.keys():
119 for row in db_conn.exec(f'SELECT * FROM {cls.table_name} '
120 'WHERE id = ?', (id_,)):
121 obj = cls.from_table_row(db_conn, row)
124 return obj, from_cache
126 def set_int_id(self, id_: int | None) -> None:
127 """Set id_ if >= 1 or None, else fail."""
128 if (id_ is not None) and id_ < 1:
129 msg = f'illegal {self.__class__.__name__} ID, must be >=1: {id_}'
130 raise HandledException(msg)
133 def save_core(self, db_conn: DatabaseConnection,
134 update_with_lastrowid: bool = True) -> None:
135 """Write bare-bones self (sans connected items), ensuring self.id_."""
136 values = tuple([self.id_] + [getattr(self, key)
137 for key in self.to_save])
138 q_marks = DatabaseConnection.q_marks_from_values(values)
139 table_name = self.table_name
140 cursor = db_conn.exec(f'REPLACE INTO {table_name} VALUES {q_marks}',
142 if update_with_lastrowid:
143 self.id_ = cursor.lastrowid
144 cache = getattr(db_conn, f'cached_{table_name}')
145 cache[self.id_] = self