moving away from public API

Author: rambleraptor

pyiceberg/catalog/__init__.py

@@ -737,30 +737,6 @@ def namespace_to_string(identifier: str | Identifier, err: type[ValueError] | ty
     def supports_server_side_planning(self) -> bool:
         """Check if the catalog supports server-side scan planning."""
 
-    @abstractmethod
-    def supports_purge_table(self) -> bool:
-        """Check if the catalog supports purging tables."""
-
-    @abstractmethod
-    def supports_atomic_concurrent_updates(self) -> bool:
-        """Check if the catalog supports atomic concurrent updates."""
-
-    @abstractmethod
-    def supports_nested_namespaces(self) -> bool:
-        """Check if the catalog supports nested namespaces."""
-
-    @abstractmethod
-    def supports_schema_evolution(self) -> bool:
-        """Check if the catalog supports schema evolution."""
-
-    @abstractmethod
-    def supports_slash_in_identifier(self) -> bool:
-        """Check if the catalog supports slash in identifier."""
-
-    @abstractmethod
-    def supports_dot_in_identifier(self) -> bool:
-        """Check if the catalog supports dot in identifier."""
-
     @staticmethod
     def identifier_to_database(
         identifier: str | Identifier, err: type[ValueError] | type[NoSuchNamespaceError] = ValueError
@@ -863,24 +839,6 @@ def __init__(self, name: str, **properties: str):
     def supports_server_side_planning(self) -> bool:
         return False
 
-    def supports_purge_table(self) -> bool:
-        return True
-
-    def supports_atomic_concurrent_updates(self) -> bool:
-        return True
-
-    def supports_nested_namespaces(self) -> bool:
-        return True
-
-    def supports_schema_evolution(self) -> bool:
-        return True
-
-    def supports_slash_in_identifier(self) -> bool:
-        return True
-
-    def supports_dot_in_identifier(self) -> bool:
-        return True
-
     def create_table_transaction(
         self,
         identifier: str | Identifier,

pyiceberg/catalog/bigquery_metastore.py

@@ -98,9 +98,6 @@ def __init__(self, name: str, **properties: str):
         self.location = location
         self.project_id = project_id
 
-    def supports_nested_namespaces(self) -> bool:
-        return False
-
     def create_table(
         self,
         identifier: str | Identifier,

pyiceberg/catalog/dynamodb.py

@@ -117,9 +117,6 @@ def __init__(self, name: str, client: Optional["DynamoDBClient"] = None, **prope
         self.dynamodb_table_name = self.properties.get(DYNAMODB_TABLE_NAME, DYNAMODB_TABLE_NAME_DEFAULT)
         self._ensure_catalog_table_exists_or_create()
 
-    def supports_nested_namespaces(self) -> bool:
-        return False
-
     def _ensure_catalog_table_exists_or_create(self) -> None:
         if self._dynamodb_table_exists():
             return None

pyiceberg/catalog/glue.py

@@ -350,9 +350,6 @@ def __init__(self, name: str, client: Optional["GlueClient"] = None, **propertie
             if glue_catalog_id := properties.get(GLUE_ID):
                 _register_glue_catalog_id_with_glue_client(self.glue, glue_catalog_id)
 
-    def supports_nested_namespaces(self) -> bool:
-        return False
-
     def _convert_glue_to_iceberg(self, glue_table: "TableTypeDef") -> Table:
         if (database_name := glue_table.get("DatabaseName")) is None:
             raise ValueError("Glue table is missing DatabaseName property")

pyiceberg/catalog/hive.py

@@ -650,24 +650,6 @@ def drop_table(self, identifier: str | Identifier) -> None:
             # When the namespace doesn't exist, it throws the same error
             raise NoSuchTableError(f"Table does not exists: {table_name}") from e
 
-    def supports_purge_table(self) -> bool:
-        return False
-
-    def supports_atomic_concurrent_updates(self) -> bool:
-        return False
-
-    def supports_nested_namespaces(self) -> bool:
-        return False
-
-    def supports_schema_evolution(self) -> bool:
-        return False
-
-    def supports_slash_in_identifier(self) -> bool:
-        return False
-
-    def supports_dot_in_identifier(self) -> bool:
-        return False
-
     def purge_table(self, identifier: str | Identifier) -> None:
         # This requires to traverse the reachability set, and drop all the data files.
         raise NotImplementedError("Not yet implemented")

pyiceberg/catalog/noop.py

@@ -88,24 +88,6 @@ def drop_table(self, identifier: str | Identifier) -> None:
     def supports_server_side_planning(self) -> bool:
         raise NotImplementedError
 
-    def supports_purge_table(self) -> bool:
-        raise NotImplementedError
-
-    def supports_atomic_concurrent_updates(self) -> bool:
-        raise NotImplementedError
-
-    def supports_nested_namespaces(self) -> bool:
-        raise NotImplementedError
-
-    def supports_schema_evolution(self) -> bool:
-        raise NotImplementedError
-
-    def supports_slash_in_identifier(self) -> bool:
-        raise NotImplementedError
-
-    def supports_dot_in_identifier(self) -> bool:
-        raise NotImplementedError
-
     def purge_table(self, identifier: str | Identifier) -> None:
         raise NotImplementedError
 

pyiceberg/catalog/rest/__init__.py

@@ -403,30 +403,6 @@ def supports_server_side_planning(self) -> bool:
             self.properties, REST_SCAN_PLANNING_ENABLED, REST_SCAN_PLANNING_ENABLED_DEFAULT
         )
 
-    def supports_purge_table(self) -> bool:
-        """Check if the catalog supports purging tables."""
-        return property_as_bool(self.properties, "supports_purge_table", True)
-
-    def supports_atomic_concurrent_updates(self) -> bool:
-        """Check if the catalog supports atomic concurrent updates."""
-        return property_as_bool(self.properties, "supports_atomic_concurrent_updates", True)
-
-    def supports_nested_namespaces(self) -> bool:
-        """Check if the catalog supports nested namespaces."""
-        return property_as_bool(self.properties, "supports_nested_namespaces", True)
-
-    def supports_schema_evolution(self) -> bool:
-        """Check if the catalog supports schema evolution."""
-        return property_as_bool(self.properties, "supports_schema_evolution", True)
-
-    def supports_slash_in_identifier(self) -> bool:
-        """Check if the catalog supports slash in identifier."""
-        return property_as_bool(self.properties, "supports_slash_in_identifier", True)
-
-    def supports_dot_in_identifier(self) -> bool:
-        """Check if the catalog supports dot in identifier."""
-        return property_as_bool(self.properties, "supports_dot_in_identifier", True)
-
     @retry(**_RETRY_ARGS)
     def _plan_table_scan(self, identifier: str | Identifier, request: PlanTableScanRequest) -> PlanningResponse:
         """Submit a scan plan request to the REST server.

pyiceberg/catalog/sql.py

@@ -149,12 +149,6 @@ def create_tables(self) -> None:
     def destroy_tables(self) -> None:
         SqlCatalogBaseTable.metadata.drop_all(self.engine)
 
-    def supports_slash_in_identifier(self) -> bool:
-        return False
-
-    def supports_dot_in_identifier(self) -> bool:
-        return False
-
     def _convert_orm_to_iceberg(self, orm_table: IcebergTables) -> Table:
         # Check for expected properties.
         if not (metadata_location := orm_table.metadata_location):

tests/conftest.py

@@ -48,8 +48,13 @@
 from pytest_lazyfixture import lazy_fixture
 
 from pyiceberg.catalog import Catalog, load_catalog
+from pyiceberg.catalog.bigquery_metastore import BigQueryMetastoreCatalog
+from pyiceberg.catalog.dynamodb import DynamoDbCatalog
+from pyiceberg.catalog.glue import GlueCatalog
+from pyiceberg.catalog.hive import HiveCatalog
 from pyiceberg.catalog.memory import InMemoryCatalog
 from pyiceberg.catalog.noop import NoopCatalog
+from pyiceberg.catalog.rest import RestCatalog
 from pyiceberg.catalog.sql import SqlCatalog
 from pyiceberg.expressions import BoundReference
 from pyiceberg.io import (
@@ -97,6 +102,7 @@
     UUIDType,
 )
 from pyiceberg.utils.datetime import datetime_to_millis
+from pyiceberg.utils.properties import property_as_bool
 
 if TYPE_CHECKING:
     import pyarrow as pa
@@ -3130,3 +3136,51 @@ def test_table_properties() -> dict[str, str]:
         "key1": "value1",
         "key2": "value2",
     }
+
+
+def does_support_purge_table(catalog: Catalog) -> bool:
+    if isinstance(catalog, RestCatalog):
+        return property_as_bool(catalog.properties, "supports_purge_table", True)
+    if isinstance(catalog, (HiveCatalog, NoopCatalog)):
+        return False
+    return True
+
+
+def does_support_atomic_concurrent_updates(catalog: Catalog) -> bool:
+    if isinstance(catalog, RestCatalog):
+        return property_as_bool(catalog.properties, "supports_atomic_concurrent_updates", True)
+    if isinstance(catalog, (HiveCatalog, NoopCatalog)):
+        return False
+    return True
+
+
+def does_support_nested_namespaces(catalog: Catalog) -> bool:
+    if isinstance(catalog, RestCatalog):
+        return property_as_bool(catalog.properties, "supports_nested_namespaces", True)
+    if isinstance(catalog, (HiveCatalog, NoopCatalog, GlueCatalog, BigQueryMetastoreCatalog, DynamoDbCatalog)):
+        return False
+    return True
+
+
+def does_support_schema_evolution(catalog: Catalog) -> bool:
+    if isinstance(catalog, RestCatalog):
+        return property_as_bool(catalog.properties, "supports_schema_evolution", True)
+    if isinstance(catalog, (HiveCatalog, NoopCatalog)):
+        return False
+    return True
+
+
+def does_support_slash_in_identifier(catalog: Catalog) -> bool:
+    if isinstance(catalog, RestCatalog):
+        return property_as_bool(catalog.properties, "supports_slash_in_identifier", True)
+    if isinstance(catalog, (HiveCatalog, NoopCatalog, SqlCatalog)):
+        return False
+    return True
+
+
+def does_support_dot_in_identifier(catalog: Catalog) -> bool:
+    if isinstance(catalog, RestCatalog):
+        return property_as_bool(catalog.properties, "supports_dot_in_identifier", True)
+    if isinstance(catalog, (HiveCatalog, NoopCatalog, SqlCatalog)):
+        return False
+    return True

tests/integration/test_catalog.py

@@ -43,7 +43,15 @@
 from pyiceberg.table.sorting import INITIAL_SORT_ORDER_ID, SortField, SortOrder
 from pyiceberg.transforms import BucketTransform, DayTransform, IdentityTransform
 from pyiceberg.types import IntegerType, LongType, NestedField, TimestampType, UUIDType
-from tests.conftest import clean_up
+from tests.conftest import (
+    clean_up,
+    does_support_atomic_concurrent_updates,
+    does_support_dot_in_identifier,
+    does_support_nested_namespaces,
+    does_support_purge_table,
+    does_support_schema_evolution,
+    does_support_slash_in_identifier,
+)
 
 
 @pytest.fixture(scope="function")
@@ -246,7 +254,7 @@ def test_drop_table(test_catalog: Catalog, table_schema_nested: Schema, table_na
 @pytest.mark.integration
 @pytest.mark.parametrize("test_catalog", CATALOGS)
 def test_purge_table(test_catalog: Catalog, table_schema_nested: Schema, table_name: str, database_name: str) -> None:
-    if not test_catalog.supports_purge_table():
+    if not does_support_purge_table(test_catalog):
         pytest.skip("Catalog does not support purge_table operation")
 
     identifier = (database_name, table_name)
@@ -299,7 +307,7 @@ def test_update_table_transaction(test_catalog: Catalog, test_schema: Schema, ta
 @pytest.mark.integration
 @pytest.mark.parametrize("test_catalog", CATALOGS)
 def test_update_schema_conflict(test_catalog: Catalog, test_schema: Schema, table_name: str, database_name: str) -> None:
-    if not test_catalog.supports_atomic_concurrent_updates():
+    if not does_support_atomic_concurrent_updates(test_catalog):
         pytest.skip("Catalog does not support atomic concurrent updates")
 
     identifier = (database_name, table_name)
@@ -646,7 +654,7 @@ def test_rest_custom_namespace_separator(rest_catalog: RestCatalog, table_schema
 def test_incompatible_partitioned_schema_evolution(
     test_catalog: Catalog, test_schema: Schema, test_partition_spec: PartitionSpec, database_name: str, table_name: str
 ) -> None:
-    if not test_catalog.supports_schema_evolution():
+    if not does_support_schema_evolution(test_catalog):
         pytest.skip(f"{type(test_catalog).__name__} does not support schema evolution")
 
     identifier = (database_name, table_name)
@@ -675,7 +683,7 @@ def test_incompatible_partitioned_schema_evolution(
 @pytest.mark.integration
 @pytest.mark.parametrize("test_catalog", CATALOGS)
 def test_namespace_with_slash(test_catalog: Catalog) -> None:
-    if not test_catalog.supports_slash_in_identifier():
+    if not does_support_slash_in_identifier(test_catalog):
         pytest.skip(f"{type(test_catalog).__name__} does not support slash in namespace")
 
     namespace = ("new/db",)
@@ -700,7 +708,7 @@ def test_namespace_with_slash(test_catalog: Catalog) -> None:
 def test_incompatible_sorted_schema_evolution(
     test_catalog: Catalog, test_schema: Schema, test_sort_order: SortOrder, database_name: str, table_name: str
 ) -> None:
-    if not test_catalog.supports_schema_evolution():
+    if not does_support_schema_evolution(test_catalog):
         pytest.skip(f"{type(test_catalog).__name__} does not support schema evolution")
 
     identifier = (database_name, table_name)
@@ -720,7 +728,7 @@ def test_incompatible_sorted_schema_evolution(
 @pytest.mark.integration
 @pytest.mark.parametrize("test_catalog", CATALOGS)
 def test_namespace_with_dot(test_catalog: Catalog) -> None:
-    if not test_catalog.supports_dot_in_identifier():
+    if not does_support_dot_in_identifier(test_catalog):
         pytest.skip(f"{type(test_catalog).__name__} does not support dot in namespace")
 
     namespace = ("new.db",)
@@ -734,7 +742,7 @@ def test_namespace_with_dot(test_catalog: Catalog) -> None:
     assert test_catalog.namespace_exists(namespace)
 
     # Hierarchical catalogs might treat this as multiple levels.
-    if test_catalog.supports_nested_namespaces():
+    if does_support_nested_namespaces(test_catalog):
         namespaces = test_catalog.list_namespaces()
         assert ("new",) in namespaces or ("new.db",) in namespaces
     else:
@@ -750,7 +758,7 @@ def test_namespace_with_dot(test_catalog: Catalog) -> None:
 @pytest.mark.integration
 @pytest.mark.parametrize("test_catalog", CATALOGS)
 def test_table_name_with_slash(test_catalog: Catalog, table_schema_simple: Schema) -> None:
-    if not test_catalog.supports_slash_in_identifier():
+    if not does_support_slash_in_identifier(test_catalog):
         pytest.skip(f"{type(test_catalog).__name__} does not support slash in table name")
 
     namespace = ("ns_slash",)
@@ -777,7 +785,7 @@ def test_table_name_with_slash(test_catalog: Catalog, table_schema_simple: Schem
 @pytest.mark.integration
 @pytest.mark.parametrize("test_catalog", CATALOGS)
 def test_table_name_with_dot(test_catalog: Catalog, table_schema_simple: Schema) -> None:
-    if not test_catalog.supports_dot_in_identifier():
+    if not does_support_dot_in_identifier(test_catalog):
         pytest.skip(f"{type(test_catalog).__name__} does not support dot in table name")
 
     namespace = ("ns_dot",)