Update text

text

@@ -1,260 +1,571 @@
-import sys
-sys.path.append("../..")
-import json
-from typing import Dict, List, Optional
-import sys
-from sqlalchemy import text
-from sqlalchemy.engine import Result
-from app.db import engine
-from app.config import settings
-from app.cleaning.prompts import CLEAN_PROMPT
-from app.cleaning.llm import LLM
+# app/cleaning/prompts.py
+from __future__ import annotations
 
+from textwrap import dedent
+from typing import Dict, Iterable, List, Optional, Set, Tuple
 
-"""
-IN-PLACE CLEANING PIPELINE (Original Logic, No Mirroring)
-
-- Reads from SAME TABLE
-- Writes back into SAME TABLE
-- Adds <col>_clean columns if missing
-- Cleans only up to clean_cap rows (default 20)
-- Preserves original data completely
-- No target schema, no cloned tables, no mirroring
-"""
+from app.config import settings
 
-MAX_ROWS_PER_TABLE = 20
 
+DEFAULT_ALLOWED_TABLES: Tuple[str, ...] = (
+    # "test_products", ## sample table for navin testing
+    "tblModelDetails",
+    "tblDimensionInfo",
+    "tblInstances",
+    "tblModelBoundingBox",
+    "tblModelCheckerResults",
+    "tblModelDetailsHub",
+    "tblModelFloorPlanMapping",
+    "tblModels",
+    "tblNWCViewExport",
+    "tblTypes",
+    "tblProjects",
+    "tblProjectSubTypes",
+    "tblRFISubType",
+    "tblViews",
+    "tblUsers",
+    "tblWorkflowStatuses",
+    "tblCategory",
+    "tblAssembly",
+    "tblElements",
+    "tblMaterials",
+    "tblModelRoomDetails",
+    "tblGeometryDataNew",
+    "tblGeometryDataBatchMapping",
+)
+
+RELATIONSHIP_SUMMARY = dedent("""\
+# Relational Structure Summary
+
+tblModelDetails ← (central entity)
+    ↑ tblDimensionInfo.ModelID
+    ↑ tblInstances.ModelID
+    ↑ tblModelBoundingBox.ModelID
+    ↑ tblModelCheckerResults.ModelID
+    ↑ tblModelDetailsHub.ModelID
+    ↑ tblModelFloorPlanMapping.ModelID
+    ↑ tblModels.ModelID
+    ↑ tblNWCViewExport.ModelID
+    ↑ tblTypes.ModelID
+
+tblProjects ← referenced by:
+    tblModelDetails.ProjectID
+    tblTypes.ProjectID
+
+tblTypes ← referenced by:
+    tblInstances.TypeID / RFITypeID / ProjectTypeID
+    tblProjectSubTypes.TypeID / RFITypeID / ProjectTypeID
+    tblRFISubType.TypeID / RFITypeID / ProjectTypeID
+
+tblViews ← referenced by:
+    tblModelBoundingBox.ViewID
+
+tblUsers ← referenced by:
+    tblModelDetails.ExportedBy
+
+tblWorkflowStatuses ← referenced by:
+    tblModelDetails.StatusID
+
+tblCategory ← referenced by:
+    tblTypes.CategoryID
+""")
+
+# -------------------------------
+#  Cleaning prompt (for culprit columns)
+# -------------------------------
+CLEAN_PROMPT = dedent("""\
+    You are cleaning noisy product/part names into a canonical short form.
+
+    Rules:
+    - Normalize inch units: 4", 4 inch, 4 in -> "4 in".
+    - Fix obvious misspellings: "elbw" -> "elbow".
+    - Remove opaque trailing codes like "-rr20" unless essential to identity.
+    - Keep it compact and human-readable.
+    - Return ONLY the cleaned text. No quotes, no explanations.
+""")
+
+
+# -------------------------------
+#  SQL generation (system prompt)
+# -------------------------------
+SQL_PROMPT_SYSTEM = dedent("""\
+    You are an expert Postgres SQL generator.
+
+    CONTEXT
+    - All tables are in the `public` schema of the `TransactionalData` database.
+    - The `public` schema already contains cleaned columns (e.g., *_clean).
+    - Use only the tables and columns that exist in `public`.
+    - You MUST restrict yourself to only the tables/relations that appear in the relational summary
+      provided in the user message. Do not invent tables or columns.
+
+    OUTPUT
+    - Return a single SELECT statement only (no CTEs across multiple statements, no DDL/DML).
+    - Qualify identifiers when needed using the `public.` schema.
+    - Avoid vendor-specific functions beyond standard Postgres.
+    - If units appear, assume inches unless the column clearly uses *_mm.
+
+    JOINING & FILTERING
+    - Use only joins that are consistent with the relational summary (respect directionality).
+    - When matching human-entered part names/sizes:
+        * Prefer cleaned columns (e.g., name_clean, title_clean) when they exist.
+        * Otherwise use ILIKE with robust patterns and simple normalization
+          (e.g., replace double quotes with " in).
+    - Limit columns to those that answer the question clearly.
+
+    IF UNSURE
+    - If the schema lacks a required join path, prefer a simpler query over a wrong join.
+    - You may add safe assumptions in comments inside the SQL (using --) but DO NOT return prose.
+""")
+
+
+
+# -------------------------------
+#  Catalog-aware prompt (default for sql_gen)
+# -------------------------------
+def sql_user_prompt(
+    question: str,
+    catalog_snapshot: Iterable[Dict[str, str]],
+    allowed_tables: Iterable[str] = DEFAULT_ALLOWED_TABLES,
+) -> str:
+    allowed = list(dict.fromkeys(allowed_tables))
+
+    # The source and target schema are the same now.
+    target_schema = settings.POSTGRES_SOURCE_SCHEMAS
+
+    column_map: Dict[str, Dict[str, Set[str]]] = {}
+    for row in catalog_snapshot:
+        row_data = row if isinstance(row, dict) else dict(row)
+        schema = row_data.get("table_schema")
+        table = row_data.get("table_name")
+        column = row_data.get("column_name")
+        if not schema or not table or not column:
+            continue
+        if table not in allowed:
+            continue
+        column_map.setdefault(schema, {}).setdefault(table, set()).add(column)
+
+    def render_columns(schema: str) -> List[str]:
+        lines: List[str] = []
+        tables = column_map.get(schema)
+        if not tables:
+            return lines
+        lines.append(f"{schema}:")
+        for table in allowed:
+            cols = tables.get(table)
+            if not cols:
+                continue
+            lines.append(f"  {table}:")
+            for col in sorted(cols):
+                lines.append(f"    - {col}")
+        lines.append("")
+        return lines
+
+    column_lines: List[str] = []
+    seen_schemas: Set[str] = set()
+
+    # Only one schema: public
+    for schema in [target_schema]:
+        if schema in seen_schemas:
+            continue
+        seen_schemas.add(schema)
+        column_lines.extend(render_columns(schema))
+
+    if not column_lines:
+        columns_block = "(no columns discovered for the curated tables)"
+    else:
+        columns_block = "\n".join(column_lines).rstrip()
+
+    relationship_block = RELATIONSHIP_SUMMARY.strip()
+
+    return dedent(f"""\
+        Question: {question}
+
+        Focus tables and columns (curated set):
+        {columns_block}
+
+        {relationship_block}
+
+        Guidance:
+        - Use tables only from the `public` schema.
+        - Prefer cleaned columns (e.g., *_clean) when they exist in `public`.
+        - Restrict joins to the relationships shown above; do not invent tables or links.
+        - Return ONE PostgreSQL SELECT statement (no modifications).
+    """)
+
+
+# -------------------------------
+#  Convenience: pack system + user together
+# -------------------------------
+def build_full_sql_prompt(
+    question: str,
+    allowed_tables: Iterable[str] = DEFAULT_ALLOWED_TABLES,
+    catalog_snapshot: Optional[Iterable[Dict[str, str]]] = None,
+) -> Dict[str, str]:
+    """
+    Returns {"system": SQL_PROMPT_SYSTEM, "user": <combined user text>}
+    """
+    if catalog_snapshot is None:
+        from app.db import get_catalog_snapshot  # local import to avoid cycles
+        catalog_snapshot = get_catalog_snapshot()
+
+    user = sql_user_prompt(
+        question=question,
+        catalog_snapshot=catalog_snapshot or [],
+        allowed_tables=allowed_tables,
+    )
+    return {"system": SQL_PROMPT_SYSTEM, "user": user}
 
