eventsourcing 9.4.2__py3-none-any.whl → 9.4.4__py3-none-any.whl

eventsourcing/dispatch.py

@@ -63,7 +63,7 @@ class singledispatchmethod(_singledispatchmethod[_T]):  # noqa: N801
 
         try:
             return self.dispatcher.register(cast("type[Any]", cls), func=method)
-        except NameError:
+        except (NameError, TypeError):  # NameError <= Py3.13, TypeError >= Py3.14
             self.deferred_registrations.append(
                 (cls, method)  # pyright: ignore [reportArgumentType]
             )

eventsourcing/persistence.py

@@ -449,14 +449,17 @@ class TrackingRecorder(Recorder, ABC):
         for the named application, or None if no tracking objects have been recorded.
         """
 
-    @abstractmethod
     def has_tracking_id(
         self, application_name: str, notification_id: int | None
     ) -> bool:
-        """Returns True if a tracking object with the given application name
-        and notification ID has been recorded, and True if given notification_id is
-        None, otherwise returns False.
+        """Returns True if given notification_id is None or a tracking
+        object with the given application_name and a notification ID greater
+        than or equal to the given notification_id has been recorded.
         """
+        if notification_id is None:
+            return True
+        max_tracking_id = self.max_tracking_id(application_name)
+        return max_tracking_id is not None and max_tracking_id >= notification_id
 
     def wait(
         self,
@@ -483,10 +486,7 @@ class TrackingRecorder(Recorder, ABC):
         sleep_interval_ms = 100.0
         max_sleep_interval_ms = 800.0
         while True:
-            max_tracking_id = self.max_tracking_id(application_name)
-            if notification_id is None or (
-                max_tracking_id is not None and max_tracking_id >= notification_id
-            ):
+            if self.has_tracking_id(application_name, notification_id):
                 break
             if interrupt:
                 if interrupt.wait(timeout=sleep_interval_ms / 1000):

eventsourcing/popo.py

@@ -193,14 +193,14 @@ class POPOSubscription(ListenNotifySubscription[POPOApplicationRecorder]):
 class POPOTrackingRecorder(POPORecorder, TrackingRecorder):
     def __init__(self) -> None:
         super().__init__()
-        self._tracking_table: dict[str, set[int]] = defaultdict(set)
         self._max_tracking_ids: dict[str, int | None] = defaultdict(lambda: None)
 
     def _assert_tracking_uniqueness(self, tracking: Tracking) -> None:
-        if tracking.notification_id in self._tracking_table[tracking.application_name]:
+        max_tracking_id = self._max_tracking_ids[tracking.application_name]
+        if max_tracking_id is not None and max_tracking_id >= tracking.notification_id:
             msg = (
-                f"Already recorded notification ID {tracking.notification_id} "
-                f"for application {tracking.application_name}"
+                f"Tracking notification ID {tracking.notification_id} "
+                f"not greater than current max tracking ID {max_tracking_id}"
             )
             raise IntegrityError(msg)
 
@@ -210,23 +210,12 @@ class POPOTrackingRecorder(POPORecorder, TrackingRecorder):
             self._insert_tracking(tracking)
 
     def _insert_tracking(self, tracking: Tracking) -> None:
-        self._tracking_table[tracking.application_name].add(tracking.notification_id)
-        max_tracking_id = self._max_tracking_ids[tracking.application_name]
-        if max_tracking_id is None or max_tracking_id < tracking.notification_id:
-            self._max_tracking_ids[tracking.application_name] = tracking.notification_id
+        self._max_tracking_ids[tracking.application_name] = tracking.notification_id
 
     def max_tracking_id(self, application_name: str) -> int | None:
         with self._database_lock:
             return self._max_tracking_ids[application_name]
 
-    def has_tracking_id(
-        self, application_name: str, notification_id: int | None
-    ) -> bool:
-        if notification_id is None:
-            return True
-        with self._database_lock:
-            return notification_id in self._tracking_table[application_name]
-
 
 class POPOProcessRecorder(
     POPOTrackingRecorder, POPOApplicationRecorder, ProcessRecorder

eventsourcing/postgres.py

@@ -94,10 +94,12 @@ class PostgresDatastore:
         schema: str = "",
         pool_open_timeout: int | None = None,
         get_password_func: Callable[[], str] | None = None,
+        single_row_tracking: bool = True,
     ):
         self.idle_in_transaction_session_timeout = idle_in_transaction_session_timeout
         self.pre_ping = pre_ping
         self.pool_open_timeout = pool_open_timeout
+        self.single_row_tracking = single_row_tracking
 
         check = ConnectionPool.check_connection if pre_ping else None
         self.pool = ConnectionPool(
@@ -189,6 +191,12 @@ class PostgresDatastore:
 class PostgresRecorder:
     """Base class for recorders that use PostgreSQL."""
 
+    MAX_IDENTIFIER_LEN = 63
+    # From the PostgreSQL docs: "The system uses no more than NAMEDATALEN-1 bytes
+    # of an identifier; longer names can be written in commands, but they will be
+    # truncated. By default, NAMEDATALEN is 64 so the maximum identifier length is
+    # 63 bytes." https://www.postgresql.org/docs/current/sql-syntax-lexical.html
+
     def __init__(
         self,
         datastore: PostgresDatastore,
@@ -196,18 +204,22 @@ class PostgresRecorder:
         self.datastore = datastore
         self.create_table_statements = self.construct_create_table_statements()
 
-    def construct_create_table_statements(self) -> list[Composed]:
-        return []
-
-    def check_table_name_length(self, table_name: str) -> None:
-        if len(table_name) > 63:
+    @staticmethod
+    def check_table_name_length(table_name: str) -> None:
+        if len(table_name) > PostgresRecorder.MAX_IDENTIFIER_LEN:
             msg = f"Table name too long: {table_name}"
             raise ProgrammingError(msg)
 
+    def construct_create_table_statements(self) -> list[Composed]:
+        return []
+
     def create_table(self) -> None:
         with self.datastore.transaction(commit=True) as curs:
-            for statement in self.create_table_statements:
-                curs.execute(statement, prepare=False)
+            self._create_table(curs)
+
+    def _create_table(self, curs: Cursor[DictRow]) -> None:
+        for statement in self.create_table_statements:
+            curs.execute(statement, prepare=False)
 
 
 class PostgresAggregateRecorder(PostgresRecorder, AggregateRecorder):
@@ -610,25 +622,56 @@ class PostgresTrackingRecorder(PostgresRecorder, TrackingRecorder):
         super().__init__(datastore, **kwargs)
         self.check_table_name_length(tracking_table_name)
         self.tracking_table_name = tracking_table_name
-        self.create_table_statements.append(
-            SQL(
-                "CREATE TABLE IF NOT EXISTS {0}.{1} ("
-                "application_name text, "
-                "notification_id bigint, "
-                "PRIMARY KEY "
-                "(application_name, notification_id))"
+        self.tracking_table_exists: bool = False
+        self.tracking_migration_previous: int | None = None
+        self.tracking_migration_current: int | None = None
+        self.table_migration_identifier = "__migration__"
+        self.has_checked_for_multi_row_tracking_table: bool = False
+        if self.datastore.single_row_tracking:
+            # For single-row tracking.
+            self.create_table_statements.append(
+                SQL(
+                    "CREATE TABLE IF NOT EXISTS {0}.{1} ("
+                    "application_name text, "
+                    "notification_id bigint, "
+                    "PRIMARY KEY "
+                    "(application_name))"
+                ).format(
+                    Identifier(self.datastore.schema),
+                    Identifier(self.tracking_table_name),
+                )
+            )
+            self.insert_tracking_statement = SQL(
+                "INSERT INTO {0}.{1} "
+                "VALUES (%(application_name)s, %(notification_id)s) "
+                "ON CONFLICT (application_name) DO UPDATE "
+                "SET notification_id = %(notification_id)s "
+                "WHERE {0}.{1}.notification_id < %(notification_id)s "
+                "RETURNING notification_id"
+            ).format(
+                Identifier(self.datastore.schema),
+                Identifier(self.tracking_table_name),
+            )
+        else:
+            # For legacy multi-row tracking.
+            self.create_table_statements.append(
+                SQL(
+                    "CREATE TABLE IF NOT EXISTS {0}.{1} ("
+                    "application_name text, "
+                    "notification_id bigint, "
+                    "PRIMARY KEY "
+                    "(application_name, notification_id))"
+                ).format(
+                    Identifier(self.datastore.schema),
+                    Identifier(self.tracking_table_name),
+                )
+            )
+            self.insert_tracking_statement = SQL(
+                "INSERT INTO {0}.{1} VALUES (%(application_name)s, %(notification_id)s)"
             ).format(
                 Identifier(self.datastore.schema),
                 Identifier(self.tracking_table_name),
             )
-        )
-
-        self.insert_tracking_statement = SQL(
-            "INSERT INTO {0}.{1} VALUES (%s, %s)"
-        ).format(
-            Identifier(self.datastore.schema),
-            Identifier(self.tracking_table_name),
-        )
 
         self.max_tracking_id_statement = SQL(
             "SELECT MAX(notification_id) FROM {0}.{1} WHERE application_name=%s"
@@ -637,21 +680,85 @@ class PostgresTrackingRecorder(PostgresRecorder, TrackingRecorder):
             Identifier(self.tracking_table_name),
         )
 
-        self.count_tracking_id_statement = SQL(
-            "SELECT COUNT(*) FROM {0}.{1} "
-            "WHERE application_name=%s AND notification_id=%s"
-        ).format(
-            Identifier(self.datastore.schema),
-            Identifier(self.tracking_table_name),
-        )
+    def create_table(self) -> None:
+        # Get the migration version.
+        try:
+            self.tracking_migration_current = self.tracking_migration_previous = (
+                self.max_tracking_id(self.table_migration_identifier)
+            )
+        except ProgrammingError:
+            pass
+        else:
+            self.tracking_table_exists = True
+        super().create_table()
+        if (
+            not self.datastore.single_row_tracking
+            and self.tracking_migration_current is not None
+        ):
+            msg = "Can't do multi-row tracking with single-row tracking table"
+            raise OperationalError(msg)
+
+    def _create_table(self, curs: Cursor[DictRow]) -> None:
+        max_tracking_ids: dict[str, int] = {}
+        if (
+            self.datastore.single_row_tracking
+            and self.tracking_table_exists
+            and not self.tracking_migration_previous
+        ):
+            # Migrate the table.
+            curs.execute(
+                SQL("SET LOCAL lock_timeout = '{0}s'").format(
+                    self.datastore.lock_timeout
+                )
+            )
+            curs.execute(
+                SQL("LOCK TABLE {0}.{1} IN ACCESS EXCLUSIVE MODE").format(
+                    Identifier(self.datastore.schema),
+                    Identifier(self.tracking_table_name),
+                )
+            )
+
+            # Get all application names.
+            application_names: list[str] = [
+                select_row["application_name"]
+                for select_row in curs.execute(
+                    SQL("SELECT DISTINCT application_name FROM {0}.{1}").format(
+                        Identifier(self.datastore.schema),
+                        Identifier(self.tracking_table_name),
+                    )
+                )
+            ]
+
+            # Get max tracking ID for each application name.
+            for application_name in application_names:
+                curs.execute(self.max_tracking_id_statement, (application_name,))
+                max_tracking_id_row = curs.fetchone()
+                assert max_tracking_id_row is not None
+                max_tracking_ids[application_name] = max_tracking_id_row["max"]
+            # Rename the table.
+            rename = f"bkup1_{self.tracking_table_name}"[: self.MAX_IDENTIFIER_LEN]
+            drop_table_statement = SQL("ALTER TABLE {0}.{1} RENAME TO {2}").format(
+                Identifier(self.datastore.schema),
+                Identifier(self.tracking_table_name),
+                Identifier(rename),
+            )
+            curs.execute(drop_table_statement)
+        # Create the table.
+        super()._create_table(curs)
+        # Maybe insert migration tracking record and application tracking records.
+        if self.datastore.single_row_tracking and (
+            not self.tracking_table_exists
+            or (self.tracking_table_exists and not self.tracking_migration_previous)
+        ):
+            # Assume we just created a table for single-row tracking.
+            self._insert_tracking(curs, Tracking(self.table_migration_identifier, 1))
+            self.tracking_migration_current = 1
+            for application_name, max_tracking_id in max_tracking_ids.items():
+                self._insert_tracking(curs, Tracking(application_name, max_tracking_id))
 
     @retry((InterfaceError, OperationalError), max_attempts=10, wait=0.2)
     def insert_tracking(self, tracking: Tracking) -> None:
-        with (
-            self.datastore.get_connection() as conn,
-            conn.transaction(),
-            conn.cursor() as curs,
-        ):
+        with self.datastore.transaction(commit=True) as curs:
             self._insert_tracking(curs, tracking)
 
     def _insert_tracking(
@@ -659,42 +766,57 @@ class PostgresTrackingRecorder(PostgresRecorder, TrackingRecorder):
         curs: Cursor[DictRow],
         tracking: Tracking,
     ) -> None:
+        self._check_has_multi_row_tracking_table(curs)
+
         curs.execute(
             query=self.insert_tracking_statement,
-            params=(
-                tracking.application_name,
-                tracking.notification_id,
-            ),
+            params={
+                "application_name": tracking.application_name,
+                "notification_id": tracking.notification_id,
+            },
             prepare=True,
         )
+        if self.datastore.single_row_tracking:
+            fetchone = curs.fetchone()
+            if fetchone is None:
+                msg = (
+                    "Failed to record tracking for "
+                    f"{tracking.application_name} {tracking.notification_id}"
+                )
+                raise IntegrityError(msg)
+
+    def _check_has_multi_row_tracking_table(self, c: Cursor[DictRow]) -> None:
+        if (
+            not self.datastore.single_row_tracking
+            and not self.has_checked_for_multi_row_tracking_table
+            and self._max_tracking_id(self.table_migration_identifier, c)
+        ):
+            msg = "Can't do multi-row tracking with single-row tracking table"
+            raise ProgrammingError(msg)
+        self.has_checked_for_multi_row_tracking_table = True
 
     @retry((InterfaceError, OperationalError), max_attempts=10, wait=0.2)
     def max_tracking_id(self, application_name: str) -> int | None:
         with self.datastore.get_connection() as conn, conn.cursor() as curs:
-            curs.execute(
-                query=self.max_tracking_id_statement,
-                params=(application_name,),
-                prepare=True,
-            )
-            fetchone = curs.fetchone()
-            assert fetchone is not None
-            return fetchone["max"]
+            return self._max_tracking_id(application_name, curs)
+
+    def _max_tracking_id(
+        self, application_name: str, curs: Cursor[DictRow]
+    ) -> int | None:
+        curs.execute(
+            query=self.max_tracking_id_statement,
+            params=(application_name,),
+            prepare=True,
+        )
+        fetchone = curs.fetchone()
+        assert fetchone is not None
+        return fetchone["max"]
 
     @retry((InterfaceError, OperationalError), max_attempts=10, wait=0.2)
     def has_tracking_id(
         self, application_name: str, notification_id: int | None
     ) -> bool:
-        if notification_id is None:
-            return True
-        with self.datastore.get_connection() as conn, conn.cursor() as curs:
-            curs.execute(
-                query=self.count_tracking_id_statement,
-                params=(application_name, notification_id),
-                prepare=True,
-            )
-            fetchone = curs.fetchone()
-            assert fetchone is not None
-            return bool(fetchone["count"])
+        return super().has_tracking_id(application_name, notification_id)
 
 
 TPostgresTrackingRecorder = TypeVar(
@@ -750,6 +872,7 @@ class PostgresFactory(InfrastructureFactory[PostgresTrackingRecorder]):
         "POSTGRES_IDLE_IN_TRANSACTION_SESSION_TIMEOUT"
     )
     POSTGRES_SCHEMA = "POSTGRES_SCHEMA"
+    POSTGRES_SINGLE_ROW_TRACKING = "SINGLE_ROW_TRACKING"
     CREATE_TABLE = "CREATE_TABLE"
 
     aggregate_recorder_class = PostgresAggregateRecorder
@@ -911,13 +1034,16 @@ class PostgresFactory(InfrastructureFactory[PostgresTrackingRecorder]):
 
         schema = self.env.get(self.POSTGRES_SCHEMA) or ""
 
+        single_row_tracking = strtobool(
+            self.env.get(self.POSTGRES_SINGLE_ROW_TRACKING, "t")
+        )
+
         self.datastore = PostgresDatastore(
             dbname=dbname,
             host=host,
             port=port,
             user=user,
             password=password,
-            get_password_func=get_password_func,
             connect_timeout=connect_timeout,
             idle_in_transaction_session_timeout=idle_in_transaction_session_timeout,
             pool_size=pool_size,
@@ -927,6 +1053,8 @@ class PostgresFactory(InfrastructureFactory[PostgresTrackingRecorder]):
             pre_ping=pre_ping,
             lock_timeout=lock_timeout,
             schema=schema,
+            get_password_func=get_password_func,
+            single_row_tracking=single_row_tracking,
         )
 
     def env_create_table(self) -> bool:

eventsourcing/projection.py

@@ -16,7 +16,6 @@ from eventsourcing.dispatch import singledispatchmethod
 from eventsourcing.domain import DomainEventProtocol
 from eventsourcing.persistence import (
     InfrastructureFactory,
-    IntegrityError,
     ProcessRecorder,
     Tracking,
     TrackingRecorder,
@@ -144,40 +143,27 @@ class EventSourcedProjection(Application, ABC):
     def process_event(
         self, domain_event: DomainEventProtocol, tracking: Tracking
     ) -> None:
-        """Calls :func:`~eventsourcing.system.Follower.policy` method with
-        the given :class:`~eventsourcing.domain.AggregateEvent` and a
-        new :class:`~eventsourcing.application.ProcessingEvent` created from
-        the given :class:`~eventsourcing.persistence.Tracking` object.
+        """Calls :func:`~eventsourcing.system.Follower.policy` method with the given
+        domain event and a new :class:`~eventsourcing.application.ProcessingEvent`
+        constructed with the given tracking object.
 
-        The policy will collect any new aggregate events on the process
+        The policy method should collect any new aggregate events on the process
         event object.
 
-        After the policy method returns, the process event object will
-        then be recorded by calling
-        :func:`~eventsourcing.application.Application.record`, which
-        will return new notifications.
+        After the policy method returns, the processing event object will be recorded
+        by calling :py:func:`~eventsourcing.application.Application._record`,
+        which then returns list of :py:class:`~eventsourcing.persistence.Recording`.
 
-        After calling
-        :func:`~eventsourcing.application.Application.take_snapshots`,
-        the new notifications are passed to the
-        :func:`~eventsourcing.application.Application.notify` method.
+        After calling :func:`~eventsourcing.application.Application._take_snapshots`,
+        the recordings are passed in a call to
+        :py:func:`~eventsourcing.application.Application._notify`.
         """
         processing_event = ProcessingEvent(tracking=tracking)
         self.policy(domain_event, processing_event)
-        try:
-            recordings = self._record(processing_event)
-        except IntegrityError:
-            if self.recorder.has_tracking_id(
-                tracking.application_name,
-                tracking.notification_id,
-            ):
-                pass
-            else:
-                raise
-        else:
-            self._take_snapshots(processing_event)
-            self.notify(processing_event.events)
-            self._notify(recordings)
+        recordings = self._record(processing_event)
+        self._take_snapshots(processing_event)
+        self.notify(processing_event.events)
+        self._notify(recordings)
 
     @singledispatchmethod
     def policy(

eventsourcing/sqlite.py

@@ -212,6 +212,7 @@ class SQLiteDatastore:
         pool_timeout: float = 5.0,
         max_age: float | None = None,
         pre_ping: bool = False,
+        single_row_tracking: bool = True,
     ):
         self.pool = SQLiteConnectionPool(
             db_name=db_name,
@@ -222,6 +223,7 @@ class SQLiteDatastore:
             max_age=max_age,
             pre_ping=pre_ping,
         )
+        self.single_row_tracking = single_row_tracking
 
     @contextmanager
     def transaction(self, *, commit: bool) -> Iterator[SQLiteCursor]:
@@ -260,8 +262,11 @@ class SQLiteRecorder(Recorder):
 
     def create_table(self) -> None:
         with self.datastore.transaction(commit=True) as c:
-            for statement in self.create_table_statements:
-                c.execute(statement)
+            self._create_table(c)
+
+    def _create_table(self, c: SQLiteCursor) -> None:
+        for statement in self.create_table_statements:
+            c.execute(statement)
 
 
 class SQLiteAggregateRecorder(SQLiteRecorder, AggregateRecorder):
@@ -484,27 +489,104 @@ class SQLiteTrackingRecorder(SQLiteRecorder, TrackingRecorder):
         **kwargs: Any,
     ):
         super().__init__(datastore, **kwargs)
-        self.insert_tracking_statement = "INSERT INTO tracking VALUES (?,?)"
+        self.tracking_table_exists: bool = False
+        self.tracking_migration_previous: int | None = None
+        self.tracking_migration_current: int | None = None
+        self.table_migration_identifier = "__migration__"
+        self.has_checked_for_multi_row_tracking_table: bool = False
+        if self.datastore.single_row_tracking:
+            self.insert_tracking_statement = (
+                "INSERT INTO tracking "
+                "VALUES (:application_name, :notification_id) "
+                "ON CONFLICT (application_name) DO UPDATE "
+                "SET notification_id = :notification_id "
+                "WHERE tracking.notification_id < :notification_id "
+                "RETURNING notification_id"
+            )
+        else:
+            self.insert_tracking_statement = (
+                "INSERT INTO tracking VALUES (:application_name, :notification_id)"
+            )
         self.select_max_tracking_id_statement = (
             "SELECT MAX(notification_id) FROM tracking WHERE application_name=?"
         )
-        self.count_tracking_id_statement = (
-            "SELECT COUNT(*) FROM tracking WHERE "
-            "application_name=? AND notification_id=?"
-        )
 
     def construct_create_table_statements(self) -> list[str]:
         statements = super().construct_create_table_statements()
-        statements.append(
-            "CREATE TABLE IF NOT EXISTS tracking ("
-            "application_name TEXT, "
-            "notification_id INTEGER, "
-            "PRIMARY KEY "
-            "(application_name, notification_id)) "
-            "WITHOUT ROWID"
-        )
+        if self.datastore.single_row_tracking:
+            statements.append(
+                "CREATE TABLE IF NOT EXISTS tracking ("
+                "application_name TEXT, "
+                "notification_id INTEGER, "
+                "PRIMARY KEY "
+                "(application_name)) "
+                "WITHOUT ROWID"
+            )
+        else:
+            statements.append(
+                "CREATE TABLE IF NOT EXISTS tracking ("
+                "application_name TEXT, "
+                "notification_id INTEGER, "
+                "PRIMARY KEY "
+                "(application_name, notification_id)) "
+                "WITHOUT ROWID"
+            )
         return statements
 
+    def create_table(self) -> None:
+        # Get the migration version.
+        try:
+            self.tracking_migration_current = self.tracking_migration_previous = (
+                self.max_tracking_id(self.table_migration_identifier)
+            )
+        except OperationalError:
+            pass
+        else:
+            self.tracking_table_exists = True
+        super().create_table()
+        if (
+            not self.datastore.single_row_tracking
+            and self.tracking_migration_current is not None
+        ):
+            msg = "Can't do multi-row tracking with single-row tracking table"
+            raise OperationalError(msg)
+
+    def _create_table(self, c: SQLiteCursor) -> None:
+        max_tracking_ids: dict[str, int] = {}
+        if (
+            self.datastore.single_row_tracking
+            and self.tracking_table_exists
+            and not self.tracking_migration_previous
+        ):
+            # Migrate tracking to use single-row per application name.
+            # - Get all application names.
+            c.execute("SELECT DISTINCT application_name FROM tracking")
+            application_names: list[str] = [
+                select_row["application_name"] for select_row in c.fetchall()
+            ]
+
+            # - Get max tracking ID for each application name.
+            for application_name in application_names:
+                c.execute(self.select_max_tracking_id_statement, (application_name,))
+                max_tracking_id_row = c.fetchone()
+                assert max_tracking_id_row is not None
+                max_tracking_ids[application_name] = max_tracking_id_row[0]
+            # - Rename the table.
+            drop_table_statement = "ALTER TABLE tracking RENAME TO old1_tracking"
+            c.execute(drop_table_statement)
+        # Create the table.
+        super()._create_table(c)
+        # - Maybe insert migration tracking record and application tracking records.
+        if self.datastore.single_row_tracking and (
+            not self.tracking_table_exists
+            or (self.tracking_table_exists and not self.tracking_migration_previous)
+        ):
+            # - Assume we just created a table for single-row tracking.
+            self._insert_tracking(c, Tracking(self.table_migration_identifier, 1))
+            self.tracking_migration_current = 1
+            for application_name, max_tracking_id in max_tracking_ids.items():
+                self._insert_tracking(c, Tracking(application_name, max_tracking_id))
+
     def insert_tracking(self, tracking: Tracking) -> None:
         with self.datastore.transaction(commit=True) as c:
             self._insert_tracking(c, tracking)
@@ -514,29 +596,42 @@ class SQLiteTrackingRecorder(SQLiteRecorder, TrackingRecorder):
         c: SQLiteCursor,
         tracking: Tracking,
     ) -> None:
+        self._check_has_multi_row_tracking_table(c)
+
         c.execute(
             self.insert_tracking_statement,
-            (
-                tracking.application_name,
-                tracking.notification_id,
-            ),
+            {
+                "application_name": tracking.application_name,
+                "notification_id": tracking.notification_id,
+            },
         )
+        if self.datastore.single_row_tracking:
+            fetchone = c.fetchone()
+            if fetchone is None:
+                msg = (
+                    "Failed to record tracking for "
+                    f"{tracking.application_name} {tracking.notification_id}"
+                )
+                raise IntegrityError(msg)
+
+    def _check_has_multi_row_tracking_table(self, c: SQLiteCursor) -> None:
+        if (
+            not self.datastore.single_row_tracking
+            and not self.has_checked_for_multi_row_tracking_table
+            and self._max_tracking_id(self.table_migration_identifier, c)
+        ):
+            msg = "Can't do multi-row tracking with single-row tracking table"
+            raise OperationalError(msg)
+        self.has_checked_for_multi_row_tracking_table = True
 
     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]
-
-    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])
+            return self._max_tracking_id(application_name, c)
+
+    def _max_tracking_id(self, application_name: str, c: SQLiteCursor) -> int | None:
+        params = [application_name]
+        c.execute(self.select_max_tracking_id_statement, params)
+        return c.fetchone()[0]
 
 
 class SQLiteProcessRecorder(
@@ -568,6 +663,7 @@ class SQLiteProcessRecorder(
 class SQLiteFactory(InfrastructureFactory[SQLiteTrackingRecorder]):
     SQLITE_DBNAME = "SQLITE_DBNAME"
     SQLITE_LOCK_TIMEOUT = "SQLITE_LOCK_TIMEOUT"
+    SQLITE_SINGLE_ROW_TRACKING = "SINGLE_ROW_TRACKING"
     CREATE_TABLE = "CREATE_TABLE"
 
     aggregate_recorder_class = SQLiteAggregateRecorder
@@ -603,7 +699,15 @@ class SQLiteFactory(InfrastructureFactory[SQLiteTrackingRecorder]):
                 )
                 raise OSError(msg) from None
 
-        self.datastore = SQLiteDatastore(db_name=db_name, lock_timeout=lock_timeout)
+        single_row_tracking = strtobool(
+            self.env.get(self.SQLITE_SINGLE_ROW_TRACKING, "t")
+        )
+
+        self.datastore = SQLiteDatastore(
+            db_name=db_name,
+            lock_timeout=lock_timeout,
+            single_row_tracking=single_row_tracking,
+        )
 
     def aggregate_recorder(self, purpose: str = "events") -> AggregateRecorder:
         events_table_name = "stored_" + purpose

eventsourcing/tests/persistence.py

@@ -761,15 +761,17 @@ class TrackingRecorderTestCase(TestCase, ABC):
         tracking_recorder = self.create_recorder()
 
         # Construct tracking objects.
-        tracking1 = Tracking(notification_id=21, application_name="upstream1")
-        tracking2 = Tracking(notification_id=22, application_name="upstream1")
-        tracking3 = Tracking(notification_id=21, application_name="upstream2")
+        tracking1 = Tracking("upstream1", 21)
+        tracking2 = Tracking("upstream1", 22)
+        tracking3 = Tracking("upstream2", 21)
 
         # Insert tracking objects.
         tracking_recorder.insert_tracking(tracking=tracking1)
         tracking_recorder.insert_tracking(tracking=tracking2)
         tracking_recorder.insert_tracking(tracking=tracking3)
 
+        # raise Exception(tracking_recorder.max_tracking_id(tracking1.application_name))
+
         # Fail to insert same tracking object twice.
         with self.assertRaises(IntegrityError):
             tracking_recorder.insert_tracking(tracking=tracking1)
@@ -778,16 +780,37 @@ class TrackingRecorderTestCase(TestCase, ABC):
         with self.assertRaises(IntegrityError):
             tracking_recorder.insert_tracking(tracking=tracking3)
 
-        # Get latest tracked position.
+        # Get max tracking ID.
         self.assertEqual(tracking_recorder.max_tracking_id("upstream1"), 22)
         self.assertEqual(tracking_recorder.max_tracking_id("upstream2"), 21)
         self.assertIsNone(tracking_recorder.max_tracking_id("upstream3"))
 
         # Check if an event notification has been processed.
-        assert tracking_recorder.has_tracking_id("upstream1", 21)
-        assert tracking_recorder.has_tracking_id("upstream1", 22)
-        assert tracking_recorder.has_tracking_id("upstream2", 21)
-        assert not tracking_recorder.has_tracking_id("upstream2", 22)
+        self.assertTrue(tracking_recorder.has_tracking_id("upstream1", None))
+        self.assertTrue(tracking_recorder.has_tracking_id("upstream1", 20))
+        self.assertTrue(tracking_recorder.has_tracking_id("upstream1", 21))
+        self.assertTrue(tracking_recorder.has_tracking_id("upstream1", 22))
+        self.assertFalse(tracking_recorder.has_tracking_id("upstream1", 23))
+
+        self.assertTrue(tracking_recorder.has_tracking_id("upstream2", None))
+        self.assertTrue(tracking_recorder.has_tracking_id("upstream2", 20))
+        self.assertTrue(tracking_recorder.has_tracking_id("upstream2", 21))
+        self.assertFalse(tracking_recorder.has_tracking_id("upstream2", 22))
+
+        self.assertTrue(tracking_recorder.has_tracking_id("upstream2", None))
+        self.assertFalse(tracking_recorder.has_tracking_id("upstream2", 22))
+
+        # Construct more tracking objects.
+        tracking4 = Tracking("upstream1", 23)
+        tracking5 = Tracking("upstream1", 24)
+
+        tracking_recorder.insert_tracking(tracking5)
+
+        # Can't fill in the gap.
+        with self.assertRaises(IntegrityError):
+            tracking_recorder.insert_tracking(tracking4)
+
+        self.assertTrue(tracking_recorder.has_tracking_id("upstream1", 23))
 
     def test_wait(self) -> None:
         tracking_recorder = self.create_recorder()
@@ -918,14 +941,15 @@ class ProcessRecorderTestCase(TestCase, ABC):
         self.assertFalse(recorder.has_tracking_id("upstream_app", 1))
         self.assertFalse(recorder.has_tracking_id("upstream_app", 2))
         self.assertFalse(recorder.has_tracking_id("upstream_app", 3))
+        self.assertFalse(recorder.has_tracking_id("upstream_app", 4))
 
         tracking1 = Tracking(
             application_name="upstream_app",
             notification_id=1,
         )
-        tracking2 = Tracking(
+        tracking3 = Tracking(
             application_name="upstream_app",
-            notification_id=2,
+            notification_id=3,
         )
 
         recorder.insert_events(
@@ -936,15 +960,55 @@ class ProcessRecorderTestCase(TestCase, ABC):
         self.assertTrue(recorder.has_tracking_id("upstream_app", 1))
         self.assertFalse(recorder.has_tracking_id("upstream_app", 2))
         self.assertFalse(recorder.has_tracking_id("upstream_app", 3))
+        self.assertFalse(recorder.has_tracking_id("upstream_app", 4))
 
         recorder.insert_events(
             stored_events=[],
-            tracking=tracking2,
+            tracking=tracking3,
         )
 
         self.assertTrue(recorder.has_tracking_id("upstream_app", 1))
         self.assertTrue(recorder.has_tracking_id("upstream_app", 2))
-        self.assertFalse(recorder.has_tracking_id("upstream_app", 3))
+        self.assertTrue(recorder.has_tracking_id("upstream_app", 3))
+        self.assertFalse(recorder.has_tracking_id("upstream_app", 4))
+
+    def test_raises_when_lower_inserted_later(self) -> None:
+        # Construct the recorder.
+        recorder = self.create_recorder()
+
+        tracking1 = Tracking(
+            application_name="upstream_app",
+            notification_id=1,
+        )
+        tracking2 = Tracking(
+            application_name="upstream_app",
+            notification_id=2,
+        )
+
+        # Insert tracking info.
+        recorder.insert_events(
+            stored_events=[],
+            tracking=tracking2,
+        )
+
+        # Get current position.
+        self.assertEqual(
+            recorder.max_tracking_id("upstream_app"),
+            2,
+        )
+
+        # Insert tracking info.
+        with self.assertRaises(IntegrityError):
+            recorder.insert_events(
+                stored_events=[],
+                tracking=tracking1,
+            )
+
+        # Get current position.
+        self.assertEqual(
+            recorder.max_tracking_id("upstream_app"),
+            2,
+        )
 
     def test_performance(self) -> None:
         # Construct the recorder.

eventsourcing/tests/postgres_utils.py

@@ -1,7 +1,6 @@
 import psycopg
 from psycopg.sql import SQL, Identifier
 
-from eventsourcing.persistence import PersistenceError
 from eventsourcing.postgres import PostgresDatastore
 
 
@@ -44,12 +43,9 @@ def pg_close_all_connections(
 
 
 def drop_postgres_table(datastore: PostgresDatastore, table_name: str) -> None:
-    statement = SQL("DROP TABLE {0}.{1}").format(
+    # print(f"Dropping table {datastore.schema}.{table_name}")
+    statement = SQL("DROP TABLE IF EXISTS {0}.{1}").format(
         Identifier(datastore.schema), Identifier(table_name)
     )
-    # print(f"Dropping table {datastore.schema}.{table_name}")
-    try:
-        with datastore.transaction(commit=True) as curs:
-            curs.execute(statement, prepare=False)
-    except PersistenceError:
-        pass
+    with datastore.transaction(commit=True) as curs:
+        curs.execute(statement, prepare=False)

{eventsourcing-9.4.2.dist-info → eventsourcing-9.4.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: eventsourcing
-Version: 9.4.2
+Version: 9.4.4
 Summary: Event sourcing in Python
 License: BSD-3-Clause
 Keywords: event sourcing,event store,domain driven design,domain-driven design,ddd,cqrs,cqs
@@ -24,10 +24,11 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Provides-Extra: crypto
 Provides-Extra: cryptography
 Provides-Extra: postgres
-Requires-Dist: cryptography (>=44.0,<45.0) ; extra == "cryptography"
-Requires-Dist: psycopg[pool] (>=3.2,<3.3) ; extra == "postgres"
-Requires-Dist: pycryptodome (>=3.22,<4.0) ; extra == "crypto"
+Requires-Dist: cryptography (>=44.0) ; extra == "cryptography"
+Requires-Dist: psycopg[pool] (>=3.2) ; extra == "postgres"
+Requires-Dist: pycryptodome (>=3.22) ; extra == "crypto"
 Requires-Dist: typing_extensions
+Project-URL: Documentation, https://eventsourcing.readthedocs.io/
 Project-URL: Homepage, https://github.com/pyeventsourcing/eventsourcing
 Project-URL: Repository, https://github.com/pyeventsourcing/eventsourcing
 Description-Content-Type: text/markdown
@@ -207,7 +208,7 @@ There are projects that adapt popular ORMs such as
 and [SQLAlchemy](https://github.com/pyeventsourcing/eventsourcing-sqlalchemy#readme).
 There are projects that adapt specialist event stores such as
 [Axon Server](https://github.com/pyeventsourcing/eventsourcing-axonserver#readme) and
-[EventStoreDB](https://github.com/pyeventsourcing/eventsourcing-eventstoredb#readme).
+[KurrentDB](https://github.com/pyeventsourcing/eventsourcing-kurrentdb#readme).
 There are projects that support popular NoSQL databases such as
 [DynamoDB](https://github.com/pyeventsourcing/eventsourcing-dynamodb#readme).
 There are also projects that provide examples of using the

{eventsourcing-9.4.2.dist-info → eventsourcing-9.4.4.dist-info}/RECORD

@@ -3,24 +3,24 @@ eventsourcing/application.py,sha256=K3M9_Rh2jaYzBDPMvmyemLXHQ4GsGfGsxmMfUeVSqXw,
 eventsourcing/cipher.py,sha256=ulTBtX5K9ejRAkdUaUbdIaj4H7anYwDOi7JxOolj2uo,3295
 eventsourcing/compressor.py,sha256=qEYWvsUXFLyhKgfuv-HGNJ6VF4sRw4z0IxbNW9ukOfc,385
 eventsourcing/cryptography.py,sha256=aFZLlJxxSb5seVbh94-T8FA_RIGOe-VFu5SJrbOnwUU,2969
-eventsourcing/dispatch.py,sha256=j03cIVPziq6LFEgJxvQMMIPlixuZ4bB8ynXXdd_Tj8Q,2740
+eventsourcing/dispatch.py,sha256=-yI-0EpyXnpMBkciTHNPlxSHJebUe7Ko9rT-gdOjoIo,2797
 eventsourcing/domain.py,sha256=2c33FfhVIBcUzhJa6TMhGPDwOma-wGiPHUL8RC8ZokQ,62967
 eventsourcing/interface.py,sha256=-VLoqcd9a0PXpD_Bv0LjCiG21xLREG6tXK6phgtShOw,5035
-eventsourcing/persistence.py,sha256=y_1o3LNi9tkOTqkvjgsGF4un4XPXEgxzt0Iwhk7UzEI,46340
-eventsourcing/popo.py,sha256=xZD6mig7bVwAoHe-UdraXvuu2iL5a8b2b41cEcBHlBU,9642
-eventsourcing/postgres.py,sha256=LGEsfAN_cUOL6xX0NT4gxVcu2Btma95WLqtYcEzdPSA,37757
-eventsourcing/projection.py,sha256=2qkagy2o1sts22LqndYZzsDV7AJK28oGkPrFH1ECnYM,15069
+eventsourcing/persistence.py,sha256=LrIjdEmMhM2Pz_ozGO_uOAQ099-yW92htaxO63vntwA,46406
+eventsourcing/popo.py,sha256=8LvOmAdwVRArhvWVsmfeHSmZ4B1CVdlR2KggwVbmeWU,9131
+eventsourcing/postgres.py,sha256=e1UGfc1qIX4RxLmUzneT3rjsV75Cres06Uckbrv4euo,43741
+eventsourcing/projection.py,sha256=X73BHLq37bXNm9FpNYA3O1plqPunxQmi-vu0DuFiugw,14727
 eventsourcing/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-eventsourcing/sqlite.py,sha256=1DRQgDE1S7lz7Mnz9QH6WZ4luMjI9tof1YpH5qrK9u8,22076
+eventsourcing/sqlite.py,sha256=8GJ6rKhX1z6CN0gXQIn6wh5pWmGvzOuMHtxcp0bO1SE,26696
 eventsourcing/system.py,sha256=WCfuSc45A9A1fFO7zpDum_ddh4pU7x-vEcpVZ_ycAyE,44358
 eventsourcing/tests/__init__.py,sha256=FtOyuj-L-oSisYeByTIrnUw-XzsctSbq76XmjPy5fMc,102
 eventsourcing/tests/application.py,sha256=pAn9Cugp_1rjOtj_nruGhh7PxdrQWibDlrnOAlOKXwo,20614
 eventsourcing/tests/domain.py,sha256=yN-F6gMRumeX6nIXIcZGxAR3RrUslzmEMM8JksnkI8Q,3227
-eventsourcing/tests/persistence.py,sha256=jy_aMQwRGKQKohw8Ji7oBf1aFIdcHLHiSrHxH6yHvzw,58654
-eventsourcing/tests/postgres_utils.py,sha256=0ywklGp6cXZ5PmV8ANVkwSHsZZCl5zTmOk7iG-RmrCE,1548
+eventsourcing/tests/persistence.py,sha256=TMi4gnlBfcd7XqFlWPSsNxwnEKhaPpXu-dHHgqJUs4I,60816
+eventsourcing/tests/postgres_utils.py,sha256=y-2ZrCZtHPqjfvBQqahtbTvvasFX2GGaMikG1BSK81A,1444
 eventsourcing/utils.py,sha256=pOnczXzaE5q7UbQbPmgcpWaP660fsmfiDJs6Gmo8QCM,8558
-eventsourcing-9.4.2.dist-info/AUTHORS,sha256=8aHOM4UbNZcKlD-cHpFRcM6RWyCqtwtxRev6DeUgVRs,137
-eventsourcing-9.4.2.dist-info/LICENSE,sha256=CQEQzcZO8AWXL5i3hIo4yVKrYjh2FBz6hCM7kpXWpw4,1512
-eventsourcing-9.4.2.dist-info/METADATA,sha256=agR-sOEFNlfqTmHsaQ4rIyxFoIROU_K6B4fh0Lo5ZL8,9959
-eventsourcing-9.4.2.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-eventsourcing-9.4.2.dist-info/RECORD,,
+eventsourcing-9.4.4.dist-info/AUTHORS,sha256=8aHOM4UbNZcKlD-cHpFRcM6RWyCqtwtxRev6DeUgVRs,137
+eventsourcing-9.4.4.dist-info/LICENSE,sha256=CQEQzcZO8AWXL5i3hIo4yVKrYjh2FBz6hCM7kpXWpw4,1512
+eventsourcing-9.4.4.dist-info/METADATA,sha256=C2sTYGk8meFDKMJn_w7GvoG37_9MHGMmJUgtWYhmvys,10003
+eventsourcing-9.4.4.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+eventsourcing-9.4.4.dist-info/RECORD,,