feat(entities): simplify Topic to Relation

Author: emptybutton

src/tgdb/entities/horizon/effect.py

@@ -2,20 +2,20 @@
 from dataclasses import dataclass
 from uuid import UUID
 
-from tgdb.entities.topic.partition import PartitionTuple, PartitionTupleID
+from tgdb.entities.relation.tuple import Tuple, TupleID
 
 
 @dataclass(frozen=True)
 class ViewedTuple:
-    id: PartitionTupleID
+    id: TupleID
 
     def __and__(self, effect: "TupleEffect") -> "TupleEffect":
         return effect
 
 
 @dataclass(frozen=True)
 class NewTuple:
-    tuple: PartitionTuple
+    tuple: Tuple
 
     def __and__(self, effect: "TupleEffect") -> "TupleEffect":
         match effect:
@@ -27,13 +27,13 @@ def __and__(self, effect: "TupleEffect") -> "TupleEffect":
                 return effect
 
     @property
-    def id(self) -> PartitionTupleID:
+    def id(self) -> TupleID:
         return self.tuple.id
 
 
 @dataclass(frozen=True)
 class MutatedTuple:
-    tuple: PartitionTuple
+    tuple: Tuple
 
     def __and__(self, effect: "TupleEffect") -> "TupleEffect":
         match effect:
@@ -45,13 +45,13 @@ def __and__(self, effect: "TupleEffect") -> "TupleEffect":
                 return effect
 
     @property
-    def id(self) -> PartitionTupleID:
+    def id(self) -> TupleID:
         return self.tuple.id
 
 
 @dataclass(frozen=True)
 class DeletedTuple:
-    id: PartitionTupleID
+    id: TupleID
 
     def __and__(self, effect: "TupleEffect") -> "TupleEffect":
         match effect:

src/tgdb/entities/horizon/horizon.py

@@ -1,5 +1,4 @@
 from collections import OrderedDict
-from collections.abc import Sequence
 from dataclasses import dataclass
 from uuid import UUID
 
@@ -94,7 +93,7 @@ def complete(
 
         if (
             transaction is None
-            or transaction.state is not TransactionState.prepared
+            or transaction.state() is not TransactionState.prepared
         ):
             return None
 

src/tgdb/entities/horizon/transaction.py

@@ -11,8 +11,8 @@
     TupleEffect,
     ViewedTuple,
 )
+from tgdb.entities.relation.tuple import TupleID
 from tgdb.entities.time.logic_time import LogicTime
-from tgdb.entities.topic.partition import PartitionTupleID
 
 
 @dataclass(frozen=True)
@@ -88,7 +88,7 @@ class SerializableTransaction(Transaction):
     _id: UUID
     _state: TransactionState
     _beginning: LogicTime
-    _space_map: dict[PartitionTupleID, TupleEffect]
+    _space_map: dict[TupleID, TupleEffect]
     _claims: set[Claim]
     _concurrent_transactions: set["Transaction"]
     _transactions_with_possible_conflict: set["SerializableTransaction"]
@@ -205,7 +205,7 @@ def _conflict(self) -> TransactionConflict | None:
 
         return None
 
-    def _space(self) -> set[PartitionTupleID]:
+    def _space(self) -> set[TupleID]:
         return set(self._space_map)
 
     def _effect(self) -> TransactionEffect:

src/tgdb/entities/numeration/number.py

