deltacat 2.0.0b11__py3-none-any.whl → 2.0.0b12__py3-none-any.whl

deltacat/storage/model/sort_key.py

@@ -12,6 +12,9 @@ from deltacat.storage.model.types import (
 from deltacat.storage.model.schema import FieldLocator
 from deltacat.storage.model.transform import Transform
 
+UNSORTED_SCHEME_NAME = "unsorted_scheme"
+UNSORTED_SCHEME_ID = "deadbeef-7277-49a4-a195-fdc8ed235d42"
+
 
 class SortKey(tuple):
     @staticmethod
@@ -103,6 +106,10 @@ class SortKeyList(List[SortKey]):
             self[item] = val = SortKey(val)
         return val
 
+    def __iter__(self):
+        for i in range(len(self)):
+            yield self[i]  # This triggers __getitem__ conversion
+
 
 class SortScheme(dict):
     @staticmethod
@@ -112,6 +119,19 @@ class SortScheme(dict):
         scheme_id: Optional[str] = None,
         native_object: Optional[Any] = None,
     ) -> SortScheme:
+        # Validate keys if provided
+        if keys is not None:
+            # Check for empty keys list
+            if len(keys) == 0:
+                raise ValueError("Sort scheme cannot have empty keys list")
+
+            # Check for duplicate keys
+            key_names = []
+            for key in keys:
+                if key.key[0] in key_names:
+                    raise ValueError(f"Duplicate sort key found: {key.key[0]}")
+                key_names.append(key.key[0])
+
         return SortScheme(
             {
                 "keys": keys,
@@ -132,6 +152,15 @@ class SortScheme(dict):
             return False
         if not isinstance(other, SortScheme):
             other = SortScheme(other)
+        # If both have None keys, they are equivalent (for unsorted schemes)
+        if self.keys is None and other.keys is None:
+            return not check_identifiers or (
+                self.name == other.name and self.id == other.id
+            )
+        # If only one has None keys, they are not equivalent
+        if self.keys is None or other.keys is None:
+            return False
+        # Compare keys if both have them
         for i in range(len(self.keys)):
             if not self.keys[i].equivalent_to(other.keys[i]):
                 return False
@@ -173,6 +202,13 @@ class SortScheme(dict):
         return self.get("nativeObject")
 
 
+UNSORTED_SCHEME = SortScheme.of(
+    keys=None,
+    name=UNSORTED_SCHEME_NAME,
+    scheme_id=UNSORTED_SCHEME_ID,
+)
+
+
 class SortSchemeList(List[SortScheme]):
     @staticmethod
     def of(items: List[SortScheme]) -> SortSchemeList:
@@ -188,3 +224,7 @@ class SortSchemeList(List[SortScheme]):
         if val is not None and not isinstance(val, SortScheme):
             self[item] = val = SortScheme(val)
         return val
+
+    def __iter__(self):
+        for i in range(len(self)):
+            yield self[i]  # This triggers __getitem__ conversion

deltacat/storage/model/stream.py

@@ -178,6 +178,13 @@ class Stream(Metafile):
             return stream_locator.table_version
         return None
 
+    def url(self, catalog_name: Optional[str] = None) -> str:
+        return (
+            f"dc://{catalog_name}/{self.namespace}/{self.table_name}/{self.table_version}/{self.stream_format}/"
+            if catalog_name
+            else f"table://{self.namespace}/{self.table_name}/{self.table_version}/{self.stream_format}/"
+        )
+
     def to_serializable(self) -> Stream:
         serializable = self
         if serializable.table_locator:
@@ -382,8 +389,8 @@ class StreamLocatorAlias(Locator, dict):
                     ),
                 }
             )
-            if parent_stream.state == CommitState.COMMITTED
-            else None  # only committed streams can be resolved by alias
+            if parent_stream.state != CommitState.STAGED
+            else None  # staged streams cannot be resolved by alias
         )
 
     @property

deltacat/storage/model/table.py

@@ -13,8 +13,9 @@ from deltacat.storage.model.namespace import (
 )
 from deltacat.storage.model.metafile import Metafile, MetafileRevisionInfo
 from deltacat.constants import TXN_DIR_NAME
+from deltacat.types.tables import TableProperty
 
-TableProperties = dict[str, Any]
+TableProperties = Dict[str, Any]
 
 
 class Table(Metafile):
@@ -126,6 +127,16 @@ class Table(Metafile):
         if table_locator:
             table_locator.table_name = table_name
 
+    def url(self, catalog_name: Optional[str] = None) -> str:
+        return (
+            f"dc://{catalog_name}/{self.namespace}/{self.table_name}/"
+            if catalog_name
+            else f"table://{self.namespace}/{self.table_name}/"
+        )
+
+    def read_table_property(self, property: TableProperty) -> Any:
+        return TableProperty.read_table_property(self, property)
+
     def to_serializable(self) -> Table:
         serializable = self
         if serializable.namespace_locator:

deltacat/storage/model/table_version.py

@@ -34,6 +34,7 @@ from deltacat.storage.model.table import (
 from deltacat.types.media import ContentType
 from deltacat.storage.model.sort_key import SortScheme, SortSchemeList
 from deltacat.storage.model.types import LifecycleState
+from deltacat.types.tables import TableProperty
 
 TableVersionProperties = Dict[str, Any]
 
@@ -251,6 +252,13 @@ class TableVersion(Metafile):
             return table_version_locator.table_version
         return None
 
+    def url(self, catalog_name: Optional[str] = None) -> str:
+        return (
+            f"dc://{catalog_name}/{self.namespace}/{self.table_name}/{self.table_version}/"
+            if catalog_name
+            else f"table://{self.namespace}/{self.table_name}/{self.table_version}/"
+        )
+
     def is_supported_content_type(self, content_type: ContentType):
         supported_content_types = self.content_types
         return (not supported_content_types) or (
@@ -355,6 +363,9 @@ class TableVersion(Metafile):
         )
         return int(version_number) if version_number is not None else None
 
+    def read_table_property(self, property: TableProperty) -> Any:
+        return TableProperty.read_table_property(self, property)
+
     @staticmethod
     def next_version(previous_version: Optional[str] = None) -> str:
         """