deltacat 1.1.17__tar.gz → 1.1.18__tar.gz

{deltacat-1.1.17/deltacat.egg-info → deltacat-1.1.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deltacat
-Version: 1.1.17
+Version: 1.1.18
 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.17 → deltacat-1.1.18}/deltacat/__init__.py

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

{deltacat-1.1.17 → deltacat-1.1.18}/deltacat/aws/constants.py

@@ -1,7 +1,6 @@
 import botocore
 from typing import Set
 from daft.exceptions import DaftTransientError
-
 from deltacat.utils.common import env_integer, env_string
 
 

{deltacat-1.1.17 → deltacat-1.1.18}/deltacat/compute/compactor_v2/utils/primary_key_index.py

@@ -27,8 +27,11 @@ def _append_sha1_hash_to_table(table: pa.Table, hash_column: pa.Array) -> pa.Tab
 
     result = []
     for hash_value in hash_column_np:
-        assert hash_value is not None, f"Expected non-null primary key"
-        result.append(hashlib.sha1(hash_value.encode("utf-8")).hexdigest())
+        if hash_value is None:
+            result.append(None)
+            logger.info("A primary key hash is null")
+        else:
+            result.append(hashlib.sha1(hash_value.encode("utf-8")).hexdigest())
 
     return sc.append_pk_hash_string_column(table, result)
 
