Ensure MatchRateCheck only requires the check column from the left table

Author: Benjamin Gutzmann

CHANGELOG.md

@@ -27,6 +27,7 @@ Types of changes:
 ### Fixed
 
 - Quote table identifiers in bulk SELECTs when loading data into DuckDB memory to avoid BigQuery binder errors for identifiers that look like project IDs (e.g., `EC0601`). Added an integration test covering the quoting behavior.
+- Ensure MatchRateCheck only requires the check column from the left table; the right table now only contributes join and filter columns to avoid unnecessary column selection and errors.
 
 ## [0.9.0] - 2026-01-16
 

docs/checks/matchrate.md

@@ -0,0 +1,33 @@
+# MatchRateCheck — check_column placement
+
+Guidance:
+
+- The `check_column` for `MatchRateCheck` must be a column present in the left-hand table only.
+- The right-hand table is only expected to provide join columns and filter columns; it must not be required to contain `check_column`.
+
+Configuration example:
+
+```yaml
+- defaults:
+    check_type: MatchRateCheck
+    check_column: product_number                   # must exist on the left table
+    join_columns_left:
+      - BQ_PARTITIONTIME
+      - shopId
+      - product_number
+    join_columns_right:
+      - BQ_PARTITIONTIME
+      - value.shopId
+      - product_number
+  checks:
+    - left_table: project.dataset.left_table
+      right_table: project.dataset.right_table
+      filters:
+        shop_id:
+          value: SHOP01
+```
+
+Notes:
+
+- The executor only requests the `check_column` from the left table during bulk loading; the right table will only be queried for its join and filter columns.
+- This avoids errors when the right table does not contain the `check_column` or when its identifier resembles a BigQuery project ID.

src/koality/executor.py

@@ -215,6 +215,33 @@ def get_data_requirements(self) -> defaultdict[str, defaultdict[str, set]]:  # n
         """
         data_requirements = defaultdict(lambda: defaultdict(set))
         for check in self.checks:
+            # Skip synthetic JOIN table entries created for MatchRateCheck; handle left/right tables explicitly
+            if isinstance(check, MatchRateCheck):
+                # Add columns and filter columns for left table
+                if check.check_column and check.check_column != "*":
+                    data_requirements[check.left_table]["columns"].add(check.check_column)
+                for _filter in check.filters_left.values():
+                    if "column" in _filter:
+                        data_requirements[check.left_table]["columns"].add(_filter["column"])
+                data_requirements[check.left_table]["columns"].update(check.join_columns_left)
+
+                # Add only filter and join columns for right table (check_column is only from left table)
+                for _filter in check.filters_right.values():
+                    if "column" in _filter:
+                        data_requirements[check.right_table]["columns"].add(_filter["column"])
+                data_requirements[check.right_table]["columns"].update(check.join_columns_right)
+
+                # Store unique filter configurations for both tables
+                filter_key_left = frozenset(
+                    (name, frozenset(config.items())) for name, config in check.filters_left.items()
+                )
+                filter_key_right = frozenset(
+                    (name, frozenset(config.items())) for name, config in check.filters_right.items()
+                )
+                data_requirements[check.left_table]["filters"].add(filter_key_left)
+                data_requirements[check.right_table]["filters"].add(filter_key_right)
+                continue
+
             table_name = check.table
             check_filters = check.filters
             # Add check-specific columns and filter columns to the requirements
@@ -224,16 +251,12 @@ def get_data_requirements(self) -> defaultdict[str, defaultdict[str, set]]:  # n
                 if "column" in _filter:
                     data_requirements[table_name]["columns"].add(_filter["column"])
 
-            # For MatchRateCheck, add columns from both left and right tables
-            if isinstance(check, MatchRateCheck):
-                data_requirements[check.left_table]["columns"].update(check.join_columns_left)
-                data_requirements[check.right_table]["columns"].update(check.join_columns_right)
-                for _filter in check.filters_left.values():
-                    if "column" in _filter:
-                        data_requirements[check.left_table]["columns"].add(_filter["column"])
-                for _filter in check.filters_right.values():
-                    if "column" in _filter:
-                        data_requirements[check.right_table]["columns"].add(_filter["column"])
+            if isinstance(check, IqrOutlierCheck):
+                check_filters = {k: v for k, v in check.filters.items() if v.get("type") != "date"}
+
+            # Store unique filter configurations for each table
+            filter_key = frozenset((name, frozenset(config.items())) for name, config in check_filters.items())
+            data_requirements[table_name]["filters"].add(filter_key)
 
             if isinstance(check, IqrOutlierCheck):
                 check_filters = {k: v for k, v in check.filters.items() if v.get("type") != "date"}
@@ -271,10 +294,16 @@ def fetch_data_into_memory(self, data_requirements: defaultdict[str, defaultdict
             if all_filters_sql:
                 final_where_clause = "WHERE " + " OR ".join(all_filters_sql)
 
+            # Determine appropriate table quoting depending on database provider
+            if self.database_provider and getattr(self.database_provider, "type", "").lower() == "bigquery":
+                table_ref = f"`{table}`"
+            else:
+                table_ref = f'"{table}"'
+
             # Construct the bulk SELECT query
             select_query = f"""
             SELECT {columns}
-            FROM "{table}"
+            FROM {table_ref}
             {final_where_clause}
             """  # noqa: S608
 

tests/integration/test_executor_table_quoting.py

@@ -58,4 +58,5 @@ def fake_execute_query(
     executor.fetch_data_into_memory(data_requirements)
 
     assert captured["query"] is not None
-    assert f'FROM "{table_name}"' in captured["query"]
+    # Expect backticks for BigQuery provider
+    assert f"FROM `{table_name}`" in captured["query"]