eventsourcing 9.3.4__py3-none-any.whl → 9.4.0__py3-none-any.whl

eventsourcing/sqlite.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import sqlite3
 from contextlib import contextmanager
-from typing import TYPE_CHECKING, Any, Iterator, List, Sequence, Type
+from typing import TYPE_CHECKING, Any
 from uuid import UUID
 
 from eventsourcing.persistence import (
@@ -23,12 +23,16 @@ from eventsourcing.persistence import (
     PersistenceError,
     ProcessRecorder,
     ProgrammingError,
+    Recorder,
     StoredEvent,
+    Subscription,
     Tracking,
+    TrackingRecorder,
 )
-from eventsourcing.utils import Environment, strtobool
+from eventsourcing.utils import Environment, resolve_topic, strtobool
 
-if TYPE_CHECKING:  # pragma: nocover
+if TYPE_CHECKING:
+    from collections.abc import Iterator, Sequence
     from types import TracebackType
 
 SQLITE3_DEFAULT_LOCK_TIMEOUT = 5
@@ -100,7 +104,7 @@ class SQLiteTransaction:
 
     def __exit__(
         self,
-        exc_type: Type[BaseException] | None,
+        exc_type: type[BaseException] | None,
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
     ) -> None:
@@ -242,16 +246,32 @@ class SQLiteDatastore:
         self.close()
 
 
-class SQLiteAggregateRecorder(AggregateRecorder):
+class SQLiteRecorder(Recorder):
     def __init__(
         self,
         datastore: SQLiteDatastore,
-        events_table_name: str = "stored_events",
     ):
         assert isinstance(datastore, SQLiteDatastore)
         self.datastore = datastore
-        self.events_table_name = events_table_name
         self.create_table_statements = self.construct_create_table_statements()
+
+    def construct_create_table_statements(self) -> list[str]:
+        return []
+
+    def create_table(self) -> None:
+        with self.datastore.transaction(commit=True) as c:
+            for statement in self.create_table_statements:
+                c.execute(statement)
+
+
+class SQLiteAggregateRecorder(SQLiteRecorder, AggregateRecorder):
+    def __init__(
+        self,
+        datastore: SQLiteDatastore,
+        events_table_name: str = "stored_events",
+    ):
+        self.events_table_name = events_table_name
+        super().__init__(datastore)
         self.insert_events_statement = (
             f"INSERT INTO {self.events_table_name} VALUES (?,?,?,?)"
         )
@@ -259,8 +279,9 @@ class SQLiteAggregateRecorder(AggregateRecorder):
             f"SELECT * FROM {self.events_table_name} WHERE originator_id=? "
         )
 
-    def construct_create_table_statements(self) -> List[str]:
-        statement = (
+    def construct_create_table_statements(self) -> list[str]:
+        statements = super().construct_create_table_statements()
+        statements.append(
             "CREATE TABLE IF NOT EXISTS "
             f"{self.events_table_name} ("
             "originator_id TEXT, "
@@ -271,15 +292,10 @@ class SQLiteAggregateRecorder(AggregateRecorder):
             "(originator_id, originator_version)) "
             "WITHOUT ROWID"
         )
-        return [statement]
-
-    def create_table(self) -> None:
-        with self.datastore.transaction(commit=True) as c:
-            for statement in self.create_table_statements:
-                c.execute(statement)
+        return statements
 
     def insert_events(
-        self, stored_events: List[StoredEvent], **kwargs: Any
+        self, stored_events: list[StoredEvent], **kwargs: Any
     ) -> Sequence[int] | None:
         with self.datastore.transaction(commit=True) as c:
             return self._insert_events(c, stored_events, **kwargs)
@@ -287,7 +303,7 @@ class SQLiteAggregateRecorder(AggregateRecorder):
     def _insert_events(
         self,
         c: SQLiteCursor,
-        stored_events: List[StoredEvent],
+        stored_events: list[StoredEvent],
         **_: Any,
     ) -> Sequence[int] | None:
         params = [
@@ -310,9 +326,9 @@ class SQLiteAggregateRecorder(AggregateRecorder):
         lte: int | None = None,
         desc: bool = False,
         limit: int | None = None,
-    ) -> List[StoredEvent]:
+    ) -> list[StoredEvent]:
         statement = self.select_events_statement
-        params: List[Any] = [originator_id.hex]
+        params: list[Any] = [originator_id.hex]
         if gt is not None:
             statement += "AND originator_version>? "
             params.append(gt)
@@ -354,7 +370,7 @@ class SQLiteApplicationRecorder(
             f"SELECT MAX(rowid) FROM {self.events_table_name}"
         )
 
