Restore the proper meta-params of PK column type relevant to each side when slicing

Otherwise, it uses the same PK values, e.g. `ArithUUID` from the side A, and then pushes them to side B, where improper rendering can lead to improper slicing.

Author: Sergey Vasilyev

data_diff/abcs/database_types.py

@@ -182,6 +182,8 @@ def python_type(self) -> type:
         "Return the equivalent Python type of the key"
 
     def make_value(self, value):
+        if isinstance(value, self.python_type):
+            return value
         return self.python_type(value)
 
 
@@ -237,9 +239,6 @@ def test_value(value: str) -> bool:
         except ValueError:
             return False
 
-    def make_value(self, value):
-        return self.python_type(value)
-
 
 @attrs.define(frozen=True)
 class String_VaryingAlphanum(String_Alphanum):
@@ -251,6 +250,8 @@ class String_FixedAlphanum(String_Alphanum):
     length: int
 
     def make_value(self, value):
+        if isinstance(value, self.python_type):
+            return value
         if len(value) != self.length:
             raise ValueError(f"Expected alphanumeric value of length {self.length}, but got '{value}'.")
         return self.python_type(value, max_len=self.length)

data_diff/diff_tables.py

@@ -297,7 +297,8 @@ def _bisect_and_diff_tables(self, table1: TableSegment, table2: TableSegment, in
         # Start with the first completed value, so we don't waste time waiting
         min_key1, max_key1 = self._parse_key_range_result(key_types1, next(key_ranges))
 
-        btable1, btable2 = [t.new_key_bounds(min_key=min_key1, max_key=max_key1) for t in (table1, table2)]
+        btable1 = table1.new_key_bounds(min_key=min_key1, max_key=max_key1, key_types=key_types1)
+        btable2 = table2.new_key_bounds(min_key=min_key1, max_key=max_key1, key_types=key_types2)
 
         logger.info(
             f"Diffing segments at key-range: {btable1.min_key}..{btable2.max_key}. "
@@ -321,16 +322,18 @@ def _bisect_and_diff_tables(self, table1: TableSegment, table2: TableSegment, in
         # └──┴──────┴──┘
         # Overall, the max number of new regions in this 2nd pass is 3^|k| - 1
 
-        min_key2, max_key2 = self._parse_key_range_result(key_types1, next(key_ranges))
+        # Note: python types can be the same, but the rendering parameters (e.g. casing) can differ.
+        min_key2, max_key2 = self._parse_key_range_result(key_types2, next(key_ranges))
 
         points = [list(sorted(p)) for p in safezip(min_key1, min_key2, max_key1, max_key2)]
         box_mesh = create_mesh_from_points(*points)
 
         new_regions = [(p1, p2) for p1, p2 in box_mesh if p1 < p2 and not (p1 >= min_key1 and p2 <= max_key1)]
 
         for p1, p2 in new_regions:
-            extra_tables = [t.new_key_bounds(min_key=p1, max_key=p2) for t in (table1, table2)]
-            ti.submit(self._bisect_and_diff_segments, ti, *extra_tables, info_tree, priority=999)
+            extra_table1 = table1.new_key_bounds(min_key=p1, max_key=p2, key_types=key_types1)
+            extra_table2 = table2.new_key_bounds(min_key=p1, max_key=p2, key_types=key_types2)
+            ti.submit(self._bisect_and_diff_segments, ti, extra_table1, extra_table2, info_tree, priority=999)
 
         return ti
 

data_diff/table_segment.py

@@ -1,5 +1,5 @@
 import time
-from typing import Container, Dict, List, Optional, Tuple
+from typing import Container, Dict, List, Optional, Sequence, Tuple
 import logging
 from itertools import product
 
@@ -9,7 +9,7 @@
 from data_diff.utils import safezip, Vector
 from data_diff.utils import ArithString, split_space
 from data_diff.databases.base import Database
-from data_diff.abcs.database_types import DbPath, DbKey, DbTime
+from data_diff.abcs.database_types import DbPath, DbKey, DbTime, IKey
 from data_diff.schema import RawColumnInfo, Schema, create_schema
 from data_diff.queries.extras import Checksum
 from data_diff.queries.api import Count, SKIP, table, this, Expr, min_, max_, Code
@@ -205,7 +205,7 @@ def new(self, **kwargs) -> Self:
         """Creates a copy of the instance using 'replace()'"""
         return attrs.evolve(self, **kwargs)
 
-    def new_key_bounds(self, min_key: Vector, max_key: Vector) -> Self:
+    def new_key_bounds(self, min_key: Vector, max_key: Vector, *, key_types: Optional[Sequence[IKey]] = None) -> Self:
         if self.min_key is not None:
             assert self.min_key <= min_key, (self.min_key, min_key)
             assert self.min_key < max_key
@@ -214,6 +214,13 @@ def new_key_bounds(self, min_key: Vector, max_key: Vector) -> Self:
             assert min_key < self.max_key
             assert max_key <= self.max_key
 
+        # If asked, enforce the PKs to proper types, mainly to meta-params of the relevant side,
+        # so that we do not leak e.g. casing of UUIDs from side A to side B and vice versa.
+        # If not asked, keep the meta-params of the keys as is (assume them already casted).
+        if key_types is not None:
+            min_key = Vector(type.make_value(val) for type, val in safezip(key_types, min_key))
+            max_key = Vector(type.make_value(val) for type, val in safezip(key_types, max_key))
+
         return attrs.evolve(self, min_key=min_key, max_key=max_key)
 
     @property

data_diff/utils.py

@@ -135,8 +135,10 @@ def range(self, other: "ArithString", count: int) -> List[Self]:
         return [self.new(int=i) for i in checkpoints]
 
 
-def _any_to_uuid(v: Union[str, int, UUID]) -> UUID:
-    if isinstance(v, UUID):
+def _any_to_uuid(v: Union[str, int, UUID, "ArithUUID"]) -> UUID:
+    if isinstance(v, ArithUUID):
+        return v.uuid
+    elif isinstance(v, UUID):
         return v
     elif isinstance(v, str):
         return UUID(v)

tests/test_mesh.py

@@ -0,0 +1,132 @@
+import uuid
+
+from data_diff.abcs.database_types import String_UUID
+from data_diff.databases import MySQL
+from data_diff.table_segment import create_mesh_from_points
+from data_diff.utils import ArithUUID, safezip
+from tests.common import DiffTestCase, table_segment
+
+
+# We do not need real tables, just any reference to them for proper object creation.
+class TestDiffMesh(DiffTestCase):
+    db_cls = MySQL
+
+    def test_meta_parameters_passed_from_coltypes_to_values(self):
+        key_types1 = [String_UUID(lowercase=True, uppercase=False)]
+        key_types2 = [String_UUID(lowercase=False, uppercase=True)]
+
+        # side B is wider than side A to ensure there are "outer" regions.
+        min_uuid1 = uuid.UUID("11111111-1111-1111-1111-111111111111")
+        max_uuid1 = uuid.UUID("EEEEEEEE-EEEE-EEEE-EEEE-EEEEEEEEEEEE")
+        min_uuid2 = uuid.UUID("00000000-0000-0000-0000-000000000000")
+        max_uuid2 = uuid.UUID("FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF")
+        min_key1 = (key_types1[0].make_value(min_uuid1),)
+        max_key1 = (key_types1[0].make_value(max_uuid1),)
+        min_key2 = (key_types2[0].make_value(min_uuid2),)
+        max_key2 = (key_types2[0].make_value(max_uuid2),)
+
+        # Verify that we pass the meta-parameters from col types to values:
+        assert isinstance(min_key1[0], ArithUUID)
+        assert isinstance(max_key1[0], ArithUUID)
+        assert isinstance(min_key2[0], ArithUUID)
+        assert isinstance(max_key2[0], ArithUUID)
+        assert min_key1[0].uuid == min_uuid1
+        assert min_key1[0].lowercase == True
+        assert min_key1[0].uppercase == False
+        assert max_key1[0].uuid == max_uuid1
+        assert max_key1[0].lowercase == True
+        assert max_key1[0].uppercase == False
+        assert min_key2[0].uuid == min_uuid2
+        assert min_key2[0].lowercase == False
+        assert min_key2[0].uppercase == True
+        assert max_key2[0].uuid == max_uuid2
+        assert max_key2[0].lowercase == False
+        assert max_key2[0].uppercase == True
+
+    def test_meta_parameters_left_as_is_if_not_casted(self):
+        table1 = table_segment(self.connection, self.table_src_path, "id", "timestamp", case_sensitive=False)
+        key_types1 = [String_UUID(lowercase=True, uppercase=False)]
+
+        min_uuid1 = uuid.UUID("11111111-1111-1111-1111-111111111111")
+        max_uuid1 = uuid.UUID("EEEEEEEE-EEEE-EEEE-EEEE-EEEEEEEEEEEE")
+        min_key1 = (key_types1[0].make_value(min_uuid1),)
+        max_key1 = (key_types1[0].make_value(max_uuid1),)
+
+        btable1 = table1.new_key_bounds(min_key=min_key1, max_key=max_key1)
+        assert btable1.min_key[0] is min_key1[0]  # by identity, not by equality
+        assert btable1.max_key[0] is max_key1[0]  # by identity, not by equality
+
+    def test_mesh_keys_meta_parameters_preserved(self):
+        table1 = table_segment(self.connection, self.table_src_path, "id", "timestamp", case_sensitive=False)
+        table2 = table_segment(self.connection, self.table_src_path, "id", "timestamp", case_sensitive=False)
+        key_types1 = [String_UUID(lowercase=True, uppercase=False)]
+        key_types2 = [String_UUID(lowercase=False, uppercase=True)]
+
+        # side B is wider than side A to ensure there are "outer" regions.
+        min_uuid1 = uuid.UUID("11111111-1111-1111-1111-111111111111")
+        max_uuid1 = uuid.UUID("EEEEEEEE-EEEE-EEEE-EEEE-EEEEEEEEEEEE")
+        min_uuid2 = uuid.UUID("00000000-0000-0000-0000-000000000000")
+        max_uuid2 = uuid.UUID("FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF")
+        min_key1 = (key_types1[0].make_value(min_uuid1),)
+        max_key1 = (key_types1[0].make_value(max_uuid1),)
+        min_key2 = (key_types2[0].make_value(min_uuid2),)
+        max_key2 = (key_types2[0].make_value(max_uuid2),)
+
+        # This is what TableDiffer._bisect_and_diff_tables() does, precisely (yes, using key1!):
+        btable1 = table1.new_key_bounds(min_key=min_key1, max_key=max_key1, key_types=key_types1)
+        btable2 = table2.new_key_bounds(min_key=min_key1, max_key=max_key1, key_types=key_types2)
+
+        # Verify that both sides have proper (the side-specific) pk meta-parameters:
+        assert btable1.min_key[0].uuid == min_uuid1
+        assert btable1.min_key[0].lowercase == True
+        assert btable1.min_key[0].uppercase == False
+        assert btable1.max_key[0].uuid == max_uuid1
+        assert btable1.max_key[0].lowercase == True
+        assert btable1.max_key[0].uppercase == False
+        assert btable2.min_key[0].uuid == min_uuid1
+        assert btable2.min_key[0].lowercase == False
+        assert btable2.min_key[0].uppercase == True
+        assert btable2.max_key[0].uuid == max_uuid1
+        assert btable2.max_key[0].lowercase == False
+        assert btable2.max_key[0].uppercase == True
+
+        # This is what TableDiffer._bisect_and_diff_tables() does, precisely:
+        points = [list(sorted(p)) for p in safezip(min_key1, min_key2, max_key1, max_key2)]
+        box_mesh = create_mesh_from_points(*points)
+        new_regions = [(p1, p2) for p1, p2 in box_mesh if p1 < p2 and not (p1 >= min_key1 and p2 <= max_key1)]
+        extra_tables = [
+            (
+                table1.new_key_bounds(min_key=p1, max_key=p2, key_types=key_types1),
+                table2.new_key_bounds(min_key=p1, max_key=p2, key_types=key_types2),
+            )
+            for p1, p2 in new_regions
+        ]
+
+        # Verify that extra ("outer") segments have the proper pk meta-parameters:
+        assert len(extra_tables) == 2
+
+        assert extra_tables[0][0].min_key[0].uuid == min_uuid2
+        assert extra_tables[0][0].min_key[0].lowercase == True
+        assert extra_tables[0][0].min_key[0].uppercase == False
+        assert extra_tables[0][0].max_key[0].uuid == min_uuid1
+        assert extra_tables[0][0].max_key[0].lowercase == True
+        assert extra_tables[0][0].max_key[0].uppercase == False
+        assert extra_tables[0][1].min_key[0].uuid == min_uuid2
+        assert extra_tables[0][1].min_key[0].lowercase == False
+        assert extra_tables[0][1].min_key[0].uppercase == True
+        assert extra_tables[0][1].max_key[0].uuid == min_uuid1
+        assert extra_tables[0][1].max_key[0].lowercase == False
+        assert extra_tables[0][1].max_key[0].uppercase == True
+
+        assert extra_tables[1][0].min_key[0].uuid == max_uuid1
+        assert extra_tables[1][0].min_key[0].lowercase == True
+        assert extra_tables[1][0].min_key[0].uppercase == False
+        assert extra_tables[1][0].max_key[0].uuid == max_uuid2
+        assert extra_tables[1][0].max_key[0].lowercase == True
+        assert extra_tables[1][0].max_key[0].uppercase == False
+        assert extra_tables[1][1].min_key[0].uuid == max_uuid1
+        assert extra_tables[1][1].min_key[0].lowercase == False
+        assert extra_tables[1][1].min_key[0].uppercase == True
+        assert extra_tables[1][1].max_key[0].uuid == max_uuid2
+        assert extra_tables[1][1].max_key[0].lowercase == False
+        assert extra_tables[1][1].max_key[0].uppercase == True