deltacat 1.1.22__tar.gz → 1.1.24__tar.gz

{deltacat-1.1.22/deltacat.egg-info → deltacat-1.1.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deltacat
-Version: 1.1.22
+Version: 1.1.24
 Summary: A scalable, fast, ACID-compliant Data Catalog powered by Ray.
 Home-page: https://github.com/ray-project/deltacat
 Author: Ray Team

{deltacat-1.1.22 → deltacat-1.1.24}/deltacat/__init__.py

@@ -44,7 +44,7 @@ from deltacat.types.tables import TableWriteMode
 
 deltacat.logs.configure_deltacat_logger(logging.getLogger(__name__))
 
-__version__ = "1.1.22"
+__version__ = "1.1.24"
 
 
 __all__ = [

{deltacat-1.1.22 → deltacat-1.1.24}/deltacat/aws/s3u.py

@@ -291,7 +291,7 @@ def read_file(
             f"Retry download for: {s3_url} after receiving {type(e).__name__}"
         ) from e
     except BaseException as e:
-        logger.warn(
+        logger.warning(
             f"Read has failed for {s3_url} and content_type={content_type} "
             f"and encoding={content_encoding}. Error: {e}",
             exc_info=True,
@@ -416,7 +416,7 @@ def upload_table(
                 f"Retry upload for: {s3_url} after receiving {type(e).__name__}",
             ) from e
         except BaseException as e:
-            logger.warn(
+            logger.warning(
                 f"Upload has failed for {s3_url} and content_type={content_type}. Error: {e}",
                 exc_info=True,
             )

{deltacat-1.1.22 → deltacat-1.1.24}/deltacat/compute/compactor/utils/round_completion_file.py

@@ -63,7 +63,7 @@ def read_round_completion_file(
             logger.info(f"Read round completion info: {round_completion_info}")
             break
         else:
-            logger.warn(f"Round completion file not present at {rcf_uri}")
+            logger.warning(f"Round completion file not present at {rcf_uri}")
 
     return round_completion_info
 

{deltacat-1.1.22 → deltacat-1.1.24}/deltacat/compute/compactor_v2/private/compaction_utils.py

@@ -227,6 +227,7 @@ def _run_hash_and_merge(
     previous_compacted_delta_manifest: Optional[Manifest],
     compacted_partition: Partition,
 ) -> List[MergeResult]:
+    created_obj_ids = set()
     telemetry_time_hb = 0
     total_input_records_count = np.int64(0)
     total_hb_record_count = np.int64(0)
@@ -288,6 +289,7 @@ def _run_hash_and_merge(
                 hb_result.hash_bucket_group_to_obj_id_tuple
             ):
                 if object_id_size_tuple:
+                    created_obj_ids.add(object_id_size_tuple[0])
                     all_hash_group_idx_to_obj_id[hash_group_index].append(
                         object_id_size_tuple[0],
                     )
@@ -365,6 +367,16 @@ def _run_hash_and_merge(
     mutable_compaction_audit.set_telemetry_time_in_seconds(
         telemetry_this_round + previous_telemetry
     )
+    if params.num_rounds > 1:
+        logger.info(
+            f"Detected number of rounds to be {params.num_rounds}, "
+            f"preparing to delete {len(created_obj_ids)} objects from object store..."
+        )
+        params.object_store.delete_many(list(created_obj_ids))
+    else:
+        logger.info(
+            f"Detected number of rounds to be {params.num_rounds}, not cleaning up object store..."
+        )
 
     return merge_results
 

{deltacat-1.1.22 → deltacat-1.1.24}/deltacat/compute/compactor_v2/utils/content_type_params.py

@@ -97,7 +97,7 @@ def append_content_type_params(
     max_parquet_meta_size_bytes: Optional[int] = MAX_PARQUET_METADATA_SIZE,
     deltacat_storage=unimplemented_deltacat_storage,
     deltacat_storage_kwargs: Optional[Dict[str, Any]] = {},
-) -> None:
+) -> bool:
     """
     This operation appends content type params into the delta entry. Note
     that this operation can be time consuming, hence we cache it in a Ray actor.
@@ -105,7 +105,7 @@ def append_content_type_params(
 
     if not delta.meta:
         logger.warning(f"Delta with locator {delta.locator} doesn't contain meta.")
-        return
+        return False
 
     entry_indices_to_download = []
     for entry_index, entry in enumerate(delta.manifest.entries):
@@ -120,7 +120,7 @@ def append_content_type_params(
         logger.info(
             f"No parquet type params to download for delta with locator {delta.locator}."
         )
-        return None
+        return False
 
     ray_namespace = ray.get_runtime_context().namespace
     logger.info(
@@ -147,7 +147,7 @@ def append_content_type_params(
                 f" {delta.locator} and digest {delta.locator.hexdigest()}."
             )
             delta.manifest = cached_value.manifest
-            return
+            return True
         logger.info(
             f"Cache doesn't contain parquet meta for delta with locator {delta.locator}."
         )
@@ -215,3 +215,5 @@ def append_content_type_params(
         )
         ray.get(cache.put.remote(delta.locator.hexdigest(), delta))
         assert ray.get(cache.get.remote(delta.locator.hexdigest())) is not None
+
+    return True

{deltacat-1.1.22 → deltacat-1.1.24}/deltacat/compute/resource_estimation/delta.py

@@ -42,7 +42,11 @@ def _estimate_resources_required_to_process_delta_using_previous_inflation(
     in_memory_size = (
         delta.meta.content_length * estimate_resources_params.previous_inflation
     )
-    num_rows = int(in_memory_size / estimate_resources_params.average_record_size_bytes)
+    num_rows = 0
+    if estimate_resources_params.average_record_size_bytes is not None:
+        num_rows = int(
+            in_memory_size / estimate_resources_params.average_record_size_bytes
+        )
 
     return EstimatedResources.of(
         memory_bytes=in_memory_size,
@@ -68,6 +72,10 @@ def _estimate_resources_required_to_process_delta_using_type_params(
     ), "Number of rows can only be estimated for PYARROW_DOWNLOAD operation"
 
     if estimate_resources_params.parquet_to_pyarrow_inflation is None:
+        logger.debug(
+            "Could not estimate using type params as "
+            f"parquet_to_pyarrow_inflation is None for {delta.locator}"
+        )
         return None
 
     if not delta.manifest:
@@ -86,12 +94,18 @@ def _estimate_resources_required_to_process_delta_using_type_params(
             ),
         )
 
-    append_content_type_params(
+    appended = append_content_type_params(
         delta=delta,
         deltacat_storage=deltacat_storage,
         deltacat_storage_kwargs=deltacat_storage_kwargs,
     )
 
+    if not appended:
+        logger.debug(
+            f"Could not append content type params for {delta.locator}, returning None"
+        )
+        return None
+
     in_memory_size = 0.0
     num_rows = 0
 

{deltacat-1.1.22 → deltacat-1.1.24}/deltacat/io/file_object_store.py

@@ -41,8 +41,23 @@ class FileObjectStore(IObjectStore):
                 serialized = f.read()
                 loaded = cloudpickle.loads(serialized)
                 result.append(loaded)
-            os.remove(ref)
         end = time.monotonic()
 
         logger.info(f"The total time taken to read all objects is: {end - start}")
         return result
+
+    def delete_many(self, refs: List[Any], *args, **kwargs) -> bool:
+        start = time.monotonic()
+        num_deleted = 0
+        for ref in refs:
+            try:
+                os.remove(ref)
+                num_deleted += 1
+            except Exception:
+                logger.warning(f"Failed to delete ref {ref}!", exc_info=True)
+        end = time.monotonic()
+
+        logger.info(
+            f"The total time taken to delete {num_deleted} out of {len(refs)} objects is: {end - start}"
+        )
+        return num_deleted == len(refs)

{deltacat-1.1.22 → deltacat-1.1.24}/deltacat/io/memcached_object_store.py

@@ -100,16 +100,10 @@ class MemcachedObjectStore(IObjectStore):
 
     def get_many(self, refs: List[Any], *args, **kwargs) -> List[object]:
         result = []
-        refs_per_ip = defaultdict(lambda: [])
+        refs_per_ip = self._get_refs_per_ip(refs)
         chunks_by_refs = defaultdict(lambda: [])
 
         start = time.monotonic()
-        for ref in refs:
-            uid, ip, chunk_count = ref.split(self.SEPARATOR)
-            chunk_count = int(chunk_count)
-            for chunk_index in range(chunk_count):
-                current_ref = self._create_ref(uid, ip, chunk_index)
-                refs_per_ip[ip].append(current_ref)
 
         total_ref_count = 0
         for (ip, current_refs) in refs_per_ip.items():
@@ -193,6 +187,39 @@ class MemcachedObjectStore(IObjectStore):
 
         return cloudpickle.loads(serialized)
 
+    def delete_many(self, refs: List[Any], *args, **kwargs) -> bool:
+        refs_per_ip = self._get_refs_per_ip(refs)
+        all_deleted = True
+
+        start = time.monotonic()
+
+        total_refs = 0
+        fully_deleted_refs = 0
+        for (ip, current_refs) in refs_per_ip.items():
+            client = self._get_client_by_ip(ip)
+            total_refs += len(current_refs)
+            try:
+                # always returns true
+                client.delete_many(current_refs, noreply=self.noreply)
+                fully_deleted_refs += len(current_refs)
+            except BaseException:
+                # if an exception is raised then all, some, or none of the keys may have been deleted
+                logger.warning(
+                    f"Failed to fully delete refs: {current_refs}", exc_info=True
+                )
+                all_deleted = False
+
+        end = time.monotonic()
+
+        logger.info(
+            f"From {len(refs)} objects, found {total_refs} total chunk references, of which {fully_deleted_refs} were guaranteed to be successfully deleted."
+        )
+        logger.info(
+            f"The total time taken to attempt deleting {len(refs)} objects is: {end - start}"
+        )
+
+        return all_deleted
+
     def clear(self) -> bool:
         flushed = all(
             [
@@ -260,3 +287,14 @@ class MemcachedObjectStore(IObjectStore):
             self.current_ip = socket.gethostbyname(socket.gethostname())
 
         return self.current_ip
+
+    def _get_refs_per_ip(self, refs: List[Any]):
+        refs_per_ip = defaultdict(lambda: [])
+
+        for ref in refs:
+            uid, ip, chunk_count = ref.split(self.SEPARATOR)
+            chunk_count = int(chunk_count)
+            for chunk_index in range(chunk_count):
+                current_ref = self._create_ref(uid, ip, chunk_index)
+                refs_per_ip[ip].append(current_ref)
+        return refs_per_ip

{deltacat-1.1.22 → deltacat-1.1.24}/deltacat/io/object_store.py

@@ -43,6 +43,19 @@ class IObjectStore:
         or may not return ordered results.
         """
 
+    def delete(self, ref: Any, *args, **kwargs) -> bool:
+        """
+        Delete a single object from the object store.
+        """
+        return self.delete_many([ref])
+
+    def delete_many(self, refs: List[Any], *args, **kwargs) -> bool:
+        ...
+
+        """
+        Delete many objects from the object store.
+        """
+
     def clear(self, *args, **kwargs) -> bool:
         ...
 
@@ -52,6 +65,7 @@ class IObjectStore:
 
     def close(self, *args, **kwargs) -> None:
         ...
+
         """
         Closes all the active connections to object store without clearing
         the data in the object store.

{deltacat-1.1.22 → deltacat-1.1.24}/deltacat/io/redis_object_store.py

@@ -56,12 +56,9 @@ class RedisObjectStore(IObjectStore):
 
     def get_many(self, refs: List[Any], *args, **kwargs) -> List[object]:
         result = []
-        uid_per_ip = defaultdict(lambda: [])
+        uid_per_ip = self._get_uids_per_ip(refs)
 
         start = time.monotonic()
-        for ref in refs:
-            uid, ip = ref.split(self.SEPARATOR)
-            uid_per_ip[ip].append(uid)
 
         for (ip, uids) in uid_per_ip.items():
             client = self._get_client_by_ip(ip)
@@ -95,6 +92,29 @@ class RedisObjectStore(IObjectStore):
         serialized = client.get(uid)
         return cloudpickle.loads(serialized)
 
+    def delete_many(self, refs: List[Any], *args, **kwargs) -> bool:
+        uid_per_ip = self._get_uids_per_ip(refs)
+
+        start = time.monotonic()
+
+        num_deleted = 0
+        for (ip, uids) in uid_per_ip.items():
+            client = self._get_client_by_ip(ip)
+            num_keys_deleted = client.delete(*uids)
+            num_deleted += num_keys_deleted
+            if num_keys_deleted != len(uids):
+                logger.warning(
+                    f"Failed to delete {len(uids) - num_keys_deleted} out of {len(uids)} uids: {uids}"
+                )
+
+        end = time.monotonic()
+
+        logger.info(
+            f"The total time taken to delete {num_deleted} out of {len(refs)} objects is: {end - start}"
+        )
+
+        return num_deleted == len(refs)
+
     def _get_client_by_ip(self, ip_address: str):
         if ip_address in self.client_cache:
             return self.client_cache[ip_address]
@@ -112,3 +132,11 @@ class RedisObjectStore(IObjectStore):
 
     def _create_ref(self, uid, ip):
         return f"{uid}{self.SEPARATOR}{ip}"
+
+    def _get_uids_per_ip(self, refs: List[Any]):
+        uid_per_ip = defaultdict(lambda: [])
+
+        for ref in refs:
+            uid, ip = ref.split(self.SEPARATOR)
+            uid_per_ip[ip].append(uid)
+        return uid_per_ip

{deltacat-1.1.22 → deltacat-1.1.24}/deltacat/io/s3_object_store.py

@@ -42,3 +42,20 @@ class S3ObjectStore(IObjectStore):
 
         logger.info(f"The total time taken to read all objects is: {end - start}")
         return result
+
+    def delete_many(self, refs: List[Any], *args, **kwargs) -> bool:
+        start = time.monotonic()
+        num_deleted = 0
+        for ref in refs:
+            try:
+                s3_utils.delete_files_by_prefix(self.bucket, str(ref))
+                num_deleted += 1
+            except BaseException:
+                logger.warning(f"Failed to delete ref {ref}!", exc_info=True)
+        end = time.monotonic()
+
+        logger.info(
+            f"The total time taken to delete {num_deleted} out of {len(refs)} objects is: {end - start}"
+        )
+
+        return num_deleted == len(refs)

{deltacat-1.1.22 → deltacat-1.1.24}/deltacat/tests/compute/resource_estimation/test_delta.py

@@ -526,6 +526,30 @@ class TestEstimateResourcesRequiredToProcessDelta:
             == parquet_delta_with_manifest.meta.content_length
         )
 
+    def test_parquet_delta_when_default_v2_without_avg_record_size_and_sampling(
+        self, local_deltacat_storage_kwargs, parquet_delta_with_manifest: Delta
+    ):
+        params = EstimateResourcesParams.of(
+            resource_estimation_method=ResourceEstimationMethod.DEFAULT_V2,
+            previous_inflation=7,
+            parquet_to_pyarrow_inflation=1,
+        )
+
+        result = estimate_resources_required_to_process_delta(
+            delta=parquet_delta_with_manifest,
+            operation_type=OperationType.PYARROW_DOWNLOAD,
+            deltacat_storage=ds,
+            deltacat_storage_kwargs=local_deltacat_storage_kwargs,
+            estimate_resources_params=params,
+        )
+
+        assert parquet_delta_with_manifest.manifest is not None
+        assert result.memory_bytes is not None
+        assert (
+            result.statistics.on_disk_size_bytes
+            == parquet_delta_with_manifest.meta.content_length
+        )
+
     def test_parquet_delta_when_default_v2_and_files_to_sample_zero(
         self, local_deltacat_storage_kwargs, parquet_delta_with_manifest: Delta
     ):
@@ -578,6 +602,32 @@ class TestEstimateResourcesRequiredToProcessDelta:
             == utsv_delta_with_manifest.meta.content_length
         )
 
+    def test_utsv_delta_when_default_v2_without_avg_record_size(
+        self, local_deltacat_storage_kwargs, utsv_delta_with_manifest: Delta
+    ):
+        params = EstimateResourcesParams.of(
+            resource_estimation_method=ResourceEstimationMethod.DEFAULT_V2,
+            previous_inflation=7,
+            average_record_size_bytes=None,  # note
+            parquet_to_pyarrow_inflation=1,
+        )
+
+        result = estimate_resources_required_to_process_delta(
+            delta=utsv_delta_with_manifest,
+            operation_type=OperationType.PYARROW_DOWNLOAD,
+            deltacat_storage=ds,
+            deltacat_storage_kwargs=local_deltacat_storage_kwargs,
+            estimate_resources_params=params,
+        )
+
+        assert utsv_delta_with_manifest.manifest is not None
+        assert result.memory_bytes is not None
+        assert result.statistics.record_count == 0
+        assert (
+            result.statistics.on_disk_size_bytes
+            == utsv_delta_with_manifest.meta.content_length
+        )
+
     def test_parquet_delta_without_inflation_when_default_v2(
         self, local_deltacat_storage_kwargs, parquet_delta_with_manifest: Delta
     ):

{deltacat-1.1.22 → deltacat-1.1.24}/deltacat/tests/compute/test_compact_partition_multiple_rounds.py

@@ -5,8 +5,9 @@ import pytest
 import boto3
 from boto3.resources.base import ServiceResource
 import pyarrow as pa
-from deltacat.io.ray_plasma_object_store import RayPlasmaObjectStore
+from deltacat.io.file_object_store import FileObjectStore
 from pytest_benchmark.fixture import BenchmarkFixture
+import tempfile
 
 from deltacat.tests.compute.test_util_constant import (
     TEST_S3_RCF_BUCKET_NAME,
@@ -247,84 +248,99 @@ def test_compact_partition_rebase_multiple_rounds_same_source_and_destination(
         pgm = PlacementGroupManager(
             1, total_cpus, DEFAULT_WORKER_INSTANCE_CPUS, memory_per_bundle=4000000
         ).pgs[0]
-    compact_partition_params = CompactPartitionParams.of(
-        {
-            "compaction_artifact_s3_bucket": TEST_S3_RCF_BUCKET_NAME,
-            "compacted_file_content_type": ContentType.PARQUET,
-            "dd_max_parallelism_ratio": 1.0,
-            "deltacat_storage": ds,
-            "deltacat_storage_kwargs": ds_mock_kwargs,
-            "destination_partition_locator": rebased_partition.locator,
-            "hash_bucket_count": hash_bucket_count_param,
-            "last_stream_position_to_compact": source_partition.stream_position,
-            "list_deltas_kwargs": {**ds_mock_kwargs, **{"equivalent_table_types": []}},
-            "object_store": RayPlasmaObjectStore(),
-            "pg_config": pgm,
-            "primary_keys": primary_keys,
-            "read_kwargs_provider": read_kwargs_provider_param,
-            "rebase_source_partition_locator": source_partition.locator,
-            "rebase_source_partition_high_watermark": rebased_partition.stream_position,
-            "records_per_compacted_file": records_per_compacted_file_param,
-            "s3_client_kwargs": {},
-            "source_partition_locator": rebased_partition.locator,
-            "sort_keys": sort_keys if sort_keys else None,
-            "num_rounds": num_rounds_param,
-            "drop_duplicates": drop_duplicates_param,
-            "min_delta_bytes": 560,
-        }
-    )
-    if expected_terminal_exception:
-        with pytest.raises(expected_terminal_exception) as exc_info:
-            benchmark(compact_partition_func, compact_partition_params)
-        assert expected_terminal_exception_message in str(exc_info.value)
-        return
-    from deltacat.compute.compactor_v2.model.evaluate_compaction_result import (
-        ExecutionCompactionResult,
-    )
+    with tempfile.TemporaryDirectory() as test_dir:
+        compact_partition_params = CompactPartitionParams.of(
+            {
+                "compaction_artifact_s3_bucket": TEST_S3_RCF_BUCKET_NAME,
+                "compacted_file_content_type": ContentType.PARQUET,
+                "dd_max_parallelism_ratio": 1.0,
+                "deltacat_storage": ds,
+                "deltacat_storage_kwargs": ds_mock_kwargs,
+                "destination_partition_locator": rebased_partition.locator,
+                "hash_bucket_count": hash_bucket_count_param,
+                "last_stream_position_to_compact": source_partition.stream_position,
+                "list_deltas_kwargs": {
+                    **ds_mock_kwargs,
+                    **{"equivalent_table_types": []},
+                },
+                "object_store": FileObjectStore(test_dir),
+                "pg_config": pgm,
+                "primary_keys": primary_keys,
+                "read_kwargs_provider": read_kwargs_provider_param,
+                "rebase_source_partition_locator": source_partition.locator,
+                "rebase_source_partition_high_watermark": rebased_partition.stream_position,
+                "records_per_compacted_file": records_per_compacted_file_param,
+                "s3_client_kwargs": {},
+                "source_partition_locator": rebased_partition.locator,
+                "sort_keys": sort_keys if sort_keys else None,
+                "num_rounds": num_rounds_param,
+                "drop_duplicates": drop_duplicates_param,
+                "min_delta_bytes": 560,
+            }
+        )
+        if expected_terminal_exception:
+            with pytest.raises(expected_terminal_exception) as exc_info:
+                benchmark(compact_partition_func, compact_partition_params)
+            assert expected_terminal_exception_message in str(exc_info.value)
+            return
+        from deltacat.compute.compactor_v2.model.evaluate_compaction_result import (
+            ExecutionCompactionResult,
+        )
 
-    execute_compaction_result_spy = mocker.spy(ExecutionCompactionResult, "__init__")
+        execute_compaction_result_spy = mocker.spy(
+            ExecutionCompactionResult, "__init__"
+        )
+        object_store_delete_many_spy = mocker.spy(FileObjectStore, "delete_many")
 
-    # execute
-    rcf_file_s3_uri = benchmark(compact_partition_func, compact_partition_params)
+        # execute
+        rcf_file_s3_uri = benchmark(compact_partition_func, compact_partition_params)
 
-    round_completion_info: RoundCompletionInfo = get_rcf(s3_resource, rcf_file_s3_uri)
-    audit_bucket, audit_key = RoundCompletionInfo.get_audit_bucket_name_and_key(
-        round_completion_info.compaction_audit_url
-    )
+        round_completion_info: RoundCompletionInfo = get_rcf(
+            s3_resource, rcf_file_s3_uri
+        )
+        audit_bucket, audit_key = RoundCompletionInfo.get_audit_bucket_name_and_key(
+            round_completion_info.compaction_audit_url
+        )
 
-    compaction_audit_obj: Dict[str, Any] = read_s3_contents(
-        s3_resource, audit_bucket, audit_key
-    )
-    compaction_audit: CompactionSessionAuditInfo = CompactionSessionAuditInfo(
-        **compaction_audit_obj
-    )
+        compaction_audit_obj: Dict[str, Any] = read_s3_contents(
+            s3_resource, audit_bucket, audit_key
+        )
+        compaction_audit: CompactionSessionAuditInfo = CompactionSessionAuditInfo(
+            **compaction_audit_obj
+        )
 
-    # Assert not in-place compacted
-    assert (
-        execute_compaction_result_spy.call_args.args[-1] is False
-    ), "Table version erroneously marked as in-place compacted!"
-    compacted_delta_locator: DeltaLocator = get_compacted_delta_locator_from_rcf(
-        s3_resource, rcf_file_s3_uri
-    )
-    tables = ds.download_delta(
-        compacted_delta_locator, storage_type=StorageType.LOCAL, **ds_mock_kwargs
-    )
-    actual_rebase_compacted_table = pa.concat_tables(tables)
-    # if no primary key is specified then sort by sort_key for consistent assertion
-    sorting_cols: List[Any] = (
-        [(val, "ascending") for val in primary_keys] if primary_keys else sort_keys
-    )
-    rebase_expected_compact_partition_result = (
-        rebase_expected_compact_partition_result.combine_chunks().sort_by(sorting_cols)
-    )
-    actual_rebase_compacted_table = (
-        actual_rebase_compacted_table.combine_chunks().sort_by(sorting_cols)
-    )
-    assert actual_rebase_compacted_table.equals(
-        rebase_expected_compact_partition_result
-    ), f"{actual_rebase_compacted_table} does not match {rebase_expected_compact_partition_result}"
+        # Assert not in-place compacted
+        assert (
+            execute_compaction_result_spy.call_args.args[-1] is False
+        ), "Table version erroneously marked as in-place compacted!"
+        compacted_delta_locator: DeltaLocator = get_compacted_delta_locator_from_rcf(
+            s3_resource, rcf_file_s3_uri
+        )
+        tables = ds.download_delta(
+            compacted_delta_locator, storage_type=StorageType.LOCAL, **ds_mock_kwargs
+        )
+        actual_rebase_compacted_table = pa.concat_tables(tables)
+        # if no primary key is specified then sort by sort_key for consistent assertion
+        sorting_cols: List[Any] = (
+            [(val, "ascending") for val in primary_keys] if primary_keys else sort_keys
+        )
+        rebase_expected_compact_partition_result = (
+            rebase_expected_compact_partition_result.combine_chunks().sort_by(
+                sorting_cols
+            )
+        )
+        actual_rebase_compacted_table = (
+            actual_rebase_compacted_table.combine_chunks().sort_by(sorting_cols)
+        )
+        assert actual_rebase_compacted_table.equals(
+            rebase_expected_compact_partition_result
+        ), f"{actual_rebase_compacted_table} does not match {rebase_expected_compact_partition_result}"
 
-    if assert_compaction_audit:
-        if not assert_compaction_audit(compactor_version, compaction_audit):
-            assert False, "Compaction audit assertion failed"
-    return
+        if assert_compaction_audit:
+            if not assert_compaction_audit(compactor_version, compaction_audit):
+                assert False, "Compaction audit assertion failed"
+        assert os.listdir(test_dir) == []
+        assert (
+            object_store_delete_many_spy.call_count
+        ), "Object store was never cleaned up!"
+        return