fix(test-execution): render empty baseline/tolerance params as NULL

CAT measures substitute baseline params (counts, averages, standard
deviations) and tolerances directly into SQL. When a test definition has
an empty value, the substitution produced invalid SQL such as
CAST( AS FLOAT) — erroring the test and poisoning the aggregated CAT
batch (forcing a slow single rerun).

Add a shared null_if_empty() helper and apply it to the numeric baseline
params and tolerances in both the execution query builder and the source
data lookup service. BASELINE_VALUE (used as a quoted literal, a number,
or an IN-list) and Freshness_Trend's BASELINE_SUM (a quoted timestamp the
template handles via NULLIF) are left as-is, since "NULL" is not valid
SQL in those contexts.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: aarthy-dk

testgen/commands/queries/execute_tests_query.py

@@ -7,7 +7,7 @@
 import pandas as pd
 
 from testgen.common import read_template_sql_file
-from testgen.common.clean_sql import concat_columns
+from testgen.common.clean_sql import concat_columns, null_if_empty
 from testgen.common.database.database_service import (
     fetch_dict_from_db,
     get_flavor_service,
@@ -348,16 +348,27 @@ def _get_params(self, test_def: TestExecutionDef | None = None) -> dict:
                 "CONCAT_COLUMNS": concat_columns(test_def.column_name, self.null_value) if test_def.column_name else "",
                 "SKIP_ERRORS": test_def.skip_errors or 0,
                 "CUSTOM_QUERY": test_def.custom_query,
-                "BASELINE_CT": test_def.baseline_ct,
-                "BASELINE_UNIQUE_CT": test_def.baseline_unique_ct,
+                # Numeric baseline params feed division/arithmetic in CAT measures.
+                # Render empty values as NULL so the measure evaluates to NULL instead of producing
+                # invalid SQL like CAST( AS FLOAT). Cannot default to 0 — several are denominators.
+                "BASELINE_CT": null_if_empty(test_def.baseline_ct),
+                "BASELINE_UNIQUE_CT": null_if_empty(test_def.baseline_unique_ct),
+                # BASELINE_VALUE is a quoted literal, an unquoted number, or an IN-list depending on
+                # test type — no single empty-substitution is valid SQL, so it is templated as-is.
                 "BASELINE_VALUE": test_def.baseline_value,
-                "BASELINE_VALUE_CT": test_def.baseline_value_ct,
+                "BASELINE_VALUE_CT": null_if_empty(test_def.baseline_value_ct),
                 "THRESHOLD_VALUE": test_def.threshold_value or 0,
-                "BASELINE_SUM": test_def.baseline_sum,
-                "BASELINE_AVG": test_def.baseline_avg,
-                "BASELINE_SD": test_def.baseline_sd,
-                "LOWER_TOLERANCE": "NULL" if test_def.lower_tolerance in (None, "") else test_def.lower_tolerance,
-                "UPPER_TOLERANCE": "NULL" if test_def.upper_tolerance in (None, "") else test_def.upper_tolerance,
+                # Freshness_Trend uses BASELINE_SUM as a quoted timestamp (the template's
+                # NULLIF('{...}', '') handles empty); Other tests use it as a numeric sum.
+                "BASELINE_SUM": (
+                    test_def.baseline_sum
+                    if test_def.test_type == "Freshness_Trend"
+                    else null_if_empty(test_def.baseline_sum)
+                ),
+                "BASELINE_AVG": null_if_empty(test_def.baseline_avg),
+                "BASELINE_SD": null_if_empty(test_def.baseline_sd),
+                "LOWER_TOLERANCE": null_if_empty(test_def.lower_tolerance),
+                "UPPER_TOLERANCE": null_if_empty(test_def.upper_tolerance),
                 # SUBSET_CONDITION should be replaced after CUSTOM_QUERY
                 # since the latter may contain the former
                 "SUBSET_CONDITION": test_def.subset_condition or "1=1",

testgen/common/clean_sql.py

@@ -50,6 +50,19 @@ def quote_identifiers(identifiers: str, flavor: str) -> str:
     return ", ".join(quoted_values)
 
 
+def null_if_empty(value: object) -> object:
+    """Return the literal ``"NULL"`` when ``value`` is empty (``None`` or ``""``), else ``value``.
+
+    For numeric test parameters substituted into SQL templates (baseline counts,
+    averages, standard deviations, tolerances). An empty substitution produces invalid SQL
+    such as ``CAST( AS FLOAT)``; ``"NULL"`` makes the surrounding expression evaluate to NULL
+    instead. A real ``0`` is preserved (``0 in (None, "")`` is ``False``). Not suitable for
+    params used as quoted literals or IN-lists (e.g. ``BASELINE_VALUE``, ``BASELINE_SUM`` for
+    Freshness_Trend), where ``"NULL"`` would not be valid SQL.
+    """
+    return "NULL" if value in (None, "") else value
+
+
 def concat_columns(columns: str, null_value: str):
     # Prepares SQL expression to concatenate comma-separated column list
     expression = ""

testgen/common/source_data_service.py

@@ -11,7 +11,7 @@
 import pandas as pd
 from sqlalchemy import text
 
-from testgen.common.clean_sql import concat_columns
+from testgen.common.clean_sql import concat_columns, null_if_empty
 from testgen.common.database.database_service import get_flavor_service, replace_params
 from testgen.common.date_service import parse_fuzzy_date
 from testgen.common.models import get_current_session
@@ -207,12 +207,14 @@ def _build_query_standard(issue_data: dict, limit: int) -> str | None:
         if (parsed_test_date := parse_fuzzy_date(issue_data["test_date"]))
         else None,
         "CUSTOM_QUERY": test_definition.custom_query,
+        # BASELINE_VALUE varies (quoted literal / number / IN-list) by test type — templated as-is.
+        # The numeric baselines render empty as NULL to avoid invalid SQL like CAST( AS FLOAT).
         "BASELINE_VALUE": test_definition.baseline_value,
-        "BASELINE_CT": test_definition.baseline_ct,
-        "BASELINE_AVG": test_definition.baseline_avg,
-        "BASELINE_SD": test_definition.baseline_sd,
-        "LOWER_TOLERANCE": "NULL" if test_definition.lower_tolerance in (None, "") else test_definition.lower_tolerance,
-        "UPPER_TOLERANCE": "NULL" if test_definition.upper_tolerance in (None, "") else test_definition.upper_tolerance,
+        "BASELINE_CT": null_if_empty(test_definition.baseline_ct),
+        "BASELINE_AVG": null_if_empty(test_definition.baseline_avg),
+        "BASELINE_SD": null_if_empty(test_definition.baseline_sd),
+        "LOWER_TOLERANCE": null_if_empty(test_definition.lower_tolerance),
+        "UPPER_TOLERANCE": null_if_empty(test_definition.upper_tolerance),
         "THRESHOLD_VALUE": test_definition.threshold_value or 0,
         # SUBSET_CONDITION should be replaced after CUSTOM_QUERY
         # since the latter may contain the former

tests/unit/commands/queries/test_execute_tests_query.py

@@ -1,5 +1,5 @@
 from datetime import UTC, datetime
-from unittest.mock import patch
+from unittest.mock import MagicMock, patch
 from uuid import uuid4
 
 import pytest
@@ -495,3 +495,85 @@ def test_aggregate_cat_tests_handles_null_max_query_chars():
     assert grouped_defs == [[td]]
 
 
+# --- TestExecutionSQL._get_params baseline guards ---
+
+
+def _make_params_execution_sql() -> TestExecutionSQL:
+    """Build a minimal TestExecutionSQL for exercising _get_params without a database."""
+    instance = TestExecutionSQL.__new__(TestExecutionSQL)
+    flavor_service = MagicMock()
+    flavor_service.quote_character = '"'
+    flavor_service.varchar_type = "VARCHAR"
+    instance.flavor_service = flavor_service
+    instance.flavor = "postgresql"
+    instance.table_group = MagicMock(id=uuid4())
+    instance.test_run = MagicMock(test_suite_id=uuid4(), id=uuid4())
+    instance.run_date = datetime(2026, 1, 1, tzinfo=UTC)
+    return instance
+
+
+def test_get_params_empty_baseline_counts_become_null():
+    """Empty baseline counts must render as NULL, not "", to avoid CAST( AS FLOAT) syntax errors."""
+    instance = _make_params_execution_sql()
+    params = instance._get_params(_make_td(test_type="Missing_Pct", baseline_ct="", baseline_value_ct=""))
+    assert params["BASELINE_CT"] == "NULL"
+    assert params["BASELINE_VALUE_CT"] == "NULL"
+
+
+def test_get_params_none_baseline_counts_become_null():
+    instance = _make_params_execution_sql()
+    params = instance._get_params(_make_td(test_type="Missing_Pct", baseline_ct=None, baseline_value_ct=None))
+    assert params["BASELINE_CT"] == "NULL"
+    assert params["BASELINE_VALUE_CT"] == "NULL"
+
+
+def test_get_params_populated_baseline_counts_pass_through():
+    instance = _make_params_execution_sql()
+    params = instance._get_params(_make_td(test_type="Missing_Pct", baseline_ct="1000", baseline_value_ct="950"))
+    assert params["BASELINE_CT"] == "1000"
+    assert params["BASELINE_VALUE_CT"] == "950"
+
+
+def test_get_params_zero_baseline_count_is_not_nulled():
+    """A real 0 is a meaningful value and must not be coerced to NULL."""
+    instance = _make_params_execution_sql()
+    params = instance._get_params(_make_td(test_type="Row_Ct_Pct", baseline_ct=0))
+    assert params["BASELINE_CT"] == 0
+
+
+def test_get_params_empty_numeric_baselines_become_null():
+    """All numeric baseline params render NULL when empty."""
+    instance = _make_params_execution_sql()
+    params = instance._get_params(_make_td(
+        test_type="Avg_Shift",
+        baseline_unique_ct="", baseline_avg="", baseline_sd="", baseline_sum="",
+    ))
+    assert params["BASELINE_UNIQUE_CT"] == "NULL"
+    assert params["BASELINE_AVG"] == "NULL"
+    assert params["BASELINE_SD"] == "NULL"
+    # Non-Freshness test types null-guard BASELINE_SUM (numeric use in Incr_Avg_Shift)
+    assert params["BASELINE_SUM"] == "NULL"
+
+
+def test_get_params_freshness_baseline_sum_kept_raw_when_empty():
+    """Freshness_Trend quotes BASELINE_SUM (NULLIF('', '') in template) — must stay empty, not 'NULL'."""
+    instance = _make_params_execution_sql()
+    params = instance._get_params(_make_td(test_type="Freshness_Trend", baseline_sum=""))
+    assert params["BASELINE_SUM"] == ""
+
+
+def test_get_params_baseline_value_left_unguarded():
+    """BASELINE_VALUE has non-uniform usage (quoted/number/IN-list) — not coerced to NULL."""
+    instance = _make_params_execution_sql()
+    params = instance._get_params(_make_td(test_type="Constant", baseline_value=""))
+    assert params["BASELINE_VALUE"] == ""
+
+
+def test_get_params_empty_tolerances_become_null():
+    """Tolerances use the same NULL guard."""
+    instance = _make_params_execution_sql()
+    params = instance._get_params(_make_td(test_type="Volume_Trend", lower_tolerance="", upper_tolerance=""))
+    assert params["LOWER_TOLERANCE"] == "NULL"
+    assert params["UPPER_TOLERANCE"] == "NULL"
+
+