-    def construct_create_table_statements(self) -> List[str]:
+    def construct_create_table_statements(self) -> list[str]:
         statement = (
             "CREATE TABLE IF NOT EXISTS "
             f"{self.events_table_name} ("
@@ -370,7 +386,7 @@ class SQLiteApplicationRecorder(
     def _insert_events(
         self,
         c: SQLiteCursor,
-        stored_events: List[StoredEvent],
+        stored_events: list[StoredEvent],
         **_: Any,
     ) -> Sequence[int] | None:
         returning = []
@@ -389,25 +405,44 @@ class SQLiteApplicationRecorder(
 
     def select_notifications(
         self,
-        start: int,
+        start: int | None,
         limit: int,
         stop: int | None = None,
         topics: Sequence[str] = (),
-    ) -> List[Notification]:
-        """
-        Returns a list of event notifications
+        *,
+        inclusive_of_start: bool = True,
+    ) -> list[Notification]:
+        """Returns a list of event notifications
         from 'start', limited by 'limit'.
         """
-        params: List[int | str] = [start]
-        statement = f"SELECT rowid, * FROM {self.events_table_name} WHERE rowid>=? "
+        params: list[int | str] = []
+        statement = f"SELECT rowid, * FROM {self.events_table_name} "
+        has_where = False
+        if start is not None:
+            has_where = True
+            statement += "WHERE "
+            params.append(start)
+            if inclusive_of_start:
+                statement += "rowid>=? "
+            else:
+                statement += "rowid>? "
 
         if stop is not None:
+            if not has_where:
+                has_where = True
+                statement += "WHERE "
+            else:
+                statement += "AND "
             params.append(stop)
-            statement += "AND rowid<=? "
+            statement += "rowid<=? "
 
         if topics:
+            if not has_where:
+                statement += "WHERE "
+            else:
+                statement += "AND "
             params += list(topics)
-            statement += "AND topic IN (%s) " % ",".join("?" * len(topics))
+            statement += f"topic IN ({','.join('?' * len(topics))}) "
 
         params.append(limit)
         statement += "ORDER BY rowid LIMIT ?"
@@ -426,27 +461,29 @@ class SQLiteApplicationRecorder(
             ]
 
     def max_notification_id(self) -> int:
-        """
-        Returns the maximum notification ID.
-        """
+        """Returns the maximum notification ID."""
         with self.datastore.transaction(commit=False) as c:
             return self._max_notification_id(c)
 
     def _max_notification_id(self, c: SQLiteCursor) -> int:
         c.execute(self.select_max_notification_id_statement)
-        return c.fetchone()[0] or 0
+        return c.fetchone()[0]
 
+    def subscribe(
+        self, gt: int | None = None, topics: Sequence[str] = ()
+    ) -> Subscription[ApplicationRecorder]:
+        """This method is not implemented on this class."""
+        msg = f"The {type(self).__qualname__} recorder does not support subscriptions"
+        raise NotImplementedError(msg)
 
-class SQLiteProcessRecorder(
-    SQLiteApplicationRecorder,
-    ProcessRecorder,
-):
+
+class SQLiteTrackingRecorder(SQLiteRecorder, TrackingRecorder):
     def __init__(
         self,
         datastore: SQLiteDatastore,
-        events_table_name: str = "stored_events",
+        **kwargs: Any,
     ):
-        super().__init__(datastore, events_table_name)
+        super().__init__(datastore, **kwargs)
         self.insert_tracking_statement = "INSERT INTO tracking VALUES (?,?)"
         self.select_max_tracking_id_statement = (
             "SELECT MAX(notification_id) FROM tracking WHERE application_name=?"
@@ -456,7 +493,7 @@ class SQLiteProcessRecorder(
             "application_name=? AND notification_id=?"
         )
 
-    def construct_create_table_statements(self) -> List[str]:
+    def construct_create_table_statements(self) -> list[str]:
         statements = super().construct_create_table_statements()
         statements.append(
             "CREATE TABLE IF NOT EXISTS tracking ("
@@ -468,44 +505,74 @@ class SQLiteProcessRecorder(
         )
         return statements
 
-    def max_tracking_id(self, application_name: str) -> int:
+    def insert_tracking(self, tracking: Tracking) -> None:
+        with self.datastore.transaction(commit=True) as c:
+            self._insert_tracking(c, tracking)
+
+    def _insert_tracking(
+        self,
+        c: SQLiteCursor,
+        tracking: Tracking,
+    ) -> None:
+        c.execute(
+            self.insert_tracking_statement,
+            (
+                tracking.application_name,
+                tracking.notification_id,
+            ),
+        )
+
+    def max_tracking_id(self, application_name: str) -> int | None:
         params = [application_name]
         with self.datastore.transaction(commit=False) as c:
             c.execute(self.select_max_tracking_id_statement, params)
-            return c.fetchone()[0] or 0
+            return c.fetchone()[0]
 
-    def has_tracking_id(self, application_name: str, notification_id: int) -> bool:
+    def has_tracking_id(
+        self, application_name: str, notification_id: int | None
+    ) -> bool:
+        if notification_id is None:
+            return True
         params = [application_name, notification_id]
         with self.datastore.transaction(commit=False) as c:
             c.execute(self.count_tracking_id_statement, params)
             return bool(c.fetchone()[0])
 
+
+class SQLiteProcessRecorder(
+    SQLiteTrackingRecorder,
+    SQLiteApplicationRecorder,
+    ProcessRecorder,
+):
+    def __init__(
+        self,
+        datastore: SQLiteDatastore,
+        *,
+        events_table_name: str = "stored_events",
+    ):
+        super().__init__(datastore, events_table_name=events_table_name)
+
     def _insert_events(
         self,
         c: SQLiteCursor,
-        stored_events: List[StoredEvent],
+        stored_events: list[StoredEvent],
         **kwargs: Any,
     ) -> Sequence[int] | None:
         returning = super()._insert_events(c, stored_events, **kwargs)
-        tracking: Tracking | None = kwargs.get("tracking", None)
+        tracking: Tracking | None = kwargs.get("tracking")
         if tracking is not None:
-            c.execute(
-                self.insert_tracking_statement,
-                (
-                    tracking.application_name,
-                    tracking.notification_id,
-                ),
-            )
+            self._insert_tracking(c, tracking)
         return returning
 
 
-class Factory(InfrastructureFactory):
+class SQLiteFactory(InfrastructureFactory[SQLiteTrackingRecorder]):
     SQLITE_DBNAME = "SQLITE_DBNAME"
     SQLITE_LOCK_TIMEOUT = "SQLITE_LOCK_TIMEOUT"
     CREATE_TABLE = "CREATE_TABLE"
 
     aggregate_recorder_class = SQLiteAggregateRecorder
     application_recorder_class = SQLiteApplicationRecorder
+    tracking_recorder_class = SQLiteTrackingRecorder
     process_recorder_class = SQLiteProcessRecorder
 
     def __init__(self, env: Environment):
@@ -549,13 +616,55 @@ class Factory(InfrastructureFactory):
         return recorder
 
     def application_recorder(self) -> ApplicationRecorder:
-        recorder = self.application_recorder_class(datastore=self.datastore)
+        application_recorder_topic = self.env.get(self.APPLICATION_RECORDER_TOPIC)
+
+        if application_recorder_topic:
+            application_recorder_class: type[SQLiteApplicationRecorder] = resolve_topic(
+                application_recorder_topic
+            )
+            assert issubclass(application_recorder_class, SQLiteApplicationRecorder)
+        else:
+            application_recorder_class = self.application_recorder_class
+
+        recorder = application_recorder_class(datastore=self.datastore)
+
+        if self.env_create_table():
+            recorder.create_table()
+        return recorder
+
+    def tracking_recorder(
+        self, tracking_recorder_class: type[SQLiteTrackingRecorder] | None = None
+    ) -> SQLiteTrackingRecorder:
+        if tracking_recorder_class is None:
+            tracking_recorder_topic = self.env.get(self.TRACKING_RECORDER_TOPIC)
+
+            if tracking_recorder_topic:
+                tracking_recorder_class = resolve_topic(tracking_recorder_topic)
+            else:
+                tracking_recorder_class = self.tracking_recorder_class
+
+        assert tracking_recorder_class is not None
+        assert issubclass(tracking_recorder_class, SQLiteTrackingRecorder)
+
+        recorder = tracking_recorder_class(datastore=self.datastore)
+
         if self.env_create_table():
             recorder.create_table()
         return recorder
 
     def process_recorder(self) -> ProcessRecorder:
-        recorder = self.process_recorder_class(datastore=self.datastore)
+        process_recorder_topic = self.env.get(self.PROCESS_RECORDER_TOPIC)
+
+        if process_recorder_topic:
+            process_recorder_class: type[SQLiteProcessRecorder] = resolve_topic(
+                process_recorder_topic
+            )
+            assert issubclass(process_recorder_class, SQLiteProcessRecorder)
+        else:
+            process_recorder_class = self.process_recorder_class
+
+        recorder = process_recorder_class(datastore=self.datastore)
+
         if self.env_create_table():
             recorder.create_table()
         return recorder
@@ -566,3 +675,6 @@ class Factory(InfrastructureFactory):
 
     def close(self) -> None:
         self.datastore.close()
+
+
+Factory = SQLiteFactory