dataface 0.1.2__py3-none-any.whl

dataface/cli/commands/render.py

@@ -0,0 +1,291 @@
+"""Render command implementation."""
+
+import json as _json
+import sys
+from pathlib import Path
+
+from dataface.agent_api._paths import (
+    project_root_for,
+    setup_render_for_face,
+    setup_render_for_yaml,
+)
+from dataface.agent_api.dashboards import RenderedDashboard, render_dashboard
+from dataface.cli._error_format import print_structured_errors
+from dataface.core.errors import StructuredError
+from dataface.core.render.warnings import (
+    registry as _warnings_registry,
+    unreferenced_chart,
+)
+from dataface.core.render.warnings.base import RenderWarning
+from dataface.core.render.warnings.from_query_diagnostic import KNOWN_RENDER_CODES
+
+# Compile-time warning producers don't live on detector modules in the registry,
+# but their codes appear on the unified RenderedDashboard.warnings channel and
+# must be recognized by --ignore-warning. Adapter map is the source of truth
+# for query-validator codes; only orphan emitters (e.g. unreferenced_chart) add here.
+_COMPILE_PRODUCER_CODES: frozenset[str] = KNOWN_RENDER_CODES | {unreferenced_chart.CODE}
+
+
+def _exit_with_errors(errs: list[StructuredError], json_errors: bool) -> None:
+    print_structured_errors(errs, json_output=json_errors)
+    sys.exit(1)
+
+
+def _emit_unknown_code_notices(ignore_codes: set[str]) -> None:
+    """Print a one-line notice for each code not found in the registry.
+
+    Unknown codes are forward-compatible suppression stubs (a dataface.yml may
+    list codes that haven't shipped yet). They do NOT cause a non-zero exit.
+    Uses live module reference so tests can monkeypatch DETECTORS on the registry.
+    """
+    known = {d.CODE for d in _warnings_registry.DETECTORS} | _COMPILE_PRODUCER_CODES
+    for code in sorted(ignore_codes):
+        if code not in known:
+            print(f"unknown warning code: {code}", file=sys.stderr)
+
+
+def _format_warnings_stderr(warnings: list[RenderWarning]) -> None:
+    """Write the active warnings block to stderr in the canonical format.
+
+    Format:
+        ⚠ N warning(s):
+          [CODE] chart-id: message
+            → fix
+    """
+    if not warnings:
+        return
+    n = len(warnings)
+    label = "warning" if n == 1 else "warnings"
+    print(f"⚠ {n} {label}:", file=sys.stderr)
+    for w in warnings:
+        chart_prefix = f"{w.chart}: " if w.chart else ""
+        print(f"  [{w.code}] {chart_prefix}{w.message}", file=sys.stderr)
+        if w.fix:
+            print(f"    → {w.fix}", file=sys.stderr)
+
+
+def _merge_warnings_into_json(
+    data: dict[str, object],
+    result: RenderedDashboard,
+) -> str:
+    """For JSON format, inject warnings and suppressed_warnings.
+
+    Agents and consumers reading --format json must see warnings regardless of
+    --no-warnings (that flag is a human-output convenience only).
+    data is always a dict here (dashboard.py JSON path returns json.loads output).
+    """
+    base = dict(data)
+    base["warnings"] = [w.model_dump() for w in result.warnings]
+    base["suppressed_warnings"] = [w.model_dump() for w in result.suppressed_warnings]
+    return _json.dumps(base)
+
+
+def render_command(
+    face_path: Path,
+    output: str | None = None,
+    format: str = "svg",
+    project_dir: Path | None = None,
+    variables: dict[str, str] | None = None,
+    use_cache: bool = True,
+    json_errors: bool = False,
+    no_warnings: bool = False,
+    ignore_codes: set[str] | None = None,
+) -> str | None:
+    """Render a dashboard to SVG, HTML, PNG, PDF, or terminal.
+
+    Args:
+        face_path: Path to face YAML file
+        output: Output file path. For binary formats (png, pdf) and svg/html,
+               default is renders/ folder with face name. For json/text/yaml,
+               default is stdout. Use "-" to force stdout. Ignored for terminal
+               format (always prints to stdout).
+        format: Output format (svg, html, png, pdf, terminal, json, text, yaml)
+        project_dir: Project directory for resolving relative paths
+        variables: Variable values to pass to the render (key=value pairs)
+        use_cache: Whether to use cached query results
+        json_errors: Emit errors as JSON to stdout instead of Rich panels to stderr
+        no_warnings: Suppress stderr warning output (warnings still appear in JSON)
+        ignore_codes: Warning codes to suppress via the partition seam
+
+    Returns:
+        Output file path on success, None for terminal/stdout output or on error
+    """
+    if ignore_codes:
+        _emit_unknown_code_notices(ignore_codes)
+
+    output_dir = project_root_for(project_dir)
+    setup, face_file = setup_render_for_face(face_path, project_dir)
+    result = render_dashboard(
+        path=setup.scoped_path,
+        project_dir=setup.scoped_base,
+        format=format,
+        variables=variables,
+        adapter_registry=setup.adapter_registry,
+        use_cache=use_cache,
+        # Match pre-PR behaviour: 2x retina PNG by default for the CLI.
+        scale=2.0,
+        ignore_codes=ignore_codes,
+    )
+
+    if not result.success:
+        errors = result.validation_errors or (
+            [result.face_error] if result.face_error else []
+        )
+        _exit_with_errors(errors, json_errors=json_errors)
+
+    if not no_warnings:
+        _format_warnings_stderr(result.warnings)
+
+    if format == "json":
+        assert isinstance(result.data, dict)
+        rendered_content: str | bytes = _merge_warnings_into_json(result.data, result)
+    else:
+        rendered_content = (
+            result.data
+            if isinstance(result.data, (str, bytes))
+            else _json.dumps(result.data)
+        )
+    return _write_output(
+        rendered_content,
+        output=output,
+        format=format,
+        output_dir=output_dir,
+        default_output_stem=face_file.stem,
+        source_label=str(face_path),
+    )
+
+
+def render_command_from_yaml(
+    yaml_content: str,
+    output: str | None = None,
+    format: str = "svg",
+    project_dir: Path | None = None,
+    variables: dict[str, str] | None = None,
+    use_cache: bool = True,
+    json_errors: bool = False,
+    no_warnings: bool = False,
+    ignore_codes: set[str] | None = None,
+) -> str | None:
+    """Render a dashboard from YAML content (e.g. stdin).
+
+    Args:
+        yaml_content: Raw YAML string
+        output: Output file path. Binary formats and svg/html default to a
+               renders/ file under project_dir; json/text/yaml default to stdout.
+               Use "-" to force stdout. Ignored for terminal format.
+        format: Output format (svg, html, png, pdf, terminal, json, text, yaml)
+        project_dir: Project directory for resolving relative paths
+        variables: Variable values to pass to the render
+        use_cache: Whether to use cached query results
+        json_errors: Emit errors as JSON to stdout instead of Rich panels to stderr
+        no_warnings: Suppress stderr warning output (warnings still appear in JSON)
+        ignore_codes: Warning codes to suppress via the partition seam
+
+    Returns:
+        Output file path on success, None for terminal/stdout output or on error
+    """
+    if ignore_codes:
+        _emit_unknown_code_notices(ignore_codes)
+
+    output_dir = project_root_for(project_dir)
+    setup = setup_render_for_yaml(project_dir)
+    result = render_dashboard(
+        yaml_content=yaml_content,
+        project_dir=setup.scoped_base,
+        format=format,
+        variables=variables,
+        adapter_registry=setup.adapter_registry,
+        use_cache=use_cache,
+        scale=2.0,
+        ignore_codes=ignore_codes,
+    )
+
+    if not result.success:
+        errors = result.validation_errors or (
+            [result.face_error] if result.face_error else []
+        )
+        _exit_with_errors(errors, json_errors=json_errors)
+
+    if not no_warnings:
+        _format_warnings_stderr(result.warnings)
+
+    if format == "json":
+        assert isinstance(result.data, dict)
+        rendered_content: str | bytes = _merge_warnings_into_json(result.data, result)
+    else:
+        rendered_content = (
+            result.data
+            if isinstance(result.data, (str, bytes))
+            else _json.dumps(result.data)
+        )
+    return _write_output(
+        rendered_content,
+        output=output,
+        format=format,
+        output_dir=output_dir,
+        default_output_stem="stdin",
+        source_label="<stdin>",
+    )
+
+
+def _write_output(
+    rendered_content: str | bytes,
+    output: str | None,
+    format: str,
+    output_dir: Path,
+    default_output_stem: str,
+    source_label: str,
+) -> str | None:
+    """Write rendered content to the appropriate destination."""
+    # `terminal` is stdout-only by design — --output is meaningless for the
+    # ANSI-formatted preview. Every other text format honors --output when set
+    # and defaults to stdout otherwise (no implicit `renders/` write).
+    if format == "terminal" or (format in ("json", "text", "yaml") and output is None):
+        text_output = (
+            rendered_content.decode()
+            if isinstance(rendered_content, bytes)
+            else rendered_content
+        )
+        print(text_output)
+        return None
+
+    if output == "-":
+        if isinstance(rendered_content, bytes):
+            sys.stdout.buffer.write(rendered_content)
+        else:
+            print(rendered_content)
+        return None
+
+    # Resolve output paths against output_dir (CWD / --project-dir), not project_root
+    is_binary = format in ("png", "pdf")
+    output_extension = f".{format}"
+
+    if output:
+        output_path = Path(output)
+        if not output_path.is_absolute():
+            output_path = output_dir / output_path
+    else:
+        renders_dir = output_dir / "renders"
+        renders_dir.mkdir(exist_ok=True)
+        output_path = renders_dir / f"{default_output_stem}{output_extension}"
+
+    if is_binary:
+        content_bytes = (
+            rendered_content.encode()
+            if isinstance(rendered_content, str)
+            else rendered_content
+        )
+        output_path.write_bytes(content_bytes)
+    else:
+        content_str = (
+            rendered_content.decode()
+            if isinstance(rendered_content, bytes)
+            else rendered_content
+        )
+        output_path.write_text(content_str, encoding="utf-8")
+
+    print(
+        f"Rendered {source_label} to {output_path} ({format} format)",
+        file=sys.stderr,
+    )
+    return str(output_path)

