feat(entities): creating effects

Author: emptybutton

src/tgdb/application/ports/effect_encoding.py

@@ -0,0 +1,19 @@
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+
+from tgdb.entities.horizon.effect import (
+    Claim,
+    DeletedTuple,
+    MutatedTuple,
+    NewTuple,
+)
+
+
+type EncodableEffect = Sequence[NewTuple | MutatedTuple | DeletedTuple | Claim]
+
+
+class EffectEncoding[EncodedEffectT](ABC):
+    @abstractmethod
+    async def decoded(
+        self, effect: EncodedEffectT, /
+    ) -> EncodableEffect | None: ...

src/tgdb/application/ports/heap.py

@@ -6,7 +6,12 @@
 
 class Heap(ABC):
     @abstractmethod
-    async def rows(self, schema: str, )
+    async def tuples_with(self, id: TupleID)
 
     @abstractmethod
     async def map(self, effects: Sequence[TransactionEffect], /) -> None: ...
+
+    @abstractmethod
+    async def map_as_dublicates(
+        self, effects: Sequence[TransactionEffect], /
+    ) -> None: ...

src/tgdb/application/ports/notifying.py

@@ -1,6 +1,10 @@
 from abc import ABC, abstractmethod
 
-from tgdb.entities.horizon.transaction import Commit, ConflictError, NonSerializableWriteTransactionError
+from tgdb.entities.horizon.transaction import (
+    Commit,
+    ConflictError,
+    NonSerializableWriteTransactionError,
+)
 
 
 type Publishable = Commit | ConflictError | NonSerializableWriteTransactionError

src/tgdb/application/ports/operator_serialization.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+from uuid import UUID
+
+
+@dataclass(frozen=True)
+class Claim:
+    id: UUID
+    object: str

src/tgdb/entities/horizon/claim.py

@@ -4,13 +4,7 @@
 from dataclasses import dataclass
 from itertools import chain
 
-from tgdb.entities.horizon.effect import (
-    Claim,
-    DeletedTuple,
-    MutatedTuple,
-    NewTuple,
-    ViewedTuple,
-)
+from tgdb.entities.horizon.claim import Claim
 from tgdb.entities.horizon.transaction import (
     XID,
     Commit,
@@ -22,7 +16,13 @@
     Transaction,
     start_transaction,
 )
-from tgdb.entities.relation.tuple import Tuple, VersionedTuple
+from tgdb.entities.relation.tuple_effect import (
+    DeletedTuple,
+    InvalidTuple,
+    MigratedTuple,
+    MutatedTuple,
+    NewTuple,
+)
 from tgdb.entities.time.logic_time import LogicTime
 from tgdb.entities.tools.assert_ import assert_
 from tgdb.entities.tools.map import first_map_value
@@ -96,12 +96,12 @@ def start_transaction(
 
         return started_transaction.xid()
 
-    def view_tuple(
+    def include(
         self,
         time: LogicTime,
         xid: XID,
-        tuple: VersionedTuple,
-    ) -> Tuple:
+        effect: NewTuple | MigratedTuple | InvalidTuple,
+    ) -> None:
         """
         :raises tgdb.entities.horizon.horizon.NotMonotonicTimeError:
         :raises tgdb.entities.horizon.horizon.NoTransactionError:
@@ -114,19 +114,11 @@ def view_tuple(
             xid, SerializableTransactionState.active
         )
 
-        if isinstance(transaction, NonSerializableReadTransaction):
-            transaction.include(ViewedTuple(tuple.latest_version().id))
-            return tuple.latest_version()
-
-        latest_version = tuple.latest_version()
-        old_versions = tuple.old_versions()
-
-        if old_versions:
-            transaction.include(MutatedTuple(latest_version))
+        if isinstance(effect, InvalidTuple):
+            transaction.rollback()
+            del self._transaction_map(transaction)[transaction.xid()]
         else:
-            transaction.include(ViewedTuple(tuple.latest_version().id))
-
-        return latest_version
+            transaction.include(effect)
 
     def rollback_transaction(self, time: LogicTime, xid: XID) -> None:
         """

src/tgdb/entities/horizon/effect.py

@@ -1,21 +1,33 @@
-from collections.abc import Iterable
+from collections.abc import Iterable, Sequence, Set
 from dataclasses import dataclass
 from enum import Enum, auto
 from uuid import UUID
 
-from tgdb.entities.horizon.effect import (
-    Claim,
-    ConflictableTransactionScalarEffect,
-    TransactionEffect,
-    TupleEffect,
+from tgdb.entities.horizon.claim import Claim
+from tgdb.entities.relation.tuple import TID
+from tgdb.entities.relation.tuple_effect import (
+    DeletedTuple,
+    MigratedTuple,
+    MutatedTuple,
+    NewTuple,
+    TupleOkEffect,
     ViewedTuple,
 )
-from tgdb.entities.relation.tuple import TupleID
 from tgdb.entities.time.logic_time import LogicTime
 
 
 type XID = UUID
 
+type ConflictableTransactionScalarEffect = TupleOkEffect | Claim
+type ConflictableTransactionEffect = Sequence[
+    ConflictableTransactionScalarEffect
+]
+
+type TransactionScalarEffect = (
+    NewTuple | MutatedTuple | MigratedTuple | DeletedTuple
+)
+type TransactionEffect = Set[TransactionScalarEffect]
+
 
 @dataclass(frozen=True)
 class ConflictError(Exception):
@@ -52,7 +64,7 @@ class SerializableTransaction:
     _xid: XID
     _start_time: LogicTime
     _state: SerializableTransactionState
-    _space_map: dict[TupleID, TupleEffect]
+    _space_map: dict[TID, TupleOkEffect]
     _claims: set[Claim]
     _concurrent_transactions: set["SerializableTransaction"]
     _transactions_with_possible_conflict: set["SerializableTransaction"]
@@ -81,20 +93,20 @@ def state(self) -> SerializableTransactionState:
     def claims(self) -> frozenset[Claim]:
         return frozenset(self._claims)
 
-    def space(self) -> frozenset[TupleID]:
+    def space(self) -> frozenset[TID]:
         return frozenset(self._space_map)
 
     def include(self, effect: ConflictableTransactionScalarEffect) -> None:
         if isinstance(effect, Claim):
             self._claims.add(effect)
             return
 
-        prevous_effect = self._space_map.get(effect.id)
+        prevous_effect = self._space_map.get(effect.tid)
 
         if prevous_effect is not None:
             effect = prevous_effect & effect
 
-        self._space_map[effect.id] = effect
+        self._space_map[effect.tid] = effect
 
     def rollback(self) -> None:
         state_before_rollback = self._state
@@ -237,7 +249,10 @@ def age(self, time: LogicTime) -> LogicTime:
         return time - self._start_time
 
     def include(self, effect: ConflictableTransactionScalarEffect) -> None:
-        if self._is_readonly and not isinstance(effect, ViewedTuple):
+        if (
+            self._is_readonly
+            and not isinstance(effect, ViewedTuple | MigratedTuple)
+        ):
             self._is_readonly = False
 
     def rollback(self) -> None: