feat: add relation schema size constraint

Author: emptybutton

src/tgdb/application/common/ports/relations.py

@@ -6,13 +6,11 @@
 
 
 @dataclass(frozen=True)
-class NotUniqueRelationNumberError(Exception):
-    relation_number: Number
+class NotUniqueRelationNumberError(Exception): ...
 
 
 @dataclass(frozen=True)
-class NoRelationError(Exception):
-    relation_number: Number
+class NoRelationError(Exception): ...
 
 
 class Relations(ABC):

src/tgdb/application/common/ports/tuples.py

@@ -1,12 +1,20 @@
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
+from dataclasses import dataclass
 
 from tgdb.entities.horizon.transaction import TransactionEffect
 from tgdb.entities.numeration.number import Number
+from tgdb.entities.relation.relation import Relation
 from tgdb.entities.relation.scalar import Scalar
 from tgdb.entities.relation.tuple import Tuple
 
 
+@dataclass(frozen=True)
+class OversizedRelationSchemaError(Exception):
+    schema_size: int
+    schema_max_size: int
+
+
 class Tuples(ABC):
     @abstractmethod
     async def tuples_with_attribute(
@@ -24,3 +32,9 @@ async def map(self, effects: Sequence[TransactionEffect], /) -> None: ...
     async def map_idempotently(
         self, effects: Sequence[TransactionEffect], /
     ) -> None: ...
+
+    @abstractmethod
+    async def assert_can_accept_tuples(self, relation: Relation) -> None:
+        """
+        :raises tgdb.application.common.ports.tuples.OversizedRelationSchemaError:
+        """  # noqa: E501

src/tgdb/application/relation/create_relation.py

@@ -1,6 +1,7 @@
 from dataclasses import dataclass
 
 from tgdb.application.common.ports.relations import Relations
+from tgdb.application.common.ports.tuples import Tuples
 from tgdb.entities.numeration.number import Number
 from tgdb.entities.relation.relation import Relation
 from tgdb.entities.relation.schema import Schema
@@ -9,13 +10,17 @@
 @dataclass(frozen=True)
 class CreateRelation:
     relations: Relations
+    tuples: Tuples
 
     async def __call__(
         self, relation_number: Number, relation_schema: Schema
     ) -> None:
         """
+        :raises tgdb.application.common.ports.tuples.OversizedRelationSchemaError:
         :raises tgdb.application.common.ports.relations.NotUniqueRelationNumberError:
         """  # noqa: E501
 
         new_relation = Relation.new(relation_number, relation_schema)
+        await self.tuples.assert_can_accept_tuples(new_relation)
+
         await self.relations.add(new_relation)

src/tgdb/entities/relation/domain.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from datetime import datetime
 from uuid import UUID
 
@@ -9,84 +9,62 @@
 class IntDomain:
     min: int
     max: int
-    _is_nonable: bool
-
-    def type(self) -> type[int]:
-        return int
-
-    def is_nonable(self) -> bool:
-        return self._is_nonable
+    is_nonable: bool
 
     def __contains__(self, scalar: Scalar) -> bool:
         if scalar is None:
-            return self._is_nonable
+            return self.is_nonable
 
         return isinstance(scalar, int) and self.min <= scalar <= self.max
 
 
 @dataclass(frozen=True)
 class StrDomain:
     max_len: int
-    _is_nonable: bool
-
-    def type(self) -> type[str]:
-        return str
-
-    def is_nonable(self) -> bool:
-        return self._is_nonable
+    is_nonable: bool
 
     def __contains__(self, scalar: Scalar) -> bool:
         if scalar is None:
-            return self._is_nonable
+            return self.is_nonable
 
         return isinstance(scalar, str) and len(scalar) <= self.max_len
 
 
 @dataclass(frozen=True)
-class SetDomain[T: int | str | datetime | UUID]:
-    values: tuple[T, ...]
-    _type: type[T]
-    _is_nonable: bool
-
-    def type(self) -> type[T]:
-        return self._type
-
-    def is_nonable(self) -> bool:
-        return self._is_nonable
+class _TypeDomain:
+    is_nonable: bool
+    _type: type = field(init=False)
 
     def __contains__(self, scalar: Scalar) -> bool:
         if scalar is None:
-            return self._is_nonable
+            return self.is_nonable
 
-        return scalar in self.values
+        return scalar is True or scalar is False
 
 
 @dataclass(frozen=True)
-class TypeDomain[T: bool | datetime | UUID]:
-    _type: type[T]
-    _is_nonable: bool
+class BoolDomain(_TypeDomain):
+    _type = bool
 
-    def type(self) -> type[T]:
-        return self._type
 
-    def is_nonable(self) -> bool:
-        return self._is_nonable
+@dataclass(frozen=True)
+class DatetimeDomain(_TypeDomain):
+    _type = datetime
+
+
+@dataclass(frozen=True)
+class UuidDomain(_TypeDomain):
+    _type = UUID
 
-    def __contains__(self, scalar: Scalar) -> bool:
-        if scalar is None:
-            return self._is_nonable
 
-        return isinstance(scalar, self._type)
+type SetDomain = tuple[Scalar, ...]
 
 
 type Domain = (
     IntDomain
     | StrDomain
-    | SetDomain[int]
-    | SetDomain[str]
-    | SetDomain[datetime]
-    | SetDomain[UUID]
-    | TypeDomain[bool]
-    | TypeDomain[datetime]
-    | TypeDomain[UUID]
+    | BoolDomain
+    | DatetimeDomain
+    | UuidDomain
+    | SetDomain
 )

src/tgdb/entities/relation/relation.py

@@ -72,7 +72,7 @@ def last_version(self) -> RelationVersion:
             else self._initial_version
         )
 