@@ -191,7 +194,7 @@ def generate_pk_hash_column(
             pk_columns.append(sliced_string_cast(table[pk_name]))
 
         pk_columns.append(PK_DELIMITER)
-        hash_column = pc.binary_join_element_wise(*pk_columns)
+        hash_column = pc.binary_join_element_wise(*pk_columns, null_handling="replace")
         return hash_column
 
     def _generate_uuid(table: pa.Table) -> pa.Array:
@@ -345,8 +348,10 @@ def hash_group_index_to_hash_bucket_indices(
     return range(hb_group, num_buckets, num_groups)
 
 
-def pk_digest_to_hash_bucket_index(digest: str, num_buckets: int) -> int:
+def pk_digest_to_hash_bucket_index(digest: Optional[str], num_buckets: int) -> int:
     """
     Generates the hash bucket index from the given digest.
     """
+    if digest is None:
+        return 0
     return int(digest, 16) % num_buckets

{deltacat-1.1.17 → deltacat-1.1.18}/deltacat/exceptions.py

@@ -299,7 +299,7 @@ def _categorize_tenacity_error(e: tenacity.RetryError):
 def _categorize_dependency_pyarrow_error(e: ArrowException):
     if isinstance(e, ArrowInvalid):
         raise DependencyPyarrowInvalidError(
-            f"Pyarrow Invalid error occurred. Reason: {e}"
+            f"Pyarrow Invalid error occurred. {e}"
         ) from e
     elif isinstance(e, ArrowCapacityError):
         raise DependencyPyarrowCapacityError("Pyarrow Capacity error occurred.") from e
@@ -308,9 +308,7 @@ def _categorize_dependency_pyarrow_error(e: ArrowException):
 
 
 def _categorize_assertion_error(e: BaseException):
-    raise ValidationError(
-        f"One of the assertions in DeltaCAT has failed. Reason: {e}"
-    ) from e
+    raise ValidationError(f"One of the assertions in DeltaCAT has failed. {e}") from e
 
 
 def _categorize_daft_error(e: DaftCoreException):

{deltacat-1.1.17 → deltacat-1.1.18}/deltacat/tests/compute/compact_partition_multiple_rounds_test_cases.py

@@ -848,6 +848,83 @@ MULTIPLE_ROUNDS_TEST_CASES = {
         assert_compaction_audit=None,
         num_rounds=3,
     ),
+    # 4 input deltas (3 upsert, 1 delete delta), 2 rounds requested
+    # Expect to see a table that aggregates 10 records total
+    # (12 upserts - 2 deletes (null PK) = 10 records)
+    # (dropDuplicates = False)
+    "9-multiple-rounds-delete-deltas-with-null-pk": MultipleRoundsTestCaseParams(
+        primary_keys={"pk_col_1"},
+        sort_keys=ZERO_VALUED_SORT_KEY,
+        partition_keys=[PartitionKey.of("region_id", PartitionKeyType.INT)],
+        partition_values=["1"],
+        input_deltas=[
+            (
+                pa.Table.from_arrays(
+                    [
+                        pa.array([None, 11, 12, 13]),
+                        pa.array(["a", "b", "c", "d"]),
+                    ],
+                    names=["pk_col_1", "col_1"],
+                ),
+                DeltaType.UPSERT,
+                None,
+            ),
+            (
+                pa.Table.from_arrays(
+                    [
+                        pa.array([14, 15, 16, 17]),
+                        pa.array(["e", "f", "g", "h"]),
+                    ],
+                    names=["pk_col_1", "col_1"],
+                ),
+                DeltaType.UPSERT,
+                None,
+            ),
+            (
+                pa.Table.from_arrays(
+                    [
+                        pa.array([18, 19, 20, 21]),
+                        pa.array(["i", "j", "k", "l"]),
+                    ],
+                    names=["pk_col_1", "col_1"],
+                ),
+                DeltaType.UPSERT,
+                None,
+            ),
+            (
+                pa.Table.from_arrays(
+                    [pa.array([None, 11]), pa.array(["a", "b"])],
+                    names=["pk_col_1", "col_1"],
+                ),
+                DeltaType.DELETE,
+                DeleteParameters.of(["pk_col_1", "col_1"]),
+            ),
+        ],
+        rebase_expected_compact_partition_result=pa.Table.from_arrays(
+            [
+                pa.array([i for i in range(12, 22)]),
+                pa.array(["c", "d", "e", "f", "g", "h", "i", "j", "k", "l"]),
+            ],
+            names=["pk_col_1", "col_1"],
+        ),
+        expected_terminal_compact_partition_result=pa.Table.from_arrays(
+            [
+                pa.array([i for i in range(12, 22)]),
+                pa.array(["c", "d", "e", "f", "g", "h", "i", "j", "k", "l"]),
+            ],
+            names=["pk_col_1", "col_1"],
+        ),
+        expected_terminal_exception=None,
+        expected_terminal_exception_message=None,
+        do_create_placement_group=False,
+        records_per_compacted_file=DEFAULT_MAX_RECORDS_PER_FILE,
+        hash_bucket_count=DEFAULT_HASH_BUCKET_COUNT,
+        read_kwargs_provider=None,
+        drop_duplicates=False,
+        skip_enabled_compact_partition_drivers=[CompactorVersion.V1],
+        assert_compaction_audit=None,
+        num_rounds=2,
+    ),
 }
 
 MULTIPLE_ROUNDS_TEST_CASES = with_compactor_version_func_test_param(

deltacat-1.1.18/deltacat/tests/compute/compact_partition_rebase_test_cases.py

@@ -0,0 +1,397 @@
+import pyarrow as pa
+from deltacat.tests.compute.test_util_common import (
+    PartitionKey,
+    PartitionKeyType,
+)
+from deltacat.tests.compute.test_util_constant import (
+    DEFAULT_MAX_RECORDS_PER_FILE,
+    DEFAULT_HASH_BUCKET_COUNT,
+)
+from dataclasses import dataclass
+
+
+from deltacat.storage import (
+    DeltaType,
+)
+
+from deltacat.compute.compactor.model.compactor_version import CompactorVersion
+
+from deltacat.storage.model.sort_key import SortKey
+
+from deltacat.tests.compute.compact_partition_test_cases import (
+    BaseCompactorTestCase,
+    with_compactor_version_func_test_param,
+)
+
+
+@dataclass(frozen=True)
+class RebaseCompactionTestCaseParams(BaseCompactorTestCase):
+    """
+    A pytest parameterized test case for the `compact_partition` function with rebase compaction.
+
+    Args:
+        * (inherited from CompactorTestCase): see CompactorTestCase docstring for details
+        rebase_expected_compact_partition_result: pa.Table - expected table after rebase compaction runs. An output that is asserted on in Rebase unit tests
+    """
+
+    rebase_expected_compact_partition_result: pa.Table
+
+
+REBASE_TEST_CASES = {
+    "1-rebase-sanity": RebaseCompactionTestCaseParams(
+        primary_keys={"pk_col_1"},
+        sort_keys=[
+            SortKey.of(key_name="sk_col_1"),
+            SortKey.of(key_name="sk_col_2"),
+        ],
+        partition_keys=[PartitionKey.of("region_id", PartitionKeyType.INT)],
+        partition_values=["1"],
+        input_deltas=pa.Table.from_arrays(
+            [
+                pa.array([str(i) for i in range(10)]),
+                pa.array([i for i in range(0, 10)]),
+                pa.array(["foo"] * 10),
+                pa.array([i / 10 for i in range(10, 20)]),
+            ],
+            names=["pk_col_1", "sk_col_1", "sk_col_2", "col_1"],
+        ),
+        input_deltas_delta_type=DeltaType.UPSERT,
+        rebase_expected_compact_partition_result=pa.Table.from_arrays(
+            [
+                pa.array([str(i) for i in range(10)]),
+                pa.array([i for i in range(0, 10)]),
+                pa.array(["foo"] * 10),
+                pa.array([i / 10 for i in range(10, 20)]),
+            ],
+            names=["pk_col_1", "sk_col_1", "sk_col_2", "col_1"],
+        ),
+        expected_terminal_compact_partition_result=pa.Table.from_arrays(
+            [
+                pa.array([str(i) for i in range(10)]),
+                pa.array([i for i in range(20, 30)]),
+                pa.array(["foo"] * 10),
+                pa.array([i / 10 for i in range(40, 50)]),
+            ],
+            names=["pk_col_1", "sk_col_1", "sk_col_2", "col_1"],
+        ),
+        expected_terminal_exception=None,
+        expected_terminal_exception_message=None,
+        do_create_placement_group=False,
+        records_per_compacted_file=DEFAULT_MAX_RECORDS_PER_FILE,
+        hash_bucket_count=DEFAULT_HASH_BUCKET_COUNT,
+        read_kwargs_provider=None,
+        drop_duplicates=True,
+        skip_enabled_compact_partition_drivers=[CompactorVersion.V1],
+        assert_compaction_audit=None,
+    ),
+    "2-rebase-with-null-pk": RebaseCompactionTestCaseParams(
+        primary_keys={"pk_col_1"},
+        sort_keys=[
+            SortKey.of(key_name="sk_col_1"),
+            SortKey.of(key_name="sk_col_2"),
+        ],
+        partition_keys=[PartitionKey.of("region_id", PartitionKeyType.INT)],
+        partition_values=["1"],
+        input_deltas=pa.Table.from_arrays(
+            [
+                pa.array([1, 2, None, 2, None, 1]),
+                pa.array([1, 2, 3, 4, 5, 6]),
+                pa.array(["foo"] * 6),
+                pa.array([5, 6, 7, 8, 9, 10]),
+            ],
+            names=["pk_col_1", "sk_col_1", "sk_col_2", "col_1"],
+        ),
+        input_deltas_delta_type=DeltaType.UPSERT,
+        rebase_expected_compact_partition_result=pa.Table.from_arrays(
+            [
+                pa.array([None, 1, 2]),
+                pa.array([5, 6, 4]),
+                pa.array(["foo"] * 3),
+                pa.array([9, 10, 8]),
+            ],
+            names=["pk_col_1", "sk_col_1", "sk_col_2", "col_1"],
+        ),
+        expected_terminal_compact_partition_result=pa.Table.from_arrays(
+            [
+                pa.array([None, 1, 2]),
+                pa.array([5, 6, 4]),
+                pa.array(["foo"] * 3),
+                pa.array([7, 10, 8]),
+            ],
+            names=["pk_col_1", "sk_col_1", "sk_col_2", "col_1"],
+        ),
+        expected_terminal_exception=None,
+        expected_terminal_exception_message=None,
+        do_create_placement_group=False,
+        records_per_compacted_file=DEFAULT_MAX_RECORDS_PER_FILE,
+        hash_bucket_count=DEFAULT_HASH_BUCKET_COUNT,
+        read_kwargs_provider=None,
+        drop_duplicates=True,
+        skip_enabled_compact_partition_drivers=[CompactorVersion.V1],
+        assert_compaction_audit=None,
+    ),
+    "3-rebase-with-null-two-pk": RebaseCompactionTestCaseParams(
+        primary_keys={"pk_col_1", "pk_col_2"},
+        sort_keys=[
+            SortKey.of(key_name="sk_col_1"),
+        ],
+        partition_keys=[PartitionKey.of("region_id", PartitionKeyType.INT)],
+        partition_values=["1"],
+        input_deltas=pa.Table.from_arrays(
+            [
+                pa.array([1, 2, None, 2, None, 1, 5]),
+                pa.array([1, None, 3, None, None, 1, 5]),
+                pa.array(["foo"] * 7),
+                pa.array([5, 6, 7, 8, 9, 10, 11]),
+            ],
+            names=["pk_col_1", "pk_col_2", "sk_col_1", "col_1"],
+        ),
+        input_deltas_delta_type=DeltaType.UPSERT,
+        rebase_expected_compact_partition_result=pa.Table.from_arrays(
+            [
+                pa.array([1, 2, None, 5, None]),
+                pa.array([1, None, 3, 5, None]),
+                pa.array(["foo"] * 5),
+                pa.array([10, 8, 7, 11, 9]),
+            ],
+            names=["pk_col_1", "pk_col_2", "sk_col_1", "col_1"],
+        ),
+        expected_terminal_compact_partition_result=pa.Table.from_arrays(
+            [
+                pa.array([1, 2, None, 5, None]),
+                pa.array([1, None, 3, 5, None]),
+                pa.array(["foo"] * 5),
+                pa.array([10, 8, 7, 11, 9]),
+            ],
+            names=["pk_col_1", "pk_col_2", "sk_col_1", "col_1"],
+        ),
+        expected_terminal_exception=None,
+        expected_terminal_exception_message=None,
+        do_create_placement_group=False,
+        records_per_compacted_file=DEFAULT_MAX_RECORDS_PER_FILE,
+        hash_bucket_count=DEFAULT_HASH_BUCKET_COUNT,
+        read_kwargs_provider=None,
+        drop_duplicates=True,
+        skip_enabled_compact_partition_drivers=[CompactorVersion.V1],
+        assert_compaction_audit=None,
+    ),
+    "4-rebase-with-null-multiple-pk-different-types": RebaseCompactionTestCaseParams(
+        primary_keys={"pk_col_1", "pk_col_2", "pk_col_3"},
+        sort_keys=[],
+        partition_keys=[PartitionKey.of("region_id", PartitionKeyType.INT)],
+        partition_values=["1"],
+        input_deltas=pa.Table.from_arrays(
+            [
+                pa.array([1, 2, None, 2, None, 1, 5, None, None, None]),
+                pa.array([1, None, 3, None, None, 1, 5, None, None, None]),
+                pa.array(["a", "b", "c", "b", "e", "a", "g", "e", None, None]),
+                pa.array([5, 6, 7, 8, 9, 10, 11, 12, 13, 14]),
+            ],
+            names=["pk_col_1", "pk_col_2", "pk_col_3", "col_1"],
+        ),
+        input_deltas_delta_type=DeltaType.UPSERT,
+        rebase_expected_compact_partition_result=pa.Table.from_arrays(
+            [
+                pa.array([1, 2, None, 5, None, None]),
+                pa.array([1, None, 3, 5, None, None]),
+                pa.array(["a", "b", "c", "g", "e", None]),
+                pa.array([10, 8, 7, 11, 12, 14]),
+            ],
+            names=["pk_col_1", "pk_col_2", "pk_col_3", "col_1"],
+        ),
+        expected_terminal_compact_partition_result=pa.Table.from_arrays(
+            [
+                pa.array([1, 2, None, 5, None, None]),
+                pa.array([1, None, 3, 5, None, None]),
+                pa.array(["a", "b", "c", "g", "e", None]),
+                pa.array([10, 8, 7, 11, 12, 14]),
+            ],
+            names=["pk_col_1", "pk_col_2", "pk_col_3", "col_1"],
+        ),
+        expected_terminal_exception=None,
+        expected_terminal_exception_message=None,
+        do_create_placement_group=False,
+        records_per_compacted_file=DEFAULT_MAX_RECORDS_PER_FILE,
+        hash_bucket_count=DEFAULT_HASH_BUCKET_COUNT,
+        read_kwargs_provider=None,
+        drop_duplicates=True,
+        skip_enabled_compact_partition_drivers=[CompactorVersion.V1],
+        assert_compaction_audit=None,
+    ),
+    "5-rebase-with-null-multiple-pk-one-hash-bucket": RebaseCompactionTestCaseParams(
+        primary_keys={"pk_col_1", "pk_col_2", "pk_col_3"},
+        sort_keys=[],
+        partition_keys=[PartitionKey.of("region_id", PartitionKeyType.INT)],
+        partition_values=["1"],
+        input_deltas=pa.Table.from_arrays(
+            [
+                pa.array([1, 2, None, 2, None, 1, 5, None, None, None]),
+                pa.array([1, None, 3, None, None, 1, 5, None, None, None]),
+                pa.array(["a", "b", "c", "b", "e", "a", "g", "e", None, None]),
+                pa.array([5, 6, 7, 8, 9, 10, 11, 12, 13, 14]),
+            ],
+            names=["pk_col_1", "pk_col_2", "pk_col_3", "col_1"],
+        ),
+        input_deltas_delta_type=DeltaType.UPSERT,
+        rebase_expected_compact_partition_result=pa.Table.from_arrays(
+            [
+                pa.array([1, 2, None, 5, None, None]),
+                pa.array([1, None, 3, 5, None, None]),
+                pa.array(["a", "b", "c", "g", "e", None]),
+                pa.array([10, 8, 7, 11, 12, 14]),
+            ],
+            names=["pk_col_1", "pk_col_2", "pk_col_3", "col_1"],
+        ),
+        expected_terminal_compact_partition_result=pa.Table.from_arrays(
+            [
+                pa.array([1, 2, None, 5, None, None]),
+                pa.array([1, None, 3, 5, None, None]),
+                pa.array(["a", "b", "c", "g", "e", None]),
+                pa.array([10, 8, 7, 11, 12, 14]),
+            ],
+            names=["pk_col_1", "pk_col_2", "pk_col_3", "col_1"],
+        ),
+        expected_terminal_exception=None,
+        expected_terminal_exception_message=None,
+        do_create_placement_group=False,
+        records_per_compacted_file=DEFAULT_MAX_RECORDS_PER_FILE,
+        hash_bucket_count=1,
+        read_kwargs_provider=None,
+        drop_duplicates=True,
+        skip_enabled_compact_partition_drivers=[CompactorVersion.V1],
+        assert_compaction_audit=None,
+    ),
+    "6-rebase-with-null-multiple-pk-drop-duplicates-false": RebaseCompactionTestCaseParams(
+        primary_keys={"pk_col_1", "pk_col_2", "pk_col_3"},
+        sort_keys=[],
+        partition_keys=[PartitionKey.of("region_id", PartitionKeyType.INT)],
+        partition_values=["1"],
+        input_deltas=pa.Table.from_arrays(
+            [
+                pa.array([1, 2, None, 2, None, 1, 5, None, None, None]),
+                pa.array([1, None, 3, None, None, 1, 5, None, None, None]),
+                pa.array(["a", "b", "c", "b", "e", "a", "g", "e", None, None]),
+                pa.array([5, 6, 7, 8, 9, 10, 11, 12, 13, 14]),
+            ],
+            names=["pk_col_1", "pk_col_2", "pk_col_3", "col_1"],
+        ),
+        input_deltas_delta_type=DeltaType.UPSERT,
+        rebase_expected_compact_partition_result=pa.Table.from_arrays(
+            [
+                pa.array([1, 2, None, 2, None, 1, 5, None, None, None]),
+                pa.array([1, None, 3, None, None, 1, 5, None, None, None]),
+                pa.array(["a", "b", "c", "b", "e", "a", "g", "e", None, None]),
+                pa.array([5, 6, 7, 8, 9, 10, 11, 12, 13, 14]),
+            ],
+            names=["pk_col_1", "pk_col_2", "pk_col_3", "col_1"],
+        ),
+        expected_terminal_compact_partition_result=pa.Table.from_arrays(
+            [
+                pa.array([1, 2, None, 2, None, 1, 5, None, None, None]),
+                pa.array([1, None, 3, None, None, 1, 5, None, None, None]),
+                pa.array(["a", "b", "c", "b", "e", "a", "g", "e", None, None]),
+                pa.array([5, 6, 7, 8, 9, 10, 11, 12, 13, 14]),
+            ],
+            names=["pk_col_1", "pk_col_2", "pk_col_3", "col_1"],
+        ),
+        expected_terminal_exception=None,
+        expected_terminal_exception_message=None,
+        do_create_placement_group=False,
+        records_per_compacted_file=DEFAULT_MAX_RECORDS_PER_FILE,
+        hash_bucket_count=DEFAULT_HASH_BUCKET_COUNT,
+        read_kwargs_provider=None,
+        drop_duplicates=False,
+        skip_enabled_compact_partition_drivers=[CompactorVersion.V1],
+        assert_compaction_audit=None,
+    ),
+    "7-rebase-drop-duplicates-false": RebaseCompactionTestCaseParams(
+        primary_keys={"pk_col_1"},
+        sort_keys=[
+            SortKey.of(key_name="sk_col_1"),
+        ],
+        partition_keys=[PartitionKey.of("region_id", PartitionKeyType.INT)],
+        partition_values=["1"],
+        input_deltas=pa.Table.from_arrays(
+            [
+                pa.array([1, 2, 2, 3, 3, 1]),
+                pa.array([1, 2, 3, 4, 5, 6]),
+                pa.array(["a", "b", "c", "b", "e", "a"]),
+                pa.array([5, 6, 7, 8, 9, 10]),
+            ],
+            names=["pk_col_1", "sk_col_1", "col_1", "col_2"],
+        ),
+        input_deltas_delta_type=DeltaType.UPSERT,
+        rebase_expected_compact_partition_result=pa.Table.from_arrays(
+            [
+                pa.array([1, 2, 2, 3, 3, 1]),
+                pa.array([1, 2, 3, 4, 5, 6]),
+                pa.array(["a", "b", "c", "b", "e", "a"]),
+                pa.array([5, 6, 7, 8, 9, 10]),
+            ],
+            names=["pk_col_1", "sk_col_1", "col_1", "col_2"],
+        ),
+        expected_terminal_compact_partition_result=pa.Table.from_arrays(
+            [
+                pa.array([1, 2, 2, 3, 3, 1]),
+                pa.array([1, 2, 3, 4, 5, 6]),
+                pa.array(["a", "b", "c", "b", "e", "a"]),
+                pa.array([5, 6, 7, 8, 9, 10]),
+            ],
+            names=["pk_col_1", "sk_col_1", "col_1", "col_2"],
+        ),
+        expected_terminal_exception=None,
+        expected_terminal_exception_message=None,
+        do_create_placement_group=False,
+        records_per_compacted_file=DEFAULT_MAX_RECORDS_PER_FILE,
+        hash_bucket_count=DEFAULT_HASH_BUCKET_COUNT,
+        read_kwargs_provider=None,
+        drop_duplicates=False,
+        skip_enabled_compact_partition_drivers=[CompactorVersion.V1],
+        assert_compaction_audit=None,
+    ),
+    "8-rebase-with-with-null-pk-duplicates-false-hash-bucket-1": RebaseCompactionTestCaseParams(
+        primary_keys={"pk_col_1", "pk_col_2", "pk_col_3"},
+        sort_keys=[],
+        partition_keys=[PartitionKey.of("region_id", PartitionKeyType.INT)],
+        partition_values=["1"],
+        input_deltas=pa.Table.from_arrays(
+            [
+                pa.array([1, 2, None, 2, None, 1, 5, None, None, None]),
+                pa.array([1, None, 3, None, None, 1, 5, None, None, None]),
+                pa.array(["a", "b", "c", "b", "e", "a", "g", "e", None, None]),
+                pa.array([5, 6, 7, 8, 9, 10, 11, 12, 13, 14]),
+            ],
+            names=["pk_col_1", "pk_col_2", "pk_col_3", "col_1"],
+        ),
+        input_deltas_delta_type=DeltaType.UPSERT,
+        rebase_expected_compact_partition_result=pa.Table.from_arrays(
+            [
+                pa.array([1, 2, None, 2, None, 1, 5, None, None, None]),
+                pa.array([1, None, 3, None, None, 1, 5, None, None, None]),
+                pa.array(["a", "b", "c", "b", "e", "a", "g", "e", None, None]),
+                pa.array([5, 6, 7, 8, 9, 10, 11, 12, 13, 14]),
+            ],
+            names=["pk_col_1", "pk_col_2", "pk_col_3", "col_1"],
+        ),
+        expected_terminal_compact_partition_result=pa.Table.from_arrays(
+            [
+                pa.array([1, 2, None, 2, None, 1, 5, None, None, None]),
+                pa.array([1, None, 3, None, None, 1, 5, None, None, None]),
+                pa.array(["a", "b", "c", "b", "e", "a", "g", "e", None, None]),
+                pa.array([5, 6, 7, 8, 9, 10, 11, 12, 13, 14]),
+            ],
+            names=["pk_col_1", "pk_col_2", "pk_col_3", "col_1"],
+        ),
+        expected_terminal_exception=None,
+        expected_terminal_exception_message=None,
+        do_create_placement_group=False,
+        records_per_compacted_file=1,
+        hash_bucket_count=1,
+        read_kwargs_provider=None,
+        drop_duplicates=False,
+        skip_enabled_compact_partition_drivers=[CompactorVersion.V1],
+        assert_compaction_audit=None,
+    ),
+}
+
+REBASE_TEST_CASES = with_compactor_version_func_test_param(REBASE_TEST_CASES)