ref(relation): rename RelationVersionID to RelationSchemaID

Author: emptybutton

src/tgdb/entities/relation/relation.py

@@ -21,7 +21,7 @@ class DerivativeRelationVersion:
 
 
 @dataclass(frozen=True)
-class RelationVersionID:
+class RelationSchemaID:
     relation_number: Number
     relation_version_number: Number
 
@@ -72,8 +72,8 @@ def last_version(self) -> RelationVersion:
             else self._inital_version
         )
 
-    def last_version_id(self) -> RelationVersionID:
-        return RelationVersionID(self._number, self.last_version().number)
+    def last_version_id(self) -> RelationSchemaID:
+        return RelationSchemaID(self._number, self.last_version().number)
 
     def recent_versions(
         self, current_version_number: Number

src/tgdb/entities/relation/tuple.py

@@ -4,7 +4,7 @@
 from uuid import UUID
 
 from tgdb.entities.numeration.number import Number
-from tgdb.entities.relation.relation import RelationVersionID
+from tgdb.entities.relation.relation import RelationSchemaID
 from tgdb.entities.relation.scalar import Scalar
 from tgdb.entities.relation.schema import Schema
 
@@ -15,7 +15,7 @@
 @dataclass(frozen=True)
 class Tuple(Sequence[Scalar]):
     tid: TID
-    relation_version_id: RelationVersionID
+    relation_schema_id: RelationSchemaID
     scalars: tuple[Scalar, ...]
 
     def __iter__(self) -> Iterator[Scalar]:
@@ -51,9 +51,9 @@ def __getitem__(
 def tuple_(
     *scalars: Scalar,
     tid: TID,
-    relation_version_id: RelationVersionID = RelationVersionID(  # noqa: B008
+    relation_schema_id: RelationSchemaID = RelationSchemaID(  # noqa: B008
         Number(0),  # noqa: B008
         Number(0),  # noqa: B008
     ),
 ) -> Tuple:
-    return Tuple(tid, relation_version_id, scalars)
+    return Tuple(tid, relation_schema_id, scalars)

src/tgdb/entities/relation/tuple_effect.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 
 from tgdb.entities.numeration.number import Number
-from tgdb.entities.relation.relation import Relation, RelationVersionID
+from tgdb.entities.relation.relation import Relation, RelationSchemaID
 from tgdb.entities.relation.scalar import Scalar
 from tgdb.entities.relation.tuple import TID, Tuple
 from tgdb.entities.relation.versioned_tuple import VersionedTuple
@@ -127,7 +127,7 @@ def constructed_relation_tuple(
     """
 
     relation_last_version = relation.last_version()
-    relation_last_version_id = RelationVersionID(
+    relation_last_version_id = RelationSchemaID(
         relation.number(), relation_last_version.number
     )
 

src/tgdb/infrastructure/adapters/tuples.py

@@ -32,7 +32,7 @@ async def tuples_with_attribute(
         attribute_scalar: Scalar,
     ) -> Sequence[Tuple]:
         return self._db.select_many(lambda it: (
-            it.relation_version_id.relation_number == relation_number
+            it.relation_schema_id.relation_number == relation_number
             and len(it) >= int(attribute_number)
             and it[int(attribute_number)] == attribute_scalar
         ))

src/tgdb/infrastructure/heap_tuple_encoding.py

@@ -1,7 +1,7 @@
 from enum import Enum
 
 from tgdb.entities.numeration.number import Number
-from tgdb.entities.relation.relation import RelationVersionID
+from tgdb.entities.relation.relation import RelationSchemaID
 from tgdb.entities.relation.scalar import Scalar
 from tgdb.entities.relation.tuple import TID, Tuple
 from tgdb.infrastructure.primitive_encoding import (
@@ -30,13 +30,13 @@ class HeapTupleEncoding:
     @staticmethod
     def encoded_tuple(tuple_: Tuple) -> str:
         encoded_metadata = _HeapTupleMetadataEncoding.encoded_metadata(
-            int(tuple_.relation_version_id.relation_number),
-            int(tuple_.relation_version_id.relation_version_number),
+            int(tuple_.relation_schema_id.relation_number),
+            int(tuple_.relation_schema_id.relation_version_number),
             tuple_.tid,
         )
         encoded_attributes = (
             _HeapTupleAttributeEncoding.encoded_attribute(
-                int(tuple_.relation_version_id.relation_number),
+                int(tuple_.relation_schema_id.relation_number),
                 attribute_number,
                 tuple_[attribute_number],
             )
@@ -53,14 +53,14 @@ def decoded_tuple(encoded_tuple: str) -> Tuple:
             encoded_tuple.split(Separator.top_tuple.value)
         )
 
-        tid, relation_version_id = _HeapTupleMetadataEncoding.decoded_metadata(
+        tid, relation_schema_id = _HeapTupleMetadataEncoding.decoded_metadata(
             encoded_metadata
         )
         scalars = tuple(map(
             _HeapTupleAttributeEncoding.decoded_scalar, encoded_attributes
         ))
 
-        return Tuple(tid, relation_version_id, scalars)
+        return Tuple(tid, relation_schema_id, scalars)
 
     @staticmethod
     def id_of_encoded_tuple_with_attribute(
@@ -79,7 +79,7 @@ def id_of_encoded_tuple_with_tid(tid: TID) -> str:
         return _HeapTupleMetadataEncoding.id_of_encoded_tuple_with_tid(tid)
 
 
-type _HeapTupleMetadata = tuple[TID, RelationVersionID]
+type _HeapTupleMetadata = tuple[TID, RelationSchemaID]
 
 
 class _HeapTupleMetadataEncoding:
@@ -103,9 +103,9 @@ def decoded_metadata(encoded_metadata: str) -> _HeapTupleMetadata:
         relation_number = Number(decoded_int(encoded_relation_number))
         tid = decoded_uuid(encoded_tid)
 
-        version_id = RelationVersionID(relation_number, relation_version_number)
+        schema_id = RelationSchemaID(relation_number, relation_version_number)
 
-        return tid, version_id
+        return tid, schema_id
 
     @staticmethod
     def id_of_encoded_tuple_with_tid(tid: TID) -> str:

tests/test_tgdb/test_infrastructure/test_heap_tuple_encoding.py

@@ -3,7 +3,7 @@
 from pytest import mark
 
 from tgdb.entities.numeration.number import Number
-from tgdb.entities.relation.relation import RelationVersionID
+from tgdb.entities.relation.relation import RelationSchemaID
 from tgdb.entities.relation.tuple import Tuple, tuple_
 from tgdb.infrastructure.heap_tuple_encoding import HeapTupleEncoding
 
@@ -22,8 +22,8 @@
         tuple_(
             None,
             tid=UUID(int=100000),
-            relation_version_id=RelationVersionID(
-                Number(1000), Number(200000)
+            relation_schema_id=RelationSchemaID(
+                Number(1000), Number(200_000)
         )),
     ]
 )