-    def last_version_id(self) -> RelationSchemaID:
+    def last_version_schema_id(self) -> RelationSchemaID:
         return RelationSchemaID(self._number, self.last_version().number)
 
     def recent_versions(

src/tgdb/infrastructure/adapters/relations.py

@@ -20,29 +20,21 @@ class InMemoryRelations(Relations):
     _db: InMemoryDb[Relation]
 
     async def relation(self, relation_number: Number) -> Relation:
-        """
-        :raises tgdb.application.common.ports.relations.NoRelationError:
-        """
-
         relation = self._db.select_one(
             lambda it: it.number() == relation_number
         )
         if relation is None:
-            raise NoRelationError(relation_number)
+            raise NoRelationError
 
         return relation
 
     async def add(self, relation: Relation) -> None:
-        """
-        :raises tgdb.application.common.ports.relations.NotUniqueRelationNumberError:
-        """  # noqa: E501
-
         selected_relation = self._db.select_one(
             lambda it: it.number() == relation.number()
         )
 
         if selected_relation is not None:
-            raise NotUniqueRelationNumberError(relation.number())
+            raise NotUniqueRelationNumberError
 
         self._db.insert(relation)
 
@@ -75,7 +67,7 @@ async def relation(self, relation_number: Number) -> Relation:
         )
 
         if relation is None:
-            raise NoRelationError(relation_number)
+            raise NoRelationError
 
         return relation
 
@@ -89,7 +81,7 @@ async def add(self, relation: Relation) -> None:
         )
 
         if selected_relation is not None:
-            raise NotUniqueRelationNumberError(relation.number())
+            raise NotUniqueRelationNumberError
 
         self._cached_relations.insert(relation)
 

src/tgdb/infrastructure/adapters/tuples.py

@@ -4,12 +4,16 @@
 
 from in_memory_db import InMemoryDb
 
-from tgdb.application.common.ports.tuples import Tuples
+from tgdb.application.common.ports.tuples import (
+    OversizedRelationSchemaError,
+    Tuples,
+)
 from tgdb.entities.horizon.transaction import (
     TransactionEffect,
     TransactionScalarEffect,
 )
 from tgdb.entities.numeration.number import Number
+from tgdb.entities.relation.relation import Relation
 from tgdb.entities.relation.scalar import Scalar
 from tgdb.entities.relation.tuple import Tuple
 from tgdb.entities.relation.tuple_effect import (
@@ -18,13 +22,19 @@
     MutatedTuple,
     NewTuple,
 )
