sqlbuild 0.94.6__tar.gz → 0.96.0__tar.gz

{sqlbuild-0.94.6 → sqlbuild-0.96.0}/Cargo.lock

@@ -529,7 +529,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-rules-native"
-version = "0.94.6"
+version = "0.96.0"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.94.6 → sqlbuild-0.96.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.94.6
+Version: 0.96.0
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: filelock>=3.20.3
 Requires-Dist: orjson>=3.10.0

{sqlbuild-0.94.6 → sqlbuild-0.96.0}/crates/sqlbuild-rules-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlbuild-rules-native"
-version = "0.94.6"
+version = "0.96.0"
 edition.workspace = true
 license.workspace = true
 publish.workspace = true

{sqlbuild-0.94.6 → sqlbuild-0.96.0}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlbuild"
-version = "0.94.6"
+version = "0.96.0"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"

{sqlbuild-0.94.6 → sqlbuild-0.96.0}/src/sqlbuild/adapter/contract/classes/base_adapter.py

@@ -28,8 +28,11 @@ from sqlbuild.adapter.contract.models import (
     FunctionInfo,
     QueryResult,
     RelationInfo,
+    RowDiffCoverage,
+    RowDiffPreparedRelations,
     RowDiffResult,
     RowDiffSampleRow,
+    RowDiffSampling,
     RowDiffTolerance,
     RowDiffTolerances,
     SchemaDiffResult,
@@ -1537,6 +1540,147 @@ class BaseAdapter(RetentionAdapterMixin, StrictAdapter):
         result: Any = cursor.fetchone()
         return int(result[0])
 
+    def _inspect_row_diff_coverage(
+        self,
+        *,
+        connection: Any,
+        relation: str,
+        cursor_column: str | None = None,
+        start_cursor: CursorValue | None = None,
+        end_cursor: CursorValue | None = None,
+    ) -> RowDiffCoverage:
+        """Return exact bounded row count and cursor extent for one relation."""
+
+        cursor_filter: str = self.build_cursor_filter(
+            cursor_column=cursor_column,
+            start_cursor=start_cursor,
+            end_cursor=end_cursor,
+        )
+        projections: str = "COUNT(*)"
+        if cursor_column is not None:
+            projections += f", MIN({cursor_column}), MAX({cursor_column})"
+        query: str = f"SELECT {projections} FROM {relation}"
+        if cursor_filter:
+            query += f" WHERE {cursor_filter}"
+        row: tuple[Any, ...] = self.execute(connection=connection, sql=query).fetchone()
+        return RowDiffCoverage(
+            row_count=int(row[0]),
+            minimum_cursor=row[1] if cursor_column is not None else None,
+            maximum_cursor=row[2] if cursor_column is not None else None,
+        )
+
+    def inspect_row_diff_coverage(
+        self,
+        *,
+        connection: Any,
+        relation: str,
+        cursor_column: str | None = None,
+        start_cursor: CursorValue | None = None,
+        end_cursor: CursorValue | None = None,
+    ) -> RowDiffCoverage:
+        """Return exact bounded row count and cursor extent for custom adapters."""
+
+        return self._inspect_row_diff_coverage(
+            connection=connection,
+            relation=relation,
+            cursor_column=cursor_column,
+            start_cursor=start_cursor,
+            end_cursor=end_cursor,
+        )
+
+    def _build_row_diff_relation_ctes(
+        self,
+        *,
+        connection: Any,
+        left_sql: str,
+        right_sql: str,
+        keys: tuple[str, ...],
+        sampling: RowDiffSampling | None,
+        inspect_population: bool,
+    ) -> RowDiffPreparedRelations:
+        """Build bounded relation CTEs with optional deterministic union-key sampling."""
+
+        if sampling is None:
+            return RowDiffPreparedRelations(
+                cte_sql=f"__left AS ({left_sql}), __right AS ({right_sql})"
+            )
+        key_list: str = ", ".join(keys)
+        union_operator: str = self._render_row_diff_union_operator()
+        key_union_sql: str = (
+            f"SELECT {key_list} FROM ({left_sql}) AS __left_keys "
+            f"{union_operator} SELECT {key_list} FROM ({right_sql}) AS __right_keys"
+        )
+        population_count: int | None = None
+        if inspect_population:
+            population_row: tuple[Any, ...] = self.execute(
+                connection=connection,
+                sql=f"SELECT COUNT(*) FROM ({key_union_sql}) AS __key_population",
+            ).fetchone()
+            population_count = int(population_row[0])
+        sample_keys_sql: str = self._render_row_diff_sample_keys_sql(
+            key_union_sql=key_union_sql,
+            keys=keys,
+            sampling=sampling,
+        )
+        left_join: str = " AND ".join(f"__bounded_left.{key} = __sample_keys.{key}" for key in keys)
+        right_join: str = " AND ".join(
+            f"__bounded_right.{key} = __sample_keys.{key}" for key in keys
+        )
+        return RowDiffPreparedRelations(
+            cte_sql=(
+                f"__bounded_left AS ({left_sql}), __bounded_right AS ({right_sql}), "
+                f"__sample_keys AS ({sample_keys_sql}), "
+                f"__left AS (SELECT __bounded_left.* FROM __bounded_left "
+                f"INNER JOIN __sample_keys ON {left_join}), "
+                f"__right AS (SELECT __bounded_right.* FROM __bounded_right "
+                f"INNER JOIN __sample_keys ON {right_join})"
+            ),
+            population_count=population_count,
+        )
+
+    def _render_row_diff_sample_keys_sql(
+        self,
+        *,
+        key_union_sql: str,
+        keys: tuple[str, ...],
+        sampling: RowDiffSampling,
+    ) -> str:
+        """Render deterministic top-N union-key selection for LIMIT-capable engines."""
+
+        key_list: str = ", ".join(keys)
+        hash_expression: str = self._render_row_diff_key_hash(
+            keys=keys,
+            alias="__key_union",
+            seed=sampling.seed,
+        )
+        tie_break: str = ", ".join(f"__key_union.{key}" for key in keys)
+        return (
+            f"SELECT {key_list} FROM ({key_union_sql}) AS __key_union "
+            f"ORDER BY {hash_expression}, {tie_break} LIMIT {sampling.row_limit}"
+        )
+
+    def _render_row_diff_union_operator(self) -> str:
+        """Render the distinct union operator used for key population selection."""
+
+        return "UNION"
+
+    def _render_row_diff_key_hash(
+        self,
+        *,
+        keys: tuple[str, ...],
+        alias: str,
+        seed: int,
+    ) -> str:
+        """Render a stable hash over one canonical composite key representation."""
+
+        key_parts: list[str] = []
+        key: str
+        for key in keys:
+            value_sql: str = f"CAST({alias}.{key} AS VARCHAR)"
+            key_parts.append(f"CONCAT(LENGTH({value_sql}), ':', {value_sql})")
+        payload_parts: str = ", ".join((f"'{seed}'", *key_parts))
+        return f"MD5(CONCAT_WS('|', {payload_parts}))"
+
     def sample_unequal_rows(
         self,
         *,
@@ -1567,6 +1711,7 @@ class BaseAdapter(RetentionAdapterMixin, StrictAdapter):
         start_cursor: CursorValue | None = None,
         end_cursor: CursorValue | None = None,
         limit: int = 20,
+        sampling: RowDiffSampling | None = None,
     ) -> tuple[tuple[tuple[str, object], ...], ...]:
         raise AdapterUserError(
             message="sample_side_only_rows requires an engine-specific implementation"

{sqlbuild-0.94.6 → sqlbuild-0.96.0}/src/sqlbuild/adapter/contract/classes/diff.py

@@ -7,8 +7,10 @@ from typing import Any
 
 from sqlbuild.adapter.contract.models import (
     CursorValue,
+    RowDiffCoverage,
     RowDiffResult,
     RowDiffSampleRow,
+    RowDiffSampling,
     RowDiffTolerances,
     SchemaDiffResult,
 )
@@ -58,6 +60,19 @@ class DiffMixin(ABC):
         """Return the row count for a relation, optionally bounded by cursor."""
         ...
 
+    @abstractmethod
+    def inspect_row_diff_coverage(
+        self,
+        *,
+        connection: Any,
+        relation: str,
+        cursor_column: str | None = None,
+        start_cursor: CursorValue | None = None,
+        end_cursor: CursorValue | None = None,
+    ) -> RowDiffCoverage:
+        """Return exact bounded row count and cursor extent for one relation."""
+        ...
+
     @abstractmethod
     def sample_unequal_rows(
         self,
@@ -89,6 +104,7 @@ class DiffMixin(ABC):
         start_cursor: CursorValue | None = None,
         end_cursor: CursorValue | None = None,
         limit: int = 20,
+        sampling: RowDiffSampling | None = None,
     ) -> tuple[tuple[tuple[str, object], ...], ...]:
         """Return sampled side-only keys for verbose diff output."""
         ...

{sqlbuild-0.94.6 → sqlbuild-0.96.0}/src/sqlbuild/adapter/contract/classes/duckdb_backed_adapter.py

@@ -36,9 +36,12 @@ from sqlbuild.adapter.contract.models import (
     QueryResult,
     RelationInfo,
     RowDiffColumnResult,
+    RowDiffCoverage,
+    RowDiffPreparedRelations,
     RowDiffResult,
     RowDiffSampleCell,
     RowDiffSampleRow,
+    RowDiffSampling,
     RowDiffTolerance,
     RowDiffTolerances,
     SchemaDiffResult,
@@ -2005,6 +2008,23 @@ class DuckDbBackedAdapter(BaseAdapter):
         for stmt in statements:
             self.execute(connection=connection, sql=stmt)
 
+    def inspect_row_diff_coverage(
+        self,
+        *,
+        connection: Any,
+        relation: str,
+        cursor_column: str | None = None,
+        start_cursor: CursorValue | None = None,
+        end_cursor: CursorValue | None = None,
+    ) -> RowDiffCoverage:
+        return self._inspect_row_diff_coverage(
+            connection=connection,
+            relation=relation,
+            cursor_column=cursor_column,
+            start_cursor=start_cursor,
+            end_cursor=end_cursor,
+        )
+
     def diff_schema(
         self,
         *,
@@ -2051,6 +2071,8 @@ class DuckDbBackedAdapter(BaseAdapter):
             added_columns=tuple(added),
             removed_columns=tuple(removed),
             type_changed_columns=tuple(type_changed),
+            left_column_count=len(left_columns),
+            right_column_count=len(right_columns),
         )
 
     def diff_rows(
@@ -2069,6 +2091,7 @@ class DuckDbBackedAdapter(BaseAdapter):
         """Compare row-level data between two DuckDB relations."""
 
         keys: tuple[str, ...] = (unique_key,) if isinstance(unique_key, str) else unique_key
+        sampling: RowDiffSampling | None = tolerances.sampling if tolerances is not None else None
         left_columns: tuple[ColumnInfo, ...] = self.describe_relation(
             connection=connection, relation=left
         )
@@ -2100,6 +2123,14 @@ class DuckDbBackedAdapter(BaseAdapter):
             relation_label="right",
             keys=keys,
         )
+        prepared_relations: RowDiffPreparedRelations = self._build_row_diff_relation_ctes(
+            connection=connection,
+            left_sql=left_cte,
+            right_sql=right_cte,
+            keys=keys,
+            sampling=sampling,
+            inspect_population=True,
+        )
 
         join_condition: str = " AND ".join(f"__left.{k} = __right.{k}" for k in keys)
         column_equal_expressions: dict[str, str] = {
@@ -2133,7 +2164,7 @@ class DuckDbBackedAdapter(BaseAdapter):
             column_count_sql = ", " + ", ".join(column_count_sql_parts)
 
         diff_sql: str = (
-            f"WITH __left AS ({left_cte}), __right AS ({right_cte}) "
+            f"WITH {prepared_relations.cte_sql} "
             f"SELECT "
             f"COUNT(CASE WHEN __left.{keys[0]} IS NOT NULL THEN 1 END) AS left_count, "
             f"COUNT(CASE WHEN __right.{keys[0]} IS NOT NULL THEN 1 END) AS right_count, "
@@ -2167,6 +2198,9 @@ class DuckDbBackedAdapter(BaseAdapter):
             left_only_count=int(row[5]),
             right_only_count=int(row[6]),
             column_results=column_results,
+            population_count=prepared_relations.population_count or int(row[2]),
+            compared_count=int(row[2]),
+            sampling=sampling,
         )
 
     def count_rows(
@@ -2204,6 +2238,7 @@ class DuckDbBackedAdapter(BaseAdapter):
         limit: int = 20,
     ) -> tuple[RowDiffSampleRow, ...]:
         keys: tuple[str, ...] = (unique_key,) if isinstance(unique_key, str) else unique_key
+        sampling: RowDiffSampling | None = tolerances.sampling if tolerances is not None else None
         left_columns: tuple[ColumnInfo, ...] = self.describe_relation(
             connection=connection, relation=left
         )
@@ -2229,6 +2264,14 @@ class DuckDbBackedAdapter(BaseAdapter):
             relation_label="left",
             keys=keys,
         )
+        prepared_relations: RowDiffPreparedRelations = self._build_row_diff_relation_ctes(
+            connection=connection,
+            left_sql=left_cte,
+            right_sql=right_cte,
+            keys=keys,
+            sampling=sampling,
+            inspect_population=False,
+        )
         self.validate_row_diff_keys(
             connection=connection,
             relation_sql=right_cte,
@@ -2259,7 +2302,7 @@ class DuckDbBackedAdapter(BaseAdapter):
             compare_select_sql = ", " + compare_select_sql
         join_condition: str = " AND ".join(f"__left.{k} = __right.{k}" for k in keys)
         sample_sql: str = (
-            f"WITH __left AS ({left_cte}), __right AS ({right_cte}) "
+            f"WITH {prepared_relations.cte_sql} "
             f"SELECT {key_select_sql}{compare_select_sql} "
             f"FROM __left FULL OUTER JOIN __right ON {join_condition} "
             f"WHERE __left.{keys[0]} IS NOT NULL AND __right.{keys[0]} IS NOT NULL "
@@ -2309,6 +2352,7 @@ class DuckDbBackedAdapter(BaseAdapter):
         start_cursor: CursorValue | None = None,
         end_cursor: CursorValue | None = None,
         limit: int = 20,
+        sampling: RowDiffSampling | None = None,
     ) -> tuple[tuple[tuple[str, object], ...], ...]:
         keys: tuple[str, ...] = (unique_key,) if isinstance(unique_key, str) else unique_key
         cursor_filter: str = self.build_cursor_filter(
@@ -2327,6 +2371,14 @@ class DuckDbBackedAdapter(BaseAdapter):
             relation_label="left",
             keys=keys,
         )
+        prepared_relations: RowDiffPreparedRelations = self._build_row_diff_relation_ctes(
+            connection=connection,
+            left_sql=left_cte,
+            right_sql=right_cte,
+            keys=keys,
+            sampling=sampling,
+            inspect_population=False,
+        )
         self.validate_row_diff_keys(
             connection=connection,
             relation_sql=right_cte,
@@ -2344,7 +2396,7 @@ class DuckDbBackedAdapter(BaseAdapter):
         else:
             raise AdapterUserError(message="sample_side_only_rows side must be 'left' or 'right'")
         sample_sql: str = (
-            f"WITH __left AS ({left_cte}), __right AS ({right_cte}) "
+            f"WITH {prepared_relations.cte_sql} "
             f"SELECT {key_select_sql} "
             f"FROM __left FULL OUTER JOIN __right ON {join_condition} "
             f"WHERE {side_condition} "

{sqlbuild-0.94.6 → sqlbuild-0.96.0}/src/sqlbuild/adapter/contract/models.py

@@ -233,6 +233,8 @@ class SchemaDiffResult:
     added_columns: tuple[ColumnInfo, ...] = field(default_factory=tuple)
     removed_columns: tuple[ColumnInfo, ...] = field(default_factory=tuple)
     type_changed_columns: tuple[tuple[ColumnInfo, ColumnInfo], ...] = field(default_factory=tuple)
+    left_column_count: int = field(default=0, compare=False)
+    right_column_count: int = field(default=0, compare=False)
 
 
 @dataclass(frozen=True)
@@ -244,6 +246,31 @@ class RowDiffColumnResult:
     tolerance: RowDiffTolerance | None = None
 
 
+@dataclass(frozen=True)
+class RowDiffCoverage:
+    """Exact bounded relation coverage observed before row comparison."""
+
+    row_count: int = 0
+    minimum_cursor: object | None = None
+    maximum_cursor: object | None = None
+
+
+@dataclass(frozen=True)
+class RowDiffSampling:
+    """Deterministic key-sampling policy for a row comparison."""
+
+    row_limit: int
+    seed: int = 0
+
+
+@dataclass(frozen=True)
+class RowDiffPreparedRelations:
+    """Comparison CTEs and optional exact bounded union population."""
+
+    cte_sql: str
+    population_count: int | None = None
+
+
 @dataclass(frozen=True)
 class RowDiffResult:
     """Row-level comparison between two relations."""
@@ -256,6 +283,20 @@ class RowDiffResult:
     left_only_count: int = 0
     right_only_count: int = 0
     column_results: tuple[RowDiffColumnResult, ...] = field(default_factory=tuple)
+    population_count: int = field(default=0, compare=False)
+    compared_count: int = field(default=0, compare=False)
+    sampling: RowDiffSampling | None = field(default=None, compare=False)
+    left_coverage: RowDiffCoverage | None = field(default=None, compare=False)
+    right_coverage: RowDiffCoverage | None = field(default=None, compare=False)
+    cursor_column: str | None = field(default=None, compare=False)
+    cursor_start: object | None = field(default=None, compare=False)
+    cursor_end: object | None = field(default=None, compare=False)
+
+    @property
+    def is_exhaustive(self) -> bool:
+        """Return whether every bounded union key was compared."""
+
+        return self.sampling is None or self.compared_count >= self.population_count
 
 
 @dataclass(frozen=True)
@@ -289,6 +330,7 @@ class RowDiffTolerances:
 
     by_type: dict[str, RowDiffTolerance] = field(default_factory=dict)
     by_column: dict[str, RowDiffTolerance] = field(default_factory=dict)
+    sampling: RowDiffSampling | None = field(default=None, compare=False, repr=False)
 
 
 @dataclass(frozen=True)

{sqlbuild-0.94.6 → sqlbuild-0.96.0}/src/sqlbuild/adapters/bigquery/classes/bigquery_adapter.py

@@ -37,9 +37,12 @@ from sqlbuild.adapter.contract.models import (
     RetentionRequest,
     RetentionState,
     RowDiffColumnResult,
+    RowDiffCoverage,
+    RowDiffPreparedRelations,
     RowDiffResult,
     RowDiffSampleCell,
     RowDiffSampleRow,
+    RowDiffSampling,
     RowDiffTolerance,
     RowDiffTolerances,
     SchemaDiffResult,
@@ -732,6 +735,33 @@ class BigQueryAdapter(MicrobatchMixin, BaseAdapter):
                 message=f"row diff {relation_label} relation contains duplicate unique_key values"
             )
 
+    def _render_row_diff_key_hash(
+        self,
+        *,
+        keys: tuple[str, ...],
+        alias: str,
+        seed: int,
+    ) -> str:
+        """Render a stable BigQuery hash over a canonical composite key."""
+
+        components: list[str] = [f"'{seed}'"]
+        key: str
+        for key in keys:
+            value_sql: str = f"CAST({alias}.{key} AS STRING)"
+            components.append(f"CONCAT(CAST(LENGTH({value_sql}) AS STRING), ':', {value_sql})")
+        separated: list[str] = []
+        component: str
+        for component in components:
+            if separated:
+                separated.append("'|'")
+            separated.append(component)
+        return f"TO_HEX(MD5(CONCAT({', '.join(separated)})))"
+
+    def _render_row_diff_union_operator(self) -> str:
+        """Render BigQuery's explicit distinct union operator."""
+
+        return "UNION DISTINCT"
+
     def resolve_row_diff_tolerance(
         self,
         *,
@@ -2332,6 +2362,23 @@ class BigQueryAdapter(MicrobatchMixin, BaseAdapter):
     def format_row_diff_decimal_sql(self, value: Decimal) -> str:
         return format(value, "f")
 
+    def inspect_row_diff_coverage(
+        self,
+        *,
+        connection: Any,
+        relation: str,
+        cursor_column: str | None = None,
+        start_cursor: CursorValue | None = None,
+        end_cursor: CursorValue | None = None,
+    ) -> RowDiffCoverage:
+        return self._inspect_row_diff_coverage(
+            connection=connection,
+            relation=relation,
+            cursor_column=cursor_column,
+            start_cursor=start_cursor,
+            end_cursor=end_cursor,
+        )
+
     def diff_schema(
         self,
         *,
@@ -2374,6 +2421,8 @@ class BigQueryAdapter(MicrobatchMixin, BaseAdapter):
             added_columns=tuple(added),
             removed_columns=tuple(removed),
             type_changed_columns=tuple(type_changed),
+            left_column_count=len(left_columns),
+            right_column_count=len(right_columns),
         )
 
     def diff_rows(
@@ -2390,6 +2439,7 @@ class BigQueryAdapter(MicrobatchMixin, BaseAdapter):
         end_cursor: CursorValue | None = None,
     ) -> RowDiffResult:
         keys: tuple[str, ...] = (unique_key,) if isinstance(unique_key, str) else unique_key
+        sampling: RowDiffSampling | None = tolerances.sampling if tolerances is not None else None
         left_columns: tuple[ColumnInfo, ...] = self.describe_relation(
             connection=connection, relation=left
         )
@@ -2421,6 +2471,14 @@ class BigQueryAdapter(MicrobatchMixin, BaseAdapter):
             relation_label="right",
             keys=keys,
         )
+        prepared_relations: RowDiffPreparedRelations = self._build_row_diff_relation_ctes(
+            connection=connection,
+            left_sql=left_cte,
+            right_sql=right_cte,
+            keys=keys,
+            sampling=sampling,
+            inspect_population=True,
+        )
         join_condition: str = " AND ".join(f"__left.{key} = __right.{key}" for key in keys)
         column_equal_expressions: dict[str, str] = {
             col: self.build_row_diff_equal_expression(
@@ -2451,7 +2509,7 @@ class BigQueryAdapter(MicrobatchMixin, BaseAdapter):
         if column_count_sql_parts:
             column_count_sql = ", " + ", ".join(column_count_sql_parts)
         diff_sql: str = (
-            f"WITH __left AS ({left_cte}), __right AS ({right_cte}) "
+            f"WITH {prepared_relations.cte_sql} "
             f"SELECT "
             f"COUNT(CASE WHEN __left.{keys[0]} IS NOT NULL THEN 1 END) AS left_count, "
             f"COUNT(CASE WHEN __right.{keys[0]} IS NOT NULL THEN 1 END) AS right_count, "
@@ -2485,6 +2543,9 @@ class BigQueryAdapter(MicrobatchMixin, BaseAdapter):
             left_only_count=self._to_int(row[5]),
             right_only_count=self._to_int(row[6]),
             column_results=column_results,
+            population_count=prepared_relations.population_count or self._to_int(row[2]),
+            compared_count=self._to_int(row[2]),
+            sampling=sampling,
         )
 
     def count_rows(
@@ -2523,6 +2584,7 @@ class BigQueryAdapter(MicrobatchMixin, BaseAdapter):
         end_cursor: CursorValue | None = None,
         limit: int = 20,
     ) -> tuple[RowDiffSampleRow, ...]:
+        sampling: RowDiffSampling | None = tolerances.sampling if tolerances is not None else None
         keys: tuple[str, ...] = (unique_key,) if isinstance(unique_key, str) else unique_key
         left_columns: tuple[ColumnInfo, ...] = self.describe_relation(
             connection=connection, relation=left
@@ -2555,6 +2617,14 @@ class BigQueryAdapter(MicrobatchMixin, BaseAdapter):
             relation_label="right",
             keys=keys,
         )
+        prepared_relations: RowDiffPreparedRelations = self._build_row_diff_relation_ctes(
+            connection=connection,
+            left_sql=left_cte,
+            right_sql=right_cte,
+            keys=keys,
+            sampling=sampling,
+            inspect_population=False,
+        )
         column_equal_expressions: dict[str, str] = {
             col: self.build_row_diff_equal_expression(
                 column=col,
@@ -2579,7 +2649,7 @@ class BigQueryAdapter(MicrobatchMixin, BaseAdapter):
             compare_select_sql = ", " + compare_select_sql
         join_condition: str = " AND ".join(f"__left.{key} = __right.{key}" for key in keys)
         sample_sql: str = (
-            f"WITH __left AS ({left_cte}), __right AS ({right_cte}) "
+            f"WITH {prepared_relations.cte_sql} "
             f"SELECT {key_select_sql}{compare_select_sql} "
             f"FROM __left FULL OUTER JOIN __right ON {join_condition} "
             f"WHERE __left.{keys[0]} IS NOT NULL AND __right.{keys[0]} IS NOT NULL "
@@ -2626,6 +2696,7 @@ class BigQueryAdapter(MicrobatchMixin, BaseAdapter):
         start_cursor: CursorValue | None = None,
         end_cursor: CursorValue | None = None,
         limit: int = 20,
+        sampling: RowDiffSampling | None = None,
     ) -> tuple[tuple[tuple[str, object], ...], ...]:
         keys: tuple[str, ...] = (unique_key,) if isinstance(unique_key, str) else unique_key
         cursor_filter: str = self.build_cursor_filter(
@@ -2650,6 +2721,14 @@ class BigQueryAdapter(MicrobatchMixin, BaseAdapter):
             relation_label="right",
             keys=keys,
         )
+        prepared_relations: RowDiffPreparedRelations = self._build_row_diff_relation_ctes(
+            connection=connection,
+            left_sql=left_cte,
+            right_sql=right_cte,
+            keys=keys,
+            sampling=sampling,
+            inspect_population=False,
+        )
         join_condition: str = " AND ".join(f"__left.{key} = __right.{key}" for key in keys)
         key_select_sql: str = ", ".join(
             f"COALESCE(__left.{key}, __right.{key}) AS __key_{key}" for key in keys
@@ -2661,7 +2740,7 @@ class BigQueryAdapter(MicrobatchMixin, BaseAdapter):
         else:
             raise AdapterUserError(message="sample_side_only_rows side must be 'left' or 'right'")
         sample_sql: str = (
-            f"WITH __left AS ({left_cte}), __right AS ({right_cte}) "
+            f"WITH {prepared_relations.cte_sql} "
             f"SELECT {key_select_sql} "
             f"FROM __left FULL OUTER JOIN __right ON {join_condition} "
             f"WHERE {side_condition} "