-# ----------------------------------------------------
-# ADD <col>_clean columns into SAME TABLE
-# ----------------------------------------------------
-def ensure_clean_columns(schema: str, table: str, culprit_columns: List[str]):
-    if not culprit_columns:
-        return
 
-    with engine.begin() as cx:
-        for col in culprit_columns:
-            col_clean = f"{col}_clean"
-            sql = (
-                f'ALTER TABLE "{schema}"."{table}" '
-                f'ADD COLUMN IF NOT EXISTS "{col_clean}" TEXT'
-            )
-            cx.execute(text(sql))
-
-
-# ----------------------------------------------------
-# Count rows
-# ----------------------------------------------------
-def _count_source_rows(schema: str, table: str) -> int:
-    try:
-        with engine.begin() as cx:
-            row = cx.execute(
-                text(f'SELECT COUNT(*) FROM "{schema}"."{table}"')
-            ).first()
-            return int(row[0])
-    except Exception:
-        return -1
 
 
-# ----------------------------------------------------
-# Stream rows from SAME TABLE
-# ----------------------------------------------------
-def stream_rows(schema: str, table: str, batch_size=1000, max_rows=None):
-    limit = ""
-    if max_rows:
-        limit = f" LIMIT {int(max_rows)}"
 
-    sql = f'SELECT * FROM "{schema}"."{table}"{limit}'
 