-from tgdb.infrastructure.telethon.in_telegram_heap import InTelegramHeap
+from tgdb.infrastructure.telethon.in_telegram_heap import (
+    InTelegramHeap,
+    UnacceptableTupleError,
+)
 
 
 @dataclass(frozen=True, unsafe_hash=False)
 class InMemoryTuples(Tuples):
     _db: InMemoryDb[Tuple]
 
+    async def assert_can_accept_tuples(self, relation: Relation) -> None:
+        ...
+
     async def tuples_with_attribute(
         self,
         relation_number: Number,
@@ -88,6 +98,15 @@ async def _map_one_idempotently(self, effect: TransactionEffect) -> None:
 class InTelegramHeapTuples(Tuples):
     _heap: InTelegramHeap
 
+    async def assert_can_accept_tuples(self, relation: Relation) -> None:
+        try:
+            self._heap.assert_can_accept_tuples_of_relation(relation)
+        except UnacceptableTupleError as error:
+            raise OversizedRelationSchemaError(
+                error.encoded_tuple_len,
+                self._heap.tuple_max_len(),
+            ) from error
+
     async def tuples_with_attribute(
         self,
         relation_number: Number,

src/tgdb/infrastructure/heap_tuple_encoding.py

@@ -1,8 +1,19 @@
+from datetime import datetime, timedelta, timezone
 from enum import Enum
+from uuid import UUID
 
 from tgdb.entities.numeration.number import Number
+from tgdb.entities.relation.domain import (
+    BoolDomain,
+    DatetimeDomain,
+    Domain,
+    IntDomain,
+    StrDomain,
+    UuidDomain,
+)
 from tgdb.entities.relation.relation import RelationSchemaID
 from tgdb.entities.relation.scalar import Scalar
+from tgdb.entities.relation.schema import Schema
 from tgdb.entities.relation.tuple import TID, Tuple
 from tgdb.infrastructure.primitive_encoding import (
     ReversibleTranslationTable,
@@ -11,6 +22,7 @@
     decoded_uuid,
     encoded_int,
     encoded_primitive_with_type,
+    encoded_primitive_without_type,
     encoded_uuid,
 )
 
@@ -27,6 +39,16 @@ class Separator(Enum):
 
 
 class HeapTupleEncoding:
+    @staticmethod
+    def largest_tuple(
+        schema: Schema,
+        schema_id: RelationSchemaID,
+    ) -> Tuple:
+        xid, schema_id = _HeapTupleMetadataEncoding.largest_metadata(schema_id)
+        scalars = map(_HeapTupleAttributeEncoding.largest_scalar, schema)
+
+        return Tuple(xid, schema_id, tuple(scalars))
+
     @staticmethod
     def encoded_tuple(tuple_: Tuple) -> str:
         encoded_metadata = _HeapTupleMetadataEncoding.encoded_metadata(
@@ -111,6 +133,10 @@ def decoded_metadata(encoded_metadata: str) -> _HeapTupleMetadata:
     def id_of_encoded_tuple_with_tid(tid: TID) -> str:
         return f"{Separator.top_metadata.value}{encoded_uuid(tid)}"
 
+    @staticmethod
+    def largest_metadata(schema_id: RelationSchemaID) -> _HeapTupleMetadata:
+        return UUID(int=0), schema_id
+
 
 class _HeapTupleAttributeEncoding:
     @staticmethod
@@ -132,3 +158,25 @@ def decoded_scalar(encoded_attribute: str) -> Scalar:
         )
 
         return decoded_primitive_with_type(encoded_scalar, heap_tuple_table)
+
+    @staticmethod
+    def largest_scalar(domain: Domain) -> Scalar:
+        match domain:
+            case IntDomain():
+                return max(domain.min, domain.max, key=lambda it: len(str(it)))
+            case StrDomain():
+                return "x" * domain.max_len
+            case BoolDomain():
+                return True
+            case DatetimeDomain():
+                tzinfo = timezone(timedelta(hours=14))
+                return datetime(9999, 12, 31, 23, 59, 59, 999999, tzinfo=tzinfo)
+            case UuidDomain():
+                return UUID(int=0)
+            case tuple():
+                return max(
+                    domain,
+                    key=lambda it: (
+                        encoded_primitive_without_type(it, heap_tuple_table)
+                    )
+                )