| """Declarative check runners for dbt-core and soda-core pilots.
|
|
|
| These runners are intentionally lightweight:
|
| - They always compute violating product IDs from DuckDB SQL conditions
|
| (deterministic parity baseline).
|
| - They optionally execute dbt/soda commands to prove declarative integration.
|
| """
|
| from __future__ import annotations
|
|
|
| import os
|
| import re
|
| import shutil
|
| import subprocess
|
| from pathlib import Path
|
| from typing import Dict, List, Mapping, Sequence
|
|
|
| import duckdb
|
|
|
| from duckdb_utils.create_tables import TABLE_NAME
|
|
|
| PROJECT_ROOT = Path(__file__).resolve().parent.parent
|
| RUNTIME_DIR = PROJECT_ROOT / "results" / "declarative_runtime"
|
| OUTPUT_TAIL_CHARS = 4000
|
|
|
|
|
| def _sql_for_rule(rule: Mapping[str, object]) -> str:
|
| condition = str(rule["duckdb_condition"])
|
| return f"SELECT product_id FROM {TABLE_NAME} WHERE {condition}"
|
|
|
|
|
| def _query_rule_product_ids(rule: Mapping[str, object], db_path: Path) -> List[str]:
|
| query = _sql_for_rule(rule)
|
| with duckdb.connect(db_path.as_posix()) as con:
|
| rows = con.execute(query).fetchall()
|
| return sorted(str(row[0]) for row in rows)
|
|
|
|
|
| def _build_per_product_tags(
|
| rules: Sequence[Mapping[str, object]],
|
| per_rule_ids: Dict[str, List[str]],
|
| products: Sequence[Mapping[str, object]],
|
| ) -> Dict[str, List[str]]:
|
| per_product_tags: Dict[str, List[str]] = {str(product.get("product_id")): [] for product in products}
|
| for rule in rules:
|
| rule_name = str(rule["rule_name"])
|
| tag = str(rule["tag"])
|
| for product_id in per_rule_ids[rule_name]:
|
| if product_id in per_product_tags:
|
| per_product_tags[product_id].append(tag)
|
| return per_product_tags
|
|
|
|
|
| def _run_command(command: List[str], cwd: Path, env: Mapping[str, str] | None = None) -> Dict[str, object]:
|
| try:
|
| full_env = os.environ.copy()
|
| if env:
|
| full_env.update(env)
|
| completed = subprocess.run(
|
| command,
|
| cwd=cwd,
|
| env=full_env,
|
| capture_output=True,
|
| text=True,
|
| encoding="utf-8",
|
| errors="replace",
|
| check=False,
|
| timeout=180,
|
| )
|
| stdout = completed.stdout or ""
|
| stderr = completed.stderr or ""
|
| return {
|
| "command": " ".join(command),
|
| "executed": True,
|
| "success": completed.returncode == 0,
|
| "return_code": completed.returncode,
|
| "stdout_tail": stdout[-OUTPUT_TAIL_CHARS:],
|
| "stderr_tail": stderr[-OUTPUT_TAIL_CHARS:],
|
| }
|
| except FileNotFoundError:
|
| return {
|
| "command": " ".join(command),
|
| "executed": False,
|
| "success": False,
|
| "return_code": None,
|
| "stdout_tail": "",
|
| "stderr_tail": f"Command not found: {command[0]}",
|
| }
|
| except subprocess.TimeoutExpired as exc:
|
| return {
|
| "command": " ".join(command),
|
| "executed": True,
|
| "success": False,
|
| "return_code": None,
|
| "stdout_tail": (exc.stdout or "")[-OUTPUT_TAIL_CHARS:] if exc.stdout else "",
|
| "stderr_tail": (exc.stderr or "")[-OUTPUT_TAIL_CHARS:] if exc.stderr else "Command timed out.",
|
| }
|
|
|
|
|
| def _soda_cloud_credentials() -> Dict[str, str] | None:
|
| api_key_id = os.getenv("SODA_CLOUD_API_KEY_ID", "").strip()
|
| api_key_secret = os.getenv("SODA_CLOUD_API_KEY_SECRET", "").strip()
|
| host = os.getenv("SODA_CLOUD_HOST", "").strip()
|
| if not (api_key_id and api_key_secret and host):
|
| return None
|
| return {
|
| "api_key_id": api_key_id,
|
| "api_key_secret": api_key_secret,
|
| "host": host,
|
| }
|
|
|
|
|
| def _extract_cloud_scan_metadata(stdout_tail: str, stderr_tail: str) -> Dict[str, str]:
|
| text = f"{stdout_tail}\n{stderr_tail}"
|
| scan_id = ""
|
| scan_url = ""
|
|
|
| scan_match = re.search(r"(?:scan[\s_-]?id)\s*[:=]\s*([a-zA-Z0-9\-]+)", text, flags=re.IGNORECASE)
|
| if scan_match:
|
| scan_id = scan_match.group(1).strip()
|
|
|
| url_match = re.search(r"(https?://[^\s]+)", text)
|
| if url_match:
|
| scan_url = url_match.group(1).strip().rstrip(".,)")
|
|
|
| return {
|
| "scan_id": scan_id,
|
| "scan_url": scan_url,
|
| }
|
|
|
|
|
| def _write_soda_data_source_config(config_path: Path, data_source_name: str, runtime_db_path: Path) -> None:
|
| config_path.write_text(
|
| "\n".join(
|
| [
|
| "type: duckdb",
|
| f"name: {data_source_name}",
|
| "connection:",
|
| f" database: {runtime_db_path.as_posix()}",
|
| " schema: main",
|
| ]
|
| )
|
| + "\n",
|
| encoding="utf-8",
|
| )
|
|
|
|
|
| def _resolve_soda_cloud_config(target_path: Path) -> tuple[Path | None, str]:
|
| explicit_path = os.getenv("SODA_CLOUD_CONFIG_PATH", "").strip()
|
| candidate_paths = []
|
| if explicit_path:
|
| candidate_paths.append(Path(explicit_path).expanduser())
|
| candidate_paths.append(PROJECT_ROOT / "sc_config.yml")
|
|
|
| for candidate in candidate_paths:
|
| if candidate.is_file():
|
| shutil.copyfile(candidate, target_path)
|
| return target_path, str(candidate)
|
|
|
| credentials = _soda_cloud_credentials()
|
| if credentials is None:
|
| return None, ""
|
|
|
| target_path.write_text(
|
| "\n".join(
|
| [
|
| "soda_cloud:",
|
| f" host: {credentials['host']}",
|
| f" api_key_id: {credentials['api_key_id']}",
|
| f" api_key_secret: {credentials['api_key_secret']}",
|
| ]
|
| )
|
| + "\n",
|
| encoding="utf-8",
|
| )
|
| return target_path, "env"
|
|
|
|
|
| def _prepare_dbt_project(rules: Sequence[Mapping[str, object]], db_path: Path, root_dir: Path) -> Dict[str, object]:
|
| project_dir = root_dir / "dbt_project"
|
| tests_dir = project_dir / "tests"
|
| models_dir = project_dir / "models"
|
| macros_dir = project_dir / "macros"
|
| runtime_db_path = root_dir / "dbt_runtime.db"
|
| tests_dir.mkdir(parents=True, exist_ok=True)
|
| models_dir.mkdir(parents=True, exist_ok=True)
|
| macros_dir.mkdir(parents=True, exist_ok=True)
|
| shutil.copyfile(db_path, runtime_db_path)
|
|
|
| (project_dir / "dbt_project.yml").write_text(
|
| "\n".join(
|
| [
|
| "name: off_quality_declarative",
|
| "version: '1.0'",
|
| "config-version: 2",
|
| "profile: off_quality_duckdb",
|
| "model-paths: ['models']",
|
| "test-paths: ['tests']",
|
| ]
|
| )
|
| + "\n",
|
| encoding="utf-8",
|
| )
|
|
|
| (project_dir / "profiles.yml").write_text(
|
| "\n".join(
|
| [
|
| "off_quality_duckdb:",
|
| " target: dev",
|
| " outputs:",
|
| " dev:",
|
| " type: duckdb",
|
| f" path: '{runtime_db_path.as_posix()}'",
|
| " schema: main",
|
| " threads: 1",
|
| ]
|
| )
|
| + "\n",
|
| encoding="utf-8",
|
| )
|
|
|
| (models_dir / "sources.yml").write_text(
|
| "\n".join(
|
| [
|
| "version: 2",
|
| "sources:",
|
| " - name: off_source",
|
| " schema: main",
|
| " tables:",
|
| " - name: nutrition_table",
|
| ]
|
| )
|
| + "\n",
|
| encoding="utf-8",
|
| )
|
|
|
| test_sql_by_rule: Dict[str, str] = {}
|
| for rule in rules:
|
| rule_name = str(rule["rule_name"])
|
| condition = str(rule["duckdb_condition"])
|
| sql = (
|
| "SELECT product_id\n"
|
| "FROM {{ source('off_source', 'nutrition_table') }}\n"
|
| f"WHERE {condition}"
|
| )
|
| test_sql_by_rule[rule_name] = sql
|
| (tests_dir / f"{rule_name}.sql").write_text(sql + "\n", encoding="utf-8")
|
|
|
|
|
|
|
| (macros_dir / "count_violations.sql").write_text(
|
| "\n".join(
|
| [
|
| "{% macro count_violations(condition_sql) %}",
|
| " {% set q %}",
|
| " select count(*) as violation_count",
|
| " from {{ source('off_source', 'nutrition_table') }}",
|
| " where {{ condition_sql }}",
|
| " {% endset %}",
|
| " {% set t = run_query(q) %}",
|
| " {% if execute %}",
|
| " {% set c = t.columns[0].values()[0] %}",
|
| " {% do log('VIOLATION_COUNT=' ~ c, info=True) %}",
|
| " {% endif %}",
|
| "{% endmacro %}",
|
| ]
|
| )
|
| + "\n",
|
| encoding="utf-8",
|
| )
|
|
|
| dbt_cmd = shutil.which("dbt")
|
| if not dbt_cmd:
|
| return {
|
| "run": {
|
| "command": "dbt test --project-dir ... --profiles-dir ...",
|
| "executed": False,
|
| "success": False,
|
| "return_code": None,
|
| "stdout_tail": "",
|
| "stderr_tail": "dbt CLI not found. Install dbt-duckdb.",
|
| },
|
| "test_sql_by_rule": test_sql_by_rule,
|
| }
|
|
|
| debug_info = _run_command(
|
| [dbt_cmd, "debug", "--project-dir", str(project_dir), "--profiles-dir", str(project_dir)],
|
| cwd=project_dir,
|
| )
|
| per_rule_runs: Dict[str, Dict[str, object]] = {}
|
| for rule in rules:
|
| rule_name = str(rule["rule_name"])
|
| condition = str(rule["duckdb_condition"])
|
| args_yaml = f"{{condition_sql: {condition!r}}}"
|
| per_rule_runs[rule_name] = _run_command(
|
| [
|
| dbt_cmd,
|
| "run-operation",
|
| "count_violations",
|
| "--project-dir",
|
| str(project_dir),
|
| "--profiles-dir",
|
| str(project_dir),
|
| "--args",
|
| args_yaml,
|
| ],
|
| cwd=project_dir,
|
| )
|
|
|
| all_executed = bool(debug_info.get("executed")) and all(bool(run.get("executed")) for run in per_rule_runs.values())
|
| all_success_codes = (
|
| debug_info.get("return_code") == 0 and all(run.get("return_code") == 0 for run in per_rule_runs.values())
|
| )
|
| failing_rules = [rule_name for rule_name, run in per_rule_runs.items() if run.get("return_code") != 0]
|
| summary_stdout, summary_stderr = _summarize_soda_runs(per_rule_runs)
|
|
|
| run_info = {
|
| "command": (
|
| f"dbt debug + dbt run-operation count_violations "
|
| f"(per-rule x{len(per_rule_runs)}) --project-dir {project_dir} --profiles-dir {project_dir}"
|
| ),
|
| "executed": all_executed,
|
| "success": all_success_codes,
|
| "return_code": 0 if all_success_codes else 2,
|
| "stdout_tail": summary_stdout,
|
| "stderr_tail": summary_stderr,
|
| "real_execution": all_success_codes,
|
| "failed_rules": failing_rules,
|
| }
|
| return {"run": run_info, "test_sql_by_rule": test_sql_by_rule}
|
|
|
|
|
| def _prepare_soda_cloud_scan(
|
| rules: Sequence[Mapping[str, object]],
|
| db_path: Path,
|
| root_dir: Path,
|
| ) -> Dict[str, object]:
|
| soda_dir = root_dir / "soda_cloud"
|
| soda_dir.mkdir(parents=True, exist_ok=True)
|
| runtime_db_path = root_dir / "soda_cloud_runtime.db"
|
| shutil.copyfile(db_path, runtime_db_path)
|
|
|
| data_source_name = "off_quality"
|
| config_path = soda_dir / "data_source.yml"
|
| soda_cloud_config_path = soda_dir / "soda_cloud.yml"
|
| contracts_dir = soda_dir / "contracts"
|
| contracts_dir.mkdir(parents=True, exist_ok=True)
|
|
|
| check_yaml_by_rule: Dict[str, str] = {}
|
| soda_cloud_config, cloud_config_source = _resolve_soda_cloud_config(soda_cloud_config_path)
|
| if soda_cloud_config is None:
|
| return {
|
| "run": {
|
| "command": "soda contract verify -c <contract.yml> -ds data_source.yml -sc soda_cloud.yml -p",
|
| "executed": False,
|
| "success": False,
|
| "return_code": None,
|
| "stdout_tail": "",
|
| "stderr_tail": (
|
| "Soda Cloud config missing. Provide sc_config.yml, set SODA_CLOUD_CONFIG_PATH, "
|
| "or set SODA_CLOUD_API_KEY_ID, SODA_CLOUD_API_KEY_SECRET, SODA_CLOUD_HOST."
|
| ),
|
| "mode": "cloud",
|
| "cloud_connected": False,
|
| "cloud_scan_id": "",
|
| "cloud_scan_url": "",
|
| "real_execution": False,
|
| "failed_rules": [str(rule["rule_name"]) for rule in rules],
|
| },
|
| "check_yaml_by_rule": check_yaml_by_rule,
|
| }
|
|
|
| _write_soda_data_source_config(config_path=config_path, data_source_name=data_source_name, runtime_db_path=runtime_db_path)
|
|
|
| soda_cmd = shutil.which("soda")
|
| if not soda_cmd:
|
| return {
|
| "run": {
|
| "command": (
|
| f"soda contract verify -c <contract.yml> -ds {config_path} "
|
| f"-sc {soda_cloud_config_path} -p"
|
| ),
|
| "executed": False,
|
| "success": False,
|
| "return_code": None,
|
| "stdout_tail": "",
|
| "stderr_tail": "soda CLI not found. Install soda-duckdb.",
|
| "mode": "cloud",
|
| "cloud_connected": False,
|
| "cloud_scan_id": "",
|
| "cloud_scan_url": "",
|
| "real_execution": False,
|
| "failed_rules": [str(rule["rule_name"]) for rule in rules],
|
| },
|
| "check_yaml_by_rule": check_yaml_by_rule,
|
| }
|
|
|
| with duckdb.connect(db_path.as_posix()) as con:
|
| columns = [str(row[1]) for row in con.execute(f"PRAGMA table_info('{TABLE_NAME}')").fetchall()]
|
|
|
| soda_env = {
|
| "OTEL_SDK_DISABLED": "true",
|
| "PYTHONUTF8": "1",
|
| "PYTHONIOENCODING": "utf-8",
|
| }
|
| per_rule_runs: Dict[str, Dict[str, object]] = {}
|
| first_cloud_meta = {"scan_id": "", "scan_url": ""}
|
| for rule in rules:
|
| rule_name = str(rule["rule_name"])
|
| condition = str(rule["duckdb_condition"])
|
| check_block = (
|
| f" - failed_rows:\n"
|
| f" name: {rule_name}\n"
|
| f" expression: {condition}\n"
|
| )
|
| check_yaml_by_rule[rule_name] = check_block.rstrip("\n")
|
|
|
| contract_lines: List[str] = [
|
| f"dataset: {data_source_name}/main/{TABLE_NAME}",
|
| "columns:",
|
| ]
|
| for column in columns:
|
| contract_lines.append(f" - name: {column}")
|
| contract_lines.extend(["checks:", check_block.rstrip("\n")])
|
|
|
| contract_path = contracts_dir / f"{rule_name}.yml"
|
| contract_path.write_text("\n".join(contract_lines) + "\n", encoding="utf-8")
|
|
|
| run = _run_command(
|
| [
|
| soda_cmd,
|
| "contract",
|
| "verify",
|
| "-c",
|
| str(contract_path),
|
| "-ds",
|
| str(config_path),
|
| "-sc",
|
| str(soda_cloud_config),
|
| "-p",
|
| "-v",
|
| ],
|
| cwd=soda_dir,
|
| env=soda_env,
|
| )
|
| per_rule_runs[rule_name] = run
|
| cloud_meta = _extract_cloud_scan_metadata(
|
| stdout_tail=str(run.get("stdout_tail", "")),
|
| stderr_tail=str(run.get("stderr_tail", "")),
|
| )
|
| if not first_cloud_meta["scan_id"] and cloud_meta["scan_id"]:
|
| first_cloud_meta["scan_id"] = cloud_meta["scan_id"]
|
| if not first_cloud_meta["scan_url"] and cloud_meta["scan_url"]:
|
| first_cloud_meta["scan_url"] = cloud_meta["scan_url"]
|
|
|
| all_executed = all(bool(run.get("executed")) for run in per_rule_runs.values())
|
| all_success_codes = all(run.get("return_code") in {0, 1} for run in per_rule_runs.values())
|
| all_real = all(_soda_run_is_real(run) for run in per_rule_runs.values())
|
| all_published = all(_soda_cloud_publish_succeeded(run) for run in per_rule_runs.values())
|
| failing_rules = [
|
| rule_name
|
| for rule_name, run in per_rule_runs.items()
|
| if not (_soda_run_is_real(run) and _soda_cloud_publish_succeeded(run))
|
| ]
|
|
|
| summary_stdout, summary_stderr = _summarize_soda_runs(per_rule_runs)
|
|
|
| run_info = {
|
| "command": (
|
| f"soda contract verify (per-rule x{len(per_rule_runs)}) -ds {config_path} "
|
| f"-sc {soda_cloud_config} -p"
|
| ),
|
| "executed": all_executed,
|
| "success": all_success_codes,
|
| "return_code": 0 if all_success_codes else 3,
|
| "stdout_tail": summary_stdout,
|
| "stderr_tail": summary_stderr,
|
| "mode": "cloud",
|
| "real_execution": all_real,
|
| "cloud_connected": all_published,
|
| "cloud_scan_id": first_cloud_meta["scan_id"],
|
| "cloud_scan_url": first_cloud_meta["scan_url"],
|
| "cloud_config_source": cloud_config_source,
|
| "failed_rules": failing_rules,
|
| }
|
| return {"run": run_info, "check_yaml_by_rule": check_yaml_by_rule}
|
|
|
|
|
| def _prepare_soda_contract(rules: Sequence[Mapping[str, object]], db_path: Path, root_dir: Path) -> Dict[str, object]:
|
| soda_dir = root_dir / "soda"
|
| soda_dir.mkdir(parents=True, exist_ok=True)
|
| data_source_name = "off_quality"
|
| runtime_db_path = root_dir / "soda_runtime.db"
|
| config_path = soda_dir / "data_source.yml"
|
| contracts_dir = soda_dir / "contracts"
|
| contracts_dir.mkdir(parents=True, exist_ok=True)
|
| shutil.copyfile(db_path, runtime_db_path)
|
|
|
| _write_soda_data_source_config(config_path=config_path, data_source_name=data_source_name, runtime_db_path=runtime_db_path)
|
|
|
| with duckdb.connect(db_path.as_posix()) as con:
|
| columns = [str(row[1]) for row in con.execute(f"PRAGMA table_info('{TABLE_NAME}')").fetchall()]
|
|
|
| check_yaml_by_rule: Dict[str, str] = {}
|
| soda_cmd = shutil.which("soda")
|
| if not soda_cmd:
|
| return {
|
| "run": {
|
| "command": f"soda contract verify -c <contract.yml> -ds {config_path}",
|
| "executed": False,
|
| "success": False,
|
| "return_code": None,
|
| "stdout_tail": "",
|
| "stderr_tail": "soda CLI not found. Install soda-duckdb.",
|
| },
|
| "check_yaml_by_rule": check_yaml_by_rule,
|
| }
|
|
|
| soda_env = {
|
|
|
| "OTEL_SDK_DISABLED": "true",
|
| "PYTHONUTF8": "1",
|
| "PYTHONIOENCODING": "utf-8",
|
| }
|
| per_rule_runs: Dict[str, Dict[str, object]] = {}
|
| for rule in rules:
|
| rule_name = str(rule["rule_name"])
|
| condition = str(rule["duckdb_condition"])
|
| check_block = (
|
| f" - failed_rows:\n"
|
| f" name: {rule_name}\n"
|
| f" expression: {condition}\n"
|
| )
|
| check_yaml_by_rule[rule_name] = check_block.rstrip("\n")
|
|
|
| contract_lines: List[str] = [
|
| f"dataset: {data_source_name}/main/{TABLE_NAME}",
|
| "columns:",
|
| ]
|
| for column in columns:
|
| contract_lines.append(f" - name: {column}")
|
| contract_lines.extend(["checks:", check_block.rstrip("\n")])
|
|
|
| contract_path = contracts_dir / f"{rule_name}.yml"
|
| contract_path.write_text("\n".join(contract_lines) + "\n", encoding="utf-8")
|
|
|
| per_rule_runs[rule_name] = _run_command(
|
| [soda_cmd, "contract", "verify", "-c", str(contract_path), "-ds", str(config_path)],
|
| cwd=soda_dir,
|
| env=soda_env,
|
| )
|
|
|
| all_executed = all(bool(run.get("executed")) for run in per_rule_runs.values())
|
| all_success_codes = all(run.get("return_code") in {0, 1} for run in per_rule_runs.values())
|
| all_real = all(_soda_run_is_real(run) for run in per_rule_runs.values())
|
| failing_rules = [rule_name for rule_name, run in per_rule_runs.items() if not _soda_run_is_real(run)]
|
|
|
| summary_stdout = "\n".join(
|
| f"{rule_name}: rc={run.get('return_code')}, success={run.get('success')}"
|
| for rule_name, run in per_rule_runs.items()
|
| )[-1200:]
|
| summary_stderr = "\n".join(
|
| f"{rule_name}: {str(run.get('stderr_tail', '')).strip()}"
|
| for rule_name, run in per_rule_runs.items()
|
| if str(run.get("stderr_tail", "")).strip()
|
| )[-1200:]
|
|
|
| run_info = {
|
| "command": f"soda contract verify (per-rule x{len(per_rule_runs)}) -ds {config_path}",
|
| "executed": all_executed,
|
| "success": all_success_codes,
|
| "return_code": 0 if all_success_codes else 3,
|
| "stdout_tail": summary_stdout,
|
| "stderr_tail": summary_stderr,
|
| "mode": "local",
|
| "real_execution": all_real,
|
| "cloud_connected": False,
|
| "cloud_scan_id": "",
|
| "cloud_scan_url": "",
|
| "failed_rules": failing_rules,
|
| }
|
| return {"run": run_info, "check_yaml_by_rule": check_yaml_by_rule}
|
|
|
|
|
| def _dbt_run_is_real(run_info: Mapping[str, object]) -> bool:
|
| if "real_execution" in run_info:
|
| return bool(run_info.get("real_execution"))
|
| if not bool(run_info.get("executed")):
|
| return False
|
| return run_info.get("return_code") in {0, 1}
|
|
|
|
|
| def _soda_run_is_real(run_info: Mapping[str, object]) -> bool:
|
| if not bool(run_info.get("executed")):
|
| return False
|
| output = f"{run_info.get('stdout_tail', '')}\n{run_info.get('stderr_tail', '')}".lower()
|
| if "soda v3 commands are not supported" in output:
|
| return False
|
| if "contract results for" in output:
|
| return True
|
| if run_info.get("return_code") in {0, 1}:
|
| return True
|
| return bool(run_info.get("success"))
|
|
|
|
|
| def _soda_cloud_publish_succeeded(run_info: Mapping[str, object]) -> bool:
|
| if not bool(run_info.get("executed")):
|
| return False
|
| output = f"{run_info.get('stdout_tail', '')}\n{run_info.get('stderr_tail', '')}".lower()
|
| if "results sent to soda cloud" in output:
|
| return True
|
| if "to view the dataset on soda cloud" in output:
|
| return True
|
| if "cloud.soda.io/o/" in output:
|
| return True
|
| return False
|
|
|
|
|
| def _summarize_soda_runs(per_rule_runs: Mapping[str, Mapping[str, object]]) -> tuple[str, str]:
|
| summary_stdout = "\n".join(
|
| f"{rule_name}: rc={run.get('return_code')}, success={run.get('success')}"
|
| for rule_name, run in per_rule_runs.items()
|
| )
|
| summary_stderr = "\n".join(
|
| f"{rule_name}: {str(run.get('stderr_tail', '')).strip()}"
|
| for rule_name, run in per_rule_runs.items()
|
| if str(run.get("stderr_tail", "")).strip()
|
| )
|
|
|
| for rule_name, run in per_rule_runs.items():
|
| if not _soda_run_is_real(run):
|
| failing_stdout = str(run.get("stdout_tail", "")).strip()
|
| failing_stderr = str(run.get("stderr_tail", "")).strip()
|
| if failing_stdout:
|
| summary_stdout = f"{summary_stdout}\n\nFirst failing rule: {rule_name}\n{failing_stdout}"
|
| if failing_stderr:
|
| summary_stderr = f"{summary_stderr}\n\nFirst failing rule: {rule_name}\n{failing_stderr}"
|
| break
|
|
|
| return summary_stdout[-1200:], summary_stderr[-1200:]
|
|
|
|
|
| def run_declarative_checks(
|
| rules: Sequence[Mapping[str, object]],
|
| products: Sequence[Mapping[str, object]],
|
| db_path: Path,
|
| engine: str,
|
| soda_mode: str = "local",
|
| ) -> Dict[str, object]:
|
| """Run declarative checks and return parity-compatible output payload."""
|
| if engine not in {"dbt", "soda"}:
|
| raise ValueError(f"Unsupported declarative engine: {engine}")
|
| if soda_mode not in {"local", "cloud"}:
|
| raise ValueError("soda_mode must be one of: local, cloud")
|
|
|
| runtime_root = RUNTIME_DIR / engine
|
| runtime_root.mkdir(parents=True, exist_ok=True)
|
|
|
| per_rule_ids: Dict[str, List[str]] = {}
|
| for rule in rules:
|
| per_rule_ids[str(rule["rule_name"])] = _query_rule_product_ids(rule, db_path=db_path)
|
|
|
| per_product_tags = _build_per_product_tags(rules=rules, per_rule_ids=per_rule_ids, products=products)
|
|
|
| if engine == "dbt":
|
| artifact = _prepare_dbt_project(rules=rules, db_path=db_path, root_dir=runtime_root)
|
| run_info = artifact["run"]
|
| snippets = artifact["test_sql_by_rule"]
|
| is_real = _dbt_run_is_real(run_info)
|
| provider = "dbt_core" if is_real else "dbt_core_sql_fallback"
|
| confidence = 0.99 if is_real else 0.92
|
| note_prefix = (
|
| "dbt tests executed through dbt-core."
|
| if is_real
|
| else "dbt execution unavailable/failed; used SQL-equivalent declarative parity."
|
| )
|
| else:
|
| if soda_mode == "cloud":
|
| cloud_artifact = _prepare_soda_cloud_scan(rules=rules, db_path=db_path, root_dir=runtime_root)
|
| cloud_run = cloud_artifact["run"]
|
| snippets = cloud_artifact["check_yaml_by_rule"]
|
| cloud_ok = bool(cloud_run.get("cloud_connected")) and bool(cloud_run.get("real_execution"))
|
| if cloud_ok:
|
| run_info = cloud_run
|
| is_real = True
|
| provider = "soda_cloud"
|
| confidence = 0.99
|
| note_prefix = "Soda Cloud scan executed successfully."
|
| else:
|
| run_info = dict(cloud_run)
|
| run_info.update(
|
| {
|
| "mode": "cloud_sql_fallback",
|
| "real_execution": False,
|
| "cloud_connected": bool(cloud_run.get("cloud_connected", False)),
|
| "cloud_scan_id": str(cloud_run.get("cloud_scan_id", "")),
|
| "cloud_scan_url": str(cloud_run.get("cloud_scan_url", "")),
|
| "failed_rules": [str(rule["rule_name"]) for rule in rules],
|
| }
|
| )
|
| is_real = False
|
| provider = "soda_core_sql_fallback"
|
| confidence = 0.92
|
| note_prefix = "Soda Cloud unavailable/failed; used SQL-equivalent declarative parity (fast fallback)."
|
| else:
|
| artifact = _prepare_soda_contract(rules=rules, db_path=db_path, root_dir=runtime_root)
|
| run_info = artifact["run"]
|
| snippets = artifact["check_yaml_by_rule"]
|
| is_real = bool(run_info.get("real_execution")) or _soda_run_is_real(run_info)
|
| provider = "soda_core" if is_real else "soda_core_sql_fallback"
|
| confidence = 0.99 if is_real else 0.92
|
| note_prefix = (
|
| "Soda contract verification executed through soda-core."
|
| if is_real
|
| else "Soda execution unavailable/failed; used SQL-equivalent declarative parity."
|
| )
|
|
|
| conversion_metadata: Dict[str, Dict[str, object]] = {}
|
| for rule in rules:
|
| rule_name = str(rule["rule_name"])
|
| conversion_metadata[rule_name] = {
|
| "function_name": f"{engine}_{rule_name}",
|
| "python_code": snippets.get(rule_name, _sql_for_rule(rule)),
|
| "llm_confidence": confidence,
|
| "conversion_notes": (
|
| f"{note_prefix} "
|
| f"Command: {run_info['command']} | "
|
| f"Success: {run_info['success']} | "
|
| f"Return code: {run_info['return_code']}"
|
| ),
|
| "provider": provider,
|
| "execution_mode": str(run_info.get("mode", "local")),
|
| "cloud_connected": bool(run_info.get("cloud_connected", False)),
|
| "cloud_scan_id": str(run_info.get("cloud_scan_id", "")),
|
| "cloud_scan_url": str(run_info.get("cloud_scan_url", "")),
|
| }
|
|
|
| return {
|
| "per_product": per_product_tags,
|
| "per_rule": per_rule_ids,
|
| "conversion_metadata": conversion_metadata,
|
| "engine_run": run_info,
|
| }
|
|
|