-    with engine.begin() as cx:
-        result: Result = (
-            cx.execution_options(stream_results=True)
-            .execute(text(sql))
-        )
 
-        batch = []
-        yielded = 0
 
-        for row in result.mappings():
-            batch.append(dict(row))
-            yielded += 1
 
-            if len(batch) >= batch_size:
-                yield batch
-                batch = []
 
-            if max_rows and yielded >= max_rows:
-                break
 
-        if batch:
-            yield batch
 
 
-# ----------------------------------------------------
-# Write back INTO SAME TABLE
-# ----------------------------------------------------
-def write_batch(schema: str, table: str, rows: List[Dict], pk_col: str):
-    if not rows:
-        return
 
-    for r in rows:
-        # json encode dict/list so SQL can accept it
-        for k, v in list(r.items()):
-            if isinstance(v, (dict, list)):
-                r[k] = json.dumps(v)
+import re
+import sqlparse
+from sqlalchemy import text
+from app.db import engine, get_catalog_snapshot
+from app.cleaning.llm import LLM
+from app.cleaning.prompts import SQL_PROMPT_SYSTEM, sql_user_prompt
+from app.config import settings
 
+def is_safe_select(sql: str) -> bool:
+    parsed = sqlparse.parse(sql)
+    if not parsed:
+        return False
+    stmt = parsed[0]
+    if stmt.get_type() != "SELECT":
+        return False
+    # crude safeguards
+    forbidden = re.compile(r'\b(INSERT|UPDATE|DELETE|DROP|TRUNCATE|ALTER|CREATE|GRANT|REVOKE)\b', re.I)
+    return not forbidden.search(sql)
+
+def _quote_schema_identifiers(sql: str) -> str:
+    """Quote occurrences of <schema>.<identifier> where not already quoted.
+    This fixes case-sensitivity issues when the LLM emits MixedCase table names.
+    """
+    import re as _re
+    schema = settings.POSTGRES_SOURCE_SCHEMAS
+    # Quote occurrences like normalizeddata.tblTypes -> "normalizeddata"."tblTypes"
+    pat = _re.compile(rf'(?<!\")\b{_re.escape(schema)}\.(?!\")(\w+)', _re.IGNORECASE)
+    sql = pat.sub(lambda m: f'"{schema}"."{m.group(1)}"', sql)
+    # Also quote public.<identifier> forms
+    pat_pub = _re.compile(r'(?<!\")\bpublic\.(?!\")(\w+)', _re.IGNORECASE)
+    sql = pat_pub.sub(lambda m: f'"public"."{m.group(1)}"', sql)
+    return sql
+
+def _quote_alias_columns(sql: str) -> str:
+    """Quote occurrences of alias.column where column isn't already quoted or a wildcard.
+    Keeps alias as-is and wraps the column with quotes to preserve case.
+    """
+    import re as _re
+    # Skip cases like alias."Column" and alias.*
+    pat = _re.compile(r'\b([A-Za-z_][\w]*)\.(?!\")(\w+)')
+    reserved = {"public", settings.POSTGRES_SOURCE_SCHEMAS.lower(), "pg_catalog", "information_schema"}
+    def _repl(m: _re.Match[str]) -> str:
+        alias = m.group(1)
+        col = m.group(2)
+        if alias.lower() in reserved:
+            return m.group(0)
+        return f'{alias}."{col}"'
+    return pat.sub(_repl, sql)
+
+def nl_to_sql(question: str) -> str:
+    catalog = get_catalog_snapshot()
+    prompt = sql_user_prompt(question, catalog)
+    llm = LLM()
+    if not llm.enabled():
+        raise RuntimeError("LLM disabled: set LLM_PROVIDER in .env to enable NL→SQL.")
+    sql = llm.nl_to_sql(SQL_PROMPT_SYSTEM, prompt)
+    # strip code fences if any
+    sql = sql.strip().strip("`")
+    if sql.startswith("sql"):
+        sql = sql[3:].strip()
+    if "```" in sql:
+        sql = re.sub(r"```sql|```", "", sql, flags=re.I).strip()
+    # Quote schema identifiers to preserve MixedCase table names
+    sql = _quote_schema_identifiers(sql)
+    # Quote alias columns (e.g., e.ElementID -> e."ElementID")
+    sql = _quote_alias_columns(sql)
+    if not is_safe_select(sql):
+        raise ValueError("Generated SQL failed safety checks (SELECT-only required).")
+    return sql
+
+def run_sql(sql: str, limit: int = 200):
+    # enforce a hard cap to avoid huge result sets
+    sql_wrapped = f"SELECT * FROM ({sql}) AS sub LIMIT {limit}"
     with engine.begin() as cx:
