Scripts/pipeline_parsers/dbt_parser.py

"""
dbt_parser.py
~~~~~~~~~~~~~
Feature extraction for dbt SQL models and dbt_project.yml / schema.yml files.

SQL parsing uses regex rather than a full SQL parser because dbt models
are templated Jinja2+SQL, which most parsers reject.  We extract structural
signals (CTEs, JOINs, window functions, ref/source calls) with targeted
patterns rather than attempting full syntax analysis.
"""

import json
import re
from pathlib import PurePosixPath

# ── dbt Jinja macro patterns ──────────────────────────────────────────────────
_REF_RE    = re.compile(r"\{\{\s*ref\s*\(\s*['\"](\w+)['\"]\s*\)\s*\}\}", re.I)
_SOURCE_RE = re.compile(r"\{\{\s*source\s*\(", re.I)
_CONFIG_RE = re.compile(r"\{\{\s*config\s*\(([^}]+)\)\s*\}\}", re.I | re.S)
_MAT_RE    = re.compile(r"materialized\s*=\s*['\"](\w+)['\"]", re.I)
_UKEY_RE   = re.compile(r"unique_key\s*=", re.I)

# ── SQL structural patterns ───────────────────────────────────────────────────
_CTE_RE    = re.compile(r"\bWITH\b", re.I)
_JOIN_RE   = re.compile(r"\b(?:INNER|LEFT|RIGHT|FULL|CROSS)?\s*JOIN\b", re.I)
_WHERE_RE  = re.compile(r"\bWHERE\b", re.I)
_WINDOW_RE = re.compile(r"\bOVER\s*\(", re.I)
_LIMIT_RE  = re.compile(r"\bLIMIT\s+(\d+)\b", re.I)
_STAR_RE   = re.compile(r"\bSELECT\s+\*", re.I)
_INCR_RE   = re.compile(r"is_incremental\s*\(\s*\)", re.I)
# Hardcoded raw table reference (FROM word without ref/source) — rough heuristic
_RAW_FROM_RE = re.compile(r"\bFROM\s+([a-zA-Z_]\w*(?:\.\w+){1,2})\b", re.I)

# ── Model layer inference from path ──────────────────────────────────────────
_LAYER_MAP = {
    "staging":      "staging",
    "stg":          "staging",
    "intermediate": "intermediate",
    "int":          "intermediate",
    "marts":        "marts",
    "mart":         "marts",
    "core":         "marts",
    "final":        "marts",
    "reporting":    "marts",
}


def _infer_layer(file_path: str) -> str:
    parts = PurePosixPath(file_path).parts
    for part in parts:
        if part.lower() in _LAYER_MAP:
            return _LAYER_MAP[part.lower()]
    return "other"


def _extract_materialization(content: str) -> str | None:
    m = _CONFIG_RE.search(content)
    if m:
        inner = m.group(1)
        mat = _MAT_RE.search(inner)
        if mat:
            return mat.group(1).lower()
    return None


def extract_model(content: str, file_path: str) -> dict:
    """
    Parse one dbt SQL model file.
    Returns a feature dict ready for INSERT into dbt_model_features.
    """
    lines = content.splitlines()
    file_lines = len(lines)
    model_name = PurePosixPath(file_path).stem

    try:
        ref_count   = len(_REF_RE.findall(content))
        source_count = len(_SOURCE_RE.findall(content))
        mat         = _extract_materialization(content)
        uses_incr   = int(bool(_INCR_RE.search(content)))
        has_ukey    = int(bool(_UKEY_RE.search(content)))
        cte_count   = len(_CTE_RE.findall(content))
        has_join    = int(bool(_JOIN_RE.search(content)))
        has_where   = int(bool(_WHERE_RE.search(content)))
        has_window  = int(bool(_WINDOW_RE.search(content)))
        hardcoded_limit = int(bool(_LIMIT_RE.search(content)))
        select_star = int(bool(_STAR_RE.search(content)))

        # No ref/source + FROM literal table name = hardcoded raw table
        raw_froms = _RAW_FROM_RE.findall(content)
        antipattern_no_src_ref = int(
            ref_count == 0 and source_count == 0 and len(raw_froms) > 0
        )

        return {
            "model_name":           model_name,
            "model_layer":          _infer_layer(file_path),
            "materialization":      mat,
            "ref_count":            ref_count,
            "source_count":         source_count,
            "cte_count":            cte_count,
            "has_where_clause":     has_where,
            "has_join":             has_join,
            "has_window_function":  has_window,
            "uses_incremental":     uses_incr,
            "has_unique_key":       has_ukey,
            "hardcoded_limit":      hardcoded_limit,
            "select_star":          select_star,
            "file_lines":           file_lines,
            "antipattern_incremental_no_unique_key": int(uses_incr and not has_ukey),
            "antipattern_select_star":               select_star,
            "antipattern_no_source_no_ref":          antipattern_no_src_ref,
            "parse_error":          None,
        }
    except Exception as exc:  # noqa: BLE001
        return {"model_name": model_name, "parse_error": str(exc),
                "file_lines": file_lines}


# ── dbt_project.yml / schema.yml ─────────────────────────────────────────────
try:
    import yaml as _yaml
    _YAML_OK = True
except ImportError:
    _YAML_OK = False

_DBT_VERSION_RE = re.compile(r"require-dbt-version\s*:\s*['\"]?([^\s'\"]+)")
_MODEL_PATHS_RE = re.compile(r"model-paths\s*:\s*\[([^\]]+)\]")


def extract_project(content: str, file_path: str) -> dict:
    """
    Parse dbt_project.yml and return a summary dict for dbt_project_summary.
    """
    result: dict = {"parse_error": None}
    fname = PurePosixPath(file_path).name.lower()

    if fname not in ("dbt_project.yml", "dbt_project.yaml"):
        result["parse_error"] = "not_dbt_project_file"
        return result

    if _YAML_OK:
        try:
            data = _yaml.safe_load(content) or {}
            result["dbt_version_required"] = str(
                data.get("require-dbt-version", "")
            ) or None
            paths = data.get("model-paths") or data.get("source-paths") or []
            result["model_paths"] = json.dumps(paths)
            result["has_tests_dir"] = int("test-paths" in data or "tests" in data)
            result["has_snapshots"]  = int("snapshot-paths" in data)
            result["has_seeds"]      = int("seed-paths" in data)
            result["has_analyses"]   = int("analysis-paths" in data)
        except Exception as exc:  # noqa: BLE001
            result["parse_error"] = str(exc)
    else:
        # Regex fallback
        m = _DBT_VERSION_RE.search(content)
        result["dbt_version_required"] = m.group(1) if m else None
        result["has_tests_dir"]  = int("test-paths" in content)
        result["has_snapshots"]  = int("snapshot-paths" in content)
        result["has_seeds"]      = int("seed-paths" in content)
        result["has_analyses"]   = int("analysis-paths" in content)

    return result


def extract_schema(content: str, file_path: str) -> dict:
    """
    Parse a models/**/schema.yml and return per-model test coverage signals.
    Returns a lightweight dict:  {model_name: has_tests, ...}
    Caller merges this into dbt_model_features rows.
    """
    coverage: dict[str, int] = {}
    if not _YAML_OK:
        return coverage
    try:
        data = _yaml.safe_load(content) or {}
        for model in data.get("models", []):
            name = model.get("name", "")
            tests = model.get("tests", []) or []
            col_tests = any(
                col.get("tests") for col in model.get("columns", [])
            )
            coverage[name] = int(bool(tests) or col_tests)
    except Exception:  # noqa: BLE001
        pass
    return coverage