dataface/cli/commands/schema.py

@@ -0,0 +1,411 @@
+"""CLI command for `dft schema`.
+
+Thin wrapper. All logic lives in ``dataface.agent_api.schema`` (drill-down)
+and ``dataface.agent_api.schema_search`` (search mode); this file parses CLI
+args, calls the appropriate verb, and renders for the terminal.
+
+Modes
+-----
+- Drill-down (default): positional ``SOURCE``, ``SCHEMA``, ``TABLE``, ``COLUMN``
+- Search mode (``-s`` / ``--search`` present): dispatches to schema_search;
+  all filter flags (``--role``, ``--tag``, ``--scope``, etc.) apply.
+"""
+
+from __future__ import annotations
+
+import warnings
+from pathlib import Path
+from typing import Any
+
+import typer
+
+warnings.filterwarnings(
+    "ignore",
+    message=r"Core Pydantic V1 functionality isn't compatible with Python 3\.14",
+    category=UserWarning,
+    module=r"dsi_pydantic_shim",
+)
+
+from dataface.agent_api.schema import SchemaResponse, schema as _schema
+from dataface.agent_api.schema_search import (
+    SchemaSearchResult,
+    schema_search as _schema_search,
+)
+from dataface.cli._error_format import print_structured_errors
+from dataface.cli._parsing import parse_kv_pairs
+from dataface.core.errors import DF_UNKNOWN_INTERNAL, StructuredError
+from dataface.core.execute.adapters import build_adapter_registry
+
+
+def schema_command(
+    source: str | None = None,
+    schema: str | None = None,
+    table: str | None = None,
+    column: str | None = None,
+    json_output: bool = False,
+    project_dir: Path | None = None,
+    lineage_depth: int = 1,
+    # Search-mode args (only used when search is not None)
+    search: str | None = None,
+    scope: str | None = None,
+    regex: bool = False,
+    role: str | None = None,
+    tag: str | None = None,
+    has_test: str | None = None,
+    missing: str | None = None,
+    column_name: str | None = None,
+    table_name: str | None = None,
+    fk_to: str | None = None,
+    meta: list[str] | None = None,
+    fields: str | None = None,
+    limit: int | None = None,
+) -> None:
+    """Browse the data hierarchy or search the schema corpus.
+
+    ``-s`` / ``--search`` has context-dependent semantics:
+
+    - With ``SOURCE`` + ``SCHEMA`` (no ``TABLE`` / ``COLUMN``): applies a
+      ``re.search`` regexp filter on the level-3 table list (table name or cached
+      column name match). This calls ``agent_api.schema(table_search=...)``.
+    - Without drill-down args: full-text + predicate corpus search via
+      ``agent_api.schema_search``. All ``--role``, ``--tag``, etc. flags apply here.
+    - With any other drill-down arg combination: raises ``BadParameter``.
+
+    MCP callers use ``table_search`` directly on the ``schema`` tool to get the
+    regexp filter without going through the ``-s`` routing.
+    """
+    project_root = (project_dir or Path(".")).resolve()
+    adapter_registry = build_adapter_registry(project_root, read_only=True)
+
+    if search is not None:
+        # Level-3 drill-down + regexp filter: dft schema SOURCE SCHEMA -s PATTERN
+        # When source + schema are given but table/column are not, -s applies a
+        # regexp table/column-name filter on the drill-down result instead of
+        # dispatching to schema_search.
+        if (
+            source is not None
+            and schema is not None
+            and table is None
+            and column is None
+        ):
+            # Reject search-mode-only flags — they have no meaning in filter mode
+            # and silently dropping them would produce a wrong-looking result.
+            search_only_flags = {
+                "--role": role,
+                "--tag": tag,
+                "--has-test": has_test,
+                "--missing": missing,
+                "--column-name": column_name,
+                "--table-name": table_name,
+                "--fk-to": fk_to,
+                "--meta": meta,
+                "--fields": fields,
+                "--limit": limit,
+                "--scope": scope,
+                "--regex": regex or None,
+            }
+            active_search_flags = [f for f, v in search_only_flags.items() if v]
+            if active_search_flags:
+                raise typer.BadParameter(
+                    f"flags {active_search_flags} are search-mode-only and cannot "
+                    "be combined with SOURCE + SCHEMA + -s (filter mode). "
+                    "Drop the drill-down args to use search mode, or drop the "
+                    "predicate flags to use filter mode."
+                )
+            drill_result = _schema(
+                source=source,
+                schema=schema,
+                lineage_depth=lineage_depth,
+                table_search=search,
+                surface="cli",
+                adapter_registry=adapter_registry,
+            )
+            if json_output:
+                typer.echo(
+                    drill_result.model_dump_json(
+                        by_alias=True, indent=2, exclude_none=True
+                    )
+                )
+                if not drill_result.success:
+                    raise typer.Exit(1)
+                return
+            _print_rich(
+                drill_result, source=source, schema=schema, table=None, column=None
+            )
+            if not drill_result.success:
+                raise typer.Exit(1)
+            return
+
+        drill_args = {
+            "SOURCE": source,
+            "SCHEMA": schema,
+            "TABLE": table,
+            "COLUMN": column,
+        }
+        conflicts = [arg for arg, val in drill_args.items() if val is not None]
+        if conflicts:
+            raise typer.BadParameter(
+                f"drill-down args {conflicts} cannot be combined with -s/--search. "
+                "Use -s for search mode or positional args for navigation, not both."
+            )
+
+        parsed_meta = parse_kv_pairs(meta, "--meta") if meta else None
+
+        result = _schema_search(
+            keyword=search,
+            scope=[s.strip() for s in scope.split(",") if s.strip()] if scope else None,
+            regex=regex,
+            role=role,
+            tag=tag,
+            has_test=has_test,
+            missing=missing,
+            meta=parsed_meta,
+            column_name=column_name,
+            table_name=table_name,
+            fk_to=fk_to,
+            fields=(
+                [f.strip() for f in fields.split(",") if f.strip()] if fields else None
+            ),
+            limit=limit,
+            adapter_registry=adapter_registry,
+        )
+        if json_output:
+            typer.echo(result.model_dump_json(by_alias=True, exclude_none=True))
+            if not result.success:
+                raise typer.Exit(1)
+            return
+        _print_rich_search(result)
+        if not result.success:
+            raise typer.Exit(1)
+        return
+
+    drill_result = _schema(
+        source=source,
+        schema=schema,
+        table=table,
+        column=column,
+        lineage_depth=lineage_depth,
+        surface="cli",
+        adapter_registry=adapter_registry,
+    )
+
+    if json_output:
+        typer.echo(
+            drill_result.model_dump_json(by_alias=True, indent=2, exclude_none=True)
+        )
+        if not drill_result.success:
+            raise typer.Exit(1)
+        return
+
+    _print_rich(drill_result, source=source, schema=schema, table=table, column=column)
+    if not drill_result.success:
+        raise typer.Exit(1)
+
+
+def _print_rich_search(result: SchemaSearchResult) -> None:
+    if not result.success:
+        # SchemaSearchResult carries only plain strings in errors; synthesize a
+        # DF-UNKNOWN-INTERNAL wrapper so print_structured_errors renders cleanly.
+        print_structured_errors(
+            [
+                StructuredError(
+                    code=DF_UNKNOWN_INTERNAL.code,
+                    domain=DF_UNKNOWN_INTERNAL.domain,
+                    doc_url=DF_UNKNOWN_INTERNAL.doc_url,
+                    docs_topic=DF_UNKNOWN_INTERNAL.docs_topic,
+                    message="; ".join(result.errors),
+                )
+            ]
+        )
+        return
+    if not result.hits:
+        typer.echo("No matches.")
+        return
+    for hit in result.hits:
+        typer.echo(f"  [{hit.source}] {hit.location}  ({hit.matched_field})")
+        if hit.snippet:
+            typer.echo(f"      {hit.snippet}")
+    if result.truncated:
+        typer.echo(f"... truncated to {len(result.hits)} of {result.total} hits")
+
+
+def _spec_is_exact(arg: str) -> bool:
+    """Return True when the CLI arg is a literal name (no glob wildcards)."""
+    return "*" not in arg and "?" not in arg and "[" not in arg
+
+
+def _iter_drill_tables(
+    sources: dict[str, Any],
+    source: str,
+    schema: str,
+) -> list[tuple[str, str, dict[str, Any]]]:
+    """Yield (schema_name, table_name, table_data) over the matching subtree.
+
+    When schema is an exact name, only that schema is visited. When it contains
+    a wildcard, every schema under the source is visited.
+    """
+    schemas = sources.get(source, {}).get("schemas", {})
+    if _spec_is_exact(schema):
+        tables = schemas.get(schema, {}).get("tables") or {}
+        return [(schema, tname, tdata) for tname, tdata in tables.items()]
+    result = []
+    for sname, sdata in schemas.items():
+        for tname, tdata in (sdata.get("tables") or {}).items():
+            result.append((sname, tname, tdata))
+    return result
+
+
+def _print_rich(
+    result: SchemaResponse,
+    source: str | None,
+    schema: str | None,
+    table: str | None,
+    column: str | None,
+) -> None:
+    if not result.success:
+        print_structured_errors(
+            result.structured_errors
+            or [
+                StructuredError(
+                    code=DF_UNKNOWN_INTERNAL.code,
+                    domain=DF_UNKNOWN_INTERNAL.domain,
+                    doc_url=DF_UNKNOWN_INTERNAL.doc_url,
+                    docs_topic=DF_UNKNOWN_INTERNAL.docs_topic,
+                    message="; ".join(result.errors),
+                )
+            ]
+        )
+        return
+
+    sources = result.sources
+    if (
+        column is not None
+        and table is not None
+        and source is not None
+        and schema is not None
+    ):
+        rows = _iter_drill_tables(sources, source, schema)
+        schema_is_wildcard = not _spec_is_exact(schema)
+        first = True
+        for sname, tname, tdata in rows:
+            label = f"{sname}.{tname}" if schema_is_wildcard else tname
+            for cname, cdata in (tdata.get("columns") or {}).items():
+                if not first:
+                    typer.echo("")
+                _echo_column(f"{label}.{cname}", cdata)
+                first = False
+        return
+
+    if table is not None and source is not None and schema is not None:
+        rows = _iter_drill_tables(sources, source, schema)
+        schema_is_wildcard = not _spec_is_exact(schema)
+        first = True
+        for sname, tname, tdata in rows:
+            if not first:
+                typer.echo("")
+            label = f"{sname}.{tname}" if schema_is_wildcard else tname
+            _echo_table_profile(label, tdata)
+            first = False
+        return
+
+    if schema is not None and source is not None:
+        if result.message:
+            typer.echo(result.message)
+        for hint in result.hints or []:
+            typer.echo(f"  → {hint}")
+        for warning in result.warnings or []:
+            typer.echo(f"  ⚠ {warning}")
+        schemas_branch = sources.get(source, {}).get("schemas", {})
+        for sname, sdata in schemas_branch.items():
+            tables_branch = sdata.get("tables") or {}
+            if not tables_branch:
+                continue
+            typer.echo(f"  [{sname}]")
+            for tname, summary in tables_branch.items():
+                kind = summary.get("kind", "table")
+                rc = summary.get("row_count")
+                tag = f" rows={rc}" if rc is not None else ""
+                typer.echo(f"    {tname}  ({kind}){tag}")
+        return
+
+    if source is not None:
+        schemas_branch = sources.get(source, {}).get("schemas", {})
+        for sname, sdata in schemas_branch.items():
+            count = sdata.get("table_count")
+            tag = f"  ({count} tables)" if count is not None else ""
+            typer.echo(f"  {sname}{tag}")
+        return
+
+    if not sources:
+        typer.echo("No data sources configured.")
+        return
+    for sname, sdata in sources.items():
+        stype = sdata.get("type", "unknown")
+        path = sdata.get("path")
+        line = f"  {sname}  ({stype})"
+        if path:
+            line += f"  {path}"
+        typer.echo(line)
+
+
+def _echo_table_profile(name: str, data: dict[str, Any]) -> None:
+    typer.echo(f"Table: {name}")
+    if (rc := data.get("row_count")) is not None:
+        typer.echo(f"  rows: {rc}")
+    if (desc := data.get("description")) is not None:
+        typer.echo(f"  description: {desc}")
+    upstream = data.get("upstream") or []
+    downstream = data.get("downstream") or []
+    if upstream:
+        parts = [
+            f"{r['table']} ({'source' if r.get('kind') == 'source' else 'ref'})"
+            for r in upstream
+        ]
+        typer.echo(f"  ↑ upstream: {', '.join(parts)}")
+    if downstream:
+        typer.echo(f"  ↓ downstream: {', '.join(r['table'] for r in downstream)}")
+    partitions = data.get("partitions")
+    if (
+        partitions
+        and partitions.get("supported", False)
+        and partitions.get("type") not in {"none", "unpartitioned"}
+    ):
+        col = partitions.get("column")
+        n = len(partitions.get("entries") or [])
+        col_str = f" on {col}" if col else ""
+        noun = "entry" if n == 1 else "entries"
+        typer.echo(f"  partitions: {partitions['type']}{col_str} ({n} {noun})")
+    if (lm := data.get("last_modified")) is not None:
+        typer.echo(f"  last_modified: {lm}")
+    for cname, cdata in (data.get("columns") or {}).items():
+        ctype = cdata.get("type") or cdata.get("actual_type") or ""
+        sem = cdata.get("semantic_type") or ""
+        suffix = f"  {sem}" if sem else ""
+        rel_suffix = ""
+        for rel in cdata.get("relationships") or []:
+            rel_suffix += f"  → {rel['to_table']}.{rel['to_column']}"
+        typer.echo(f"  {cname}  {ctype}{suffix}{rel_suffix}")
+    for ref in data.get("referenced_by") or []:
+        typer.echo(f"  ← {ref['from_table']}.{ref['from_column']}")
+    for hop in data.get("linked_via") or []:
+        typer.echo(
+            f"  via {hop['through_column_a']} → {hop['hop_table_a']},"
+            f" via {hop['through_column_b']} → {hop['hop_table_b']}"
+        )
+
+
+def _echo_column(label: str, data: dict[str, Any]) -> None:
+    typer.echo(f"Column: {label}")
+    ctype = data.get("type") or data.get("actual_type")
+    if ctype:
+        typer.echo(f"  type: {ctype}")
+    if (sem := data.get("semantic_type")) is not None:
+        typer.echo(f"  semantic_type: {sem}")
+    if (dist := data.get("distribution")) is not None:
+        typer.echo(f"  distribution: {dist}")
+    if (dc := data.get("distinct_count")) is not None:
+        typer.echo(f"  distinct_count: {dc}")
+    if (np := data.get("null_percentage")) is not None:
+        typer.echo(f"  null_pct: {np:.1f}%")
+    for rel in data.get("relationships") or []:
+        typer.echo(f"  → {rel['to_table']}.{rel['to_column']}")