-        for r in rows:
-            pk_val = r[pk_col]
+        rows = cx.execute(text(sql_wrapped)).mappings().all()
+    return [dict(r) for r in rows]
 
-            set_list = ", ".join(
-                f'"{c}" = :{c}' for c in r.keys() if c != pk_col
-            )
 
-            sql = (
-                f'UPDATE "{schema}"."{table}" '
-                f'SET {set_list} '
-                f'WHERE "{pk_col}" = :{pk_col}'
-            )
 
-            cx.execute(text(sql), r)
 
 
-# ----------------------------------------------------
-# LLM clean
-# ----------------------------------------------------
-def clean_value(llm: LLM, value: str) -> str:
-    if not llm.enabled():
-        return value
 
-    out = llm.clean_text(
-        value,
-        system=CLEAN_PROMPT,
-        instruction="Clean the following product text."
-    )
-    return out.strip() or value
-
-
-# ----------------------------------------------------
-# MAIN FUNCTION — identical logic to old pipeline
-# ----------------------------------------------------
-def run_clean_table(
-    schema: str,
-    table: str,
-    culprit_columns: List[str],
-    batch_size: int = 1000,
-    clean_cap: Optional[int] = None,
-    primary_key: Optional[str] = None,
-    clean_all: bool = False,
-):
-    if not primary_key:
-        raise ValueError("primary_key required")
 
-    llm = LLM()
 
-    # Ensure <col>_clean exists
-    ensure_clean_columns(schema, table, culprit_columns)
 
-    # Determine cleaning cap
-    total_rows = _count_source_rows(schema, table)
-    cap = None if clean_all else (clean_cap or MAX_ROWS_PER_TABLE)
 
-    print(f"\n→ In-place cleaning {schema}.{table} (rows={total_rows}, cap={cap})")
-    sys.stdout.flush()
 
-    # Skip rows already cleaned
-    skip_pks = set()
-    if culprit_columns:
-        cond = " AND ".join([f'"{c}_clean" IS NOT NULL' for c in culprit_columns])
-        sql = (
-            f'SELECT "{primary_key}" FROM "{schema}"."{table}" '
-            f'WHERE {cond}'
-        )
-        try:
-            with engine.begin() as cx:
-                rows = cx.execute(text(sql)).fetchall()
-                skip_pks = {r[0] for r in rows}
-        except:
-            skip_pks = set()
+import re
+from typing import List, Tuple, Dict, Set
+
+from sqlalchemy import text
+from app.config import settings
+
+from app.db import engine, get_catalog_snapshot
+from app.cleaning.llm import LLM
+from app.cleaning.prompts import SQL_PROMPT_SYSTEM, sql_user_prompt
+
+
+def _strip_code_fences(s: str) -> str:
+    s = s.strip()
+    s = re.sub(r"^```sql\s*|\s*```$", "", s, flags=re.I | re.M)
+    return s.strip("`").strip()
+
+
+EXTRA_GUIDANCE = """
+Requirements:
+- Search across cleaned columns only (use *_clean):
+  Types(TypeName_clean, FamilyName_clean), Elements(ElementName_clean),
+  Assembly(AssemblyName_clean), Materials(Name_clean), Views(ViewName_clean),
+  ModelDetails(ModelName_clean), ModelRoomDetails(RoomName_clean),
+  ModelFloorPlanMapping(FloorPlanName_clean), GeometryDataNew(GeometryFileName_clean).
+- Prefer normalized units (e.g., 4 in). Treat 4", 4 inch, 4 inches as 4 in.
+- Match singular/plural (e.g., wall/walls, elbow/elbows) using robust ILIKE patterns.
+- Follow relationships to Types to return the correct TypeID when searching non-Type tables.
+- Final output should be a single SELECT that includes a column aliased exactly as TypeID
+  (e.g., SELECT DISTINCT t."TypeID" AS TypeID, ...). Avoid returning other columns.
+"""
 