@@ -10,20 +10,20 @@ class Number:
     :raises tgdb.entities.numeration.number.NegativeNumberError:
     """
 
-    int: int
+    _int: int
 
     def __post_init__(self) -> None:
-        if self.int < 0:
+        if self._int < 0:
             raise NegativeNumberError
 
     def __int__(self) -> "int":
-        return self.int
+        return self._int
 
     def __next__(self) -> "Number":
-        return Number(self.int + 1)
+        return Number(self._int + 1)
 
     def __lt__(self, other: "Number") -> bool:
-        return self.int < other.int
+        return self._int < other._int
 
     def __le__(self, other: "Number") -> bool:
-        return self.int <= other.int
+        return self._int <= other._int

src/tgdb/entities/relation/domain.py

@@ -60,7 +60,7 @@ class SetDomain[T: bool | int | str | datetime | UUID](Domain):
     _type: type[T]
     _is_nonable: bool
 
-    def type(self) -> type[T]:
+    def type(self) -> type[T]:  # type: ignore[override]
         return self._type
 
     def is_nonable(self) -> bool:

src/tgdb/entities/relation/relation.py

@@ -1,24 +1,138 @@
+from collections.abc import Iterator, Sequence
 from dataclasses import dataclass
+from itertools import pairwise
+from uuid import UUID
 
-from tgdb.entities.relation.scalar import Scalar
+from tgdb.entities.numeration.number import Number
+from tgdb.entities.relation.domain import Domain
 from tgdb.entities.relation.schema import Schema
 
 
 @dataclass(frozen=True)
-class UniversalRelation:
-    schema: Schema
+class InitialRelationVersion[IDDomainT: Domain]:
+    number: Number
+    schema: Schema[IDDomainT]
 
-    def __bool__(self) -> bool:
-        return bool(self.schema)
 
-    def __contains__(self, tuple_: tuple[Scalar, ...]) -> bool:
-        if not self.schema:
-            return False
+@dataclass(frozen=True)
+class DerivativeRelationVersion[IDDomainT: Domain]:
+    number: Number
+    schema: Schema[IDDomainT]
+    migration_id: UUID
+
+
+type RelationVersion[IDDomainT: Domain] = (
+    InitialRelationVersion[IDDomainT] | DerivativeRelationVersion[IDDomainT]
+)
+
+
+class NotIncrementedRelationVersionError(Exception): ...
+
+
+class RelationWithoutLastVersionError(Exception): ...
+
+
+@dataclass
+class Relation[IDDomainT: Domain]:
+    """
+    :raises tgdb.entities.relation.relation.RelationWithoutLastVersionError:
+    :raises tgdb.entities.relation.relation.NotIncrementedRelationVersionError:
+    """
 
-        if len(tuple_) != len(self.schema):
-            return False
+    _id: Number
+    _inital_version: InitialRelationVersion[IDDomainT]
+    _intermediate_versions: list[DerivativeRelationVersion[IDDomainT]]
 
-        return all(
-            scalar in domain
-            for scalar, domain in zip(tuple_, self.schema, strict=True)
+    def __post_init__(self) -> None:
+        if not self._intermediate_versions or not self._inital_version:
+            raise RelationWithoutLastVersionError
+
+        for version, next_version in pairwise(self._versions()):
+            if next(version.number) != next_version.number:
+                raise NotIncrementedRelationVersionError
+
+    def __len__(self) -> int:
+        return len(self._intermediate_versions) + 1
+
+    def __iter__(self) -> Iterator[RelationVersion[IDDomainT]]:
+        return iter(self._versions())
+
+    def inital_version(self) -> InitialRelationVersion[IDDomainT] | None:
+        return self._inital_version
+
+    def intermediate_versions(
+        self
+    ) -> Sequence[DerivativeRelationVersion[IDDomainT]]:
+        return self._intermediate_versions
+
+    def last_version(self) -> RelationVersion[IDDomainT]:
+        return (
+            self._intermediate_versions[-1]
+            if self._intermediate_versions
+            else self._inital_version
         )
+
+    def recent_versions(
+        self, current_version_number: Number
+    ) -> Sequence[DerivativeRelationVersion[IDDomainT]]:
+        if current_version_number < self._inital_version.number:
+            return tuple()
+
+        if current_version_number == self._inital_version.number:
+            return self._intermediate_versions
+
+        if current_version_number >= self._intermediate_versions[-1].number:
+            return tuple()
+
+        if not self._intermediate_versions:
+            return tuple()
+
+        current_version_index = (
+            int(self._intermediate_versions[0].number)
+            - int(current_version_number)
+        )
+
+        return self._intermediate_versions[current_version_index + 1:]
+
+    def migrate(
+        self,
+        new_version_schema: Schema[IDDomainT],
+        new_version_migration_id: UUID,
+    ) -> None:
+        last_version = DerivativeRelationVersion(
+            next(self.last_version().number),
+            new_version_schema,
+            new_version_migration_id,
+        )
+        self._intermediate_versions.append(last_version)
+
+    def remove_old_versions(self, count: int) -> None:
+        count_to_remove_intermediate_versions = count - 1
+        count_to_remove_intermediate_versions = (
+            min(count_to_remove_intermediate_versions, len(self) - 1)
+        )
+        del self._intermediate_versions[:count_to_remove_intermediate_versions]
+
+        version_to_make_inital = self._intermediate_versions[0]
+
+        self._inital_version = InitialRelationVersion(
+            version_to_make_inital.number,
+            version_to_make_inital.schema,
+        )
+        del self._intermediate_versions[0]
+
+    @classmethod
+    def new(
+        cls, id: Number, schema: Schema[IDDomainT]
+    ) -> "Relation[IDDomainT]":
+        return Relation(
+            id,
+            InitialRelationVersion(Number(0), schema),
+            list(),
+        )
+
+    def _versions(self) -> Sequence[RelationVersion[IDDomainT]]:
+        if self._inital_version:
+            return (self._inital_version, *self._intermediate_versions)
+
+        return self._intermediate_versions

src/tgdb/entities/relation/schema.py

@@ -1,4 +1,17 @@
+from collections.abc import Iterator
+from dataclasses import dataclass
+
 from tgdb.entities.relation.domain import Domain
 
 
-type Schema = tuple[Domain, ...]
+@dataclass(frozen=True)
+class Schema[IDDomainT: Domain]:
+    id_domain: IDDomainT
+    other_domains: tuple[Domain, ...]
+
+    def __iter__(self) -> Iterator[Domain]:
+        yield self.id_domain
+        yield from self.other_domains
+
+    def __len__(self) -> int:
+        return len(self.other_domains) + 1

src/tgdb/entities/relation/tuple.py

@@ -0,0 +1,20 @@
+from collections.abc import Iterator
+from dataclasses import dataclass
+
+from tgdb.entities.numeration.number import Number
+from tgdb.entities.relation.scalar import Scalar
+
+
+@dataclass(frozen=True)
+class TupleID:
+    relation_id: Number
+    scalar: Scalar
+
+
+@dataclass(frozen=True)
+class Tuple:
+    id: TupleID
+    scalars: tuple[Scalar, ...]
+
+    def __iter__(self) -> Iterator[Scalar]:
+        return iter(self.scalars)