-    rows_cleaned = 0
-    rows_processed = 0
-    skipped_existing = 0
 
-    # STREAM + CLEAN + UPDATE SAME TABLE
-    for rows in stream_rows(schema, table, batch_size=batch_size):
-        out_rows = []
+def _is_select(sql: str) -> bool:
+    return bool(sql and sql.strip().lower().startswith("select"))
 
-        for r in rows:
-            pk = r.get(primary_key)
 
-            # Skip already cleaned rows
-            if pk in skip_pks:
-                skipped_existing += 1
-                continue
+def _quote_schema_identifiers(sql: str) -> str:
+    """Quote occurrences of <schema>.<identifier> where not already quoted.
+    This helps when the LLM emits MixedCase table names without quotes.
+    """
+    schema = settings.POSTGRES_SOURCE_SCHEMAS
+    # Quote occurrences like normalizeddata.tblTypes -> "normalizeddata"."tblTypes"
+    pat = re.compile(rf'(?<!")\b{re.escape(schema)}\.(?!")(\w+)', re.IGNORECASE)
+    sql = pat.sub(lambda m: f'"{schema}"."{m.group(1)}"', sql)
+    # Also quote public.<identifier> forms
+    pat_pub = re.compile(r'(?<!")\bpublic\.(?!")(\w+)', re.IGNORECASE)
+    sql = pat_pub.sub(lambda m: f'"public"."{m.group(1)}"', sql)
+    return sql
 
-            will_clean = (cap is None) or (rows_cleaned < cap)
 
-            # Clean selected columns
-            for col in culprit_columns:
-                original = r.get(col)
-                original_s = None if original is None else str(original)
+def nl_to_typeids(question: str) -> Tuple[List[int], str]:
+    """Generate SQL via LLM that returns DISTINCT TypeID for the user question
+    and execute it, returning a list of TypeID values.
+    """
+    # Build a focused prompt with columns and relations
+    catalog = get_catalog_snapshot()
+    user = sql_user_prompt(question, catalog_snapshot=catalog)
+    user += "\n\n" + EXTRA_GUIDANCE
 
-                if will_clean:
-                    cleaned = clean_value(llm, original_s) if original_s else None
-                    r[f"{col}_clean"] = cleaned
-                    rows_cleaned += 1
-                else:
-                    # out-of-cap rows → NULL clean column (old behavior)
-                    r[f"{col}_clean"] = None
+    llm = LLM()
+    if not llm.enabled():
+        raise RuntimeError("LLM disabled: set LLM_PROVIDER in .env to enable NL→SQL.")
 
-            out_rows.append(r)
+    sql = llm.nl_to_sql(SQL_PROMPT_SYSTEM, user)
+    sql = _strip_code_fences(sql)
+    sql = _quote_schema_identifiers(sql)
+    if not _is_select(sql):
+        raise ValueError("LLM did not return a SELECT statement.")
 
-        # Write back to same table
-        write_batch(schema, table, out_rows, pk_col=primary_key)
-        rows_processed += len(out_rows)
+    # Execute LLM SQL directly and extract any column that looks like TypeID
+    try:
+        with engine.begin() as cx:
+            # Favor normalizeddata then public on the search_path for convenience
+            try:
+                cx.execute(text(
+                    f"SET LOCAL search_path TO \"{settings.POSTGRES_SOURCE_SCHEMAS}\", " + ",".join(settings.source_schemas)
+                ))
+            except Exception:
+                pass
+            rows = cx.execute(text(sql)).mappings().all()
+
+        if not rows:
+            return ([], sql)
+
+        # Find a key resembling TypeID (case-insensitive, underscores allowed)
+        keys = list(rows[0].keys())
+
+        def is_typeid(k: str) -> bool:
+            return bool(re.fullmatch(r"(?i)type[_ ]?id", k))
+
+        cand = None
+        for k in keys:
+            if is_typeid(k):
+                cand = k
+                break
+        if cand is None:
+            for k in keys:
+                if k.lower() in ("typeid", "type_id"):
+                    cand = k
+                    break
+        if cand is None:
+            return ([], sql)
+
+        vals: set[int] = set()
+        for r in rows:
+            v = r.get(cand)
+            if v is None:
+                continue
+            try:
+                vals.add(int(v))
+            except Exception:
+                try:
+                    vals.add(int(str(v).strip()))
+                except Exception:
+                    continue
+        return (sorted(vals), sql)
+    except Exception:
+        # Fallback: build a deterministic UNION-based search using only verified joins/columns
+        return _fallback_union_search(question)
+
+
+def _fallback_union_search(question: str) -> Tuple[List[int], str]:
+    """Fallback SQL builder that unions TypeIDs discovered via safe, known paths."""
+    catalog = get_catalog_snapshot()
+    target = settings.POSTGRES_SOURCE_SCHEMAS
+    cmap: Dict[str, Dict[str, Set[str]]] = {}
+    for r in catalog:
+        schema = r["table_schema"]
+        table = r["table_name"]
+        col = r["column_name"]
+        cmap.setdefault(schema, {}).setdefault(table, set()).add(col)
+
+    def has(table: str, *cols: str, schema: str = target) -> bool:
+        return table in cmap.get(schema, {}) and all(c in cmap[schema][table] for c in cols)
+
+    def normalize_inches(txt: str) -> str:
+        t = txt
+        t = re.sub(r"(\d+)\s*(?:inches|inch|in|\")\b", r"\1 in", t, flags=re.I)
+        return t
+
+    qn = normalize_inches(question.lower())
+    tokens = []
+    for tok in re.findall(r"\d+\s+in|[a-zA-Z]+", qn):
+        tokens.append(tok.strip())
+    alts: Set[str] = set(tokens)
+    for t in list(tokens):
+        if len(t) > 2 and t.isalpha():
+            if t.endswith("s"):
+                alts.add(t[:-1])
+            else:
+                alts.add(t + "s")
+    pats = [f"%{t}%" for t in sorted(alts)]
+
+    def like_all(col: str) -> str:
+        return " AND ".join([f"{col} ILIKE :p{i}" for i in range(len(pats))]) if pats else "TRUE"
+
+    parts: List[str] = []
+
+    if has("tblTypes", "TypeID", "TypeName_clean"):
+        conds = like_all('t."TypeName_clean"')
+        parts.append(
+            f'SELECT DISTINCT t."TypeID" AS TypeID FROM "{target}"."tblTypes" t WHERE {conds}'
+        )
+    if has("tblTypes", "TypeID", "FamilyName_clean"):
+        conds = like_all('t."FamilyName_clean"')
+        parts.append(
+            f'SELECT DISTINCT t."TypeID" AS TypeID FROM "{target}"."tblTypes" t WHERE {conds}'
+        )
 
-        # progress
-        target = cap or total_rows
-        pct = int(min(rows_cleaned, target) * 100 / target)
+    if has("tblElements", "TypeID", "ElementName_clean"):
+        conds = like_all('e."ElementName_clean"')
+        parts.append(
+            f'SELECT DISTINCT e."TypeID" AS TypeID FROM "{target}"."tblElements" e WHERE {conds}'
+        )
 
-        print(
-            f"   {table}: cleaned {rows_cleaned}/{target} ({pct}%) "
-            f"| updated rows: {rows_processed} | skipped: {skipped_existing}"
+    if has("tblTypes", "TypeID", "MaterialID") and has("tblMaterials", "MaterialID", "Name_clean"):
+        conds = like_all('m."Name_clean"')
+        parts.append(
+            f'SELECT DISTINCT t."TypeID" AS TypeID '
+            f'FROM "{target}"."tblTypes" t '
+            f'JOIN "{target}"."tblMaterials" m ON t."MaterialID" = m."MaterialID" '
+            f'WHERE {conds}'
         )
-        sys.stdout.flush()
 
-    print(
-        f"✓ DONE: {schema}.{table} in-place cleaned "
-        f"(cleaned={rows_cleaned}, skipped={skipped_existing})\n"
-    )
+    if has("tblTypes", "TypeID", "ModelID") and has("tblModelDetails", "ModelID", "ModelName_clean"):
+        conds = like_all('md."ModelName_clean"')
+        parts.append(
+            f'SELECT DISTINCT t."TypeID" AS TypeID '
+            f'FROM "{target}"."tblTypes" t '
+            f'JOIN "{target}"."tblModelDetails" md ON t."ModelID" = md."ModelID" '
+            f'WHERE {conds}'
+        )
+
+    if has("tblTypes", "TypeID", "ModelID") and has("tblViews", "ModelID", "ViewName_clean"):
+        conds = like_all('v."ViewName_clean"')
+        parts.append(
+            f'SELECT DISTINCT t."TypeID" AS TypeID '
+            f'FROM "{target}"."tblTypes" t '
+            f'JOIN "{target}"."tblViews" v ON t."ModelID" = v."ModelID" '
+            f'WHERE {conds}'
+        )
+
+    if has("tblTypes", "TypeID", "ModelID") and has("tblAssembly", "ModelID", "AssemblyName_clean"):
+        conds = like_all('a."AssemblyName_clean"')
+        parts.append(
+            f'SELECT DISTINCT t."TypeID" AS TypeID '
+            f'FROM "{target}"."tblTypes" t '
+            f'JOIN "{target}"."tblAssembly" a ON t."ModelID" = a."ModelID" '
+            f'WHERE {conds}'
+        )
+
+    if has("tblTypes", "TypeID", "ModelID") and has("tblModelRoomDetails", "ModelID", "RoomName_clean"):
+        conds = like_all('mrd."RoomName_clean"')
+        parts.append(
+            f'SELECT DISTINCT t."TypeID" AS TypeID '
+            f'FROM "{target}"."tblTypes" t '
+            f'JOIN "{target}"."tblModelRoomDetails" mrd ON t."ModelID" = mrd."ModelID" '
+            f'WHERE {conds}'
+        )
 
+    if has("tblTypes", "TypeID", "ModelID") and has("tblModelFloorPlanMapping", "ModelID", "FloorPlanName_clean"):
+        conds = like_all('mfpm."FloorPlanName_clean"')
+        parts.append(
+            f'SELECT DISTINCT t."TypeID" AS TypeID '
+            f'FROM "{target}"."tblTypes" t '
+            f'JOIN "{target}"."tblModelFloorPlanMapping" mfpm ON t."ModelID" = mfpm."ModelID" '
+            f'WHERE {conds}'
+        )
 
-# ----------------------------------------------------
-# YAML Loader
-# ----------------------------------------------------
-def run_cleaning_from_yaml(
-    yaml_path: str,
-    batch_size: int = 1000,
-    clean_cap: Optional[int] = None,
-    clean_all: bool = False,
-):
-    import yaml
-
-    with open(yaml_path, "r") as f:
-        cfg = yaml.safe_load(f)
-
-    for t in cfg.get("tables", []):
-        run_clean_table(
-            schema=t["schema"],
-            table=t["name"],
-            culprit_columns=t["culprit_columns"],
-            batch_size=batch_size,
-            primary_key=t["primary_key"],
-            clean_cap=clean_cap,
-            clean_all=clean_all,
+    if has("tblTypes", "TypeID", "ModelID") and has("tblGeometryDataNew", "ModelID", "GeometryFileName_clean"):
+        conds = like_all('g."GeometryFileName_clean"')
+        parts.append(
+            f'SELECT DISTINCT t."TypeID" AS TypeID '
+            f'FROM "{target}"."tblTypes" t '
+            f'JOIN "{target}"."tblGeometryDataNew" g ON t."ModelID" = g."ModelID" '
+            f'WHERE {conds}'
         )
 
+    if not parts:
+        return ([], "-- no valid search paths found")
+
+    sql = "\nUNION\n".join(parts)
+
+    params = {f"p{i}": pats[i] for i in range(len(pats))}
+    with engine.begin() as cx:
+        rows = cx.execute(text(sql), params).scalars().all()
+    # rows already ints
+    out = sorted({int(x) for x in rows if x is not None})
+    return (out, sql)
+
+