sql-code-graph 1.0.2__py3-none-any.whl → 1.1.0__py3-none-any.whl

sqlcg/cli/commands/mcp.py

@@ -71,3 +71,106 @@ def mcp_best_practices() -> None:
     from sqlcg.server.skill import render_body
 
     typer.echo(render_body())
+
+
+@app.command("status")
+def mcp_status() -> None:
+    """Print server status JSON (connects to control socket).
+
+    Returns JSON with fields: running, pid, db_path, indexed_sha, head_sha,
+    stale_by_commits, connected_clients, uptime when a server is live.
+
+    When no server is found: {"running": false}.
+    When the PID file exists with a live process but the socket is unavailable:
+    {"running": true, "degraded": "socket unavailable", ...}.
+
+    R3 (stale socket): if the socket file exists but the server is not
+    responding (ConnectionRefusedError / FileNotFoundError), falls through
+    to the PID-file probe — never hangs or errors on a dead socket.
+    """
+    import socket as _socket
+
+    from sqlcg.server.control import is_pid_alive, read_pid, sock_path
+
+    sp = sock_path()
+    try:
+        with _socket.socket(_socket.AF_UNIX, _socket.SOCK_STREAM) as s:
+            s.settimeout(2)
+            s.connect(str(sp))
+            s.sendall(json.dumps({"op": "status"}).encode() + b"\n")
+            data = s.recv(4096)
+        console.print_json(data.decode())
+    except (FileNotFoundError, ConnectionRefusedError, OSError):
+        # Socket unavailable — probe via PID file (R3: stale-socket fall-through)
+        rec = read_pid()
+        if rec and is_pid_alive(rec["pid"]):
+            console.print_json(
+                json.dumps(
+                    {
+                        "running": True,
+                        "degraded": "socket unavailable",
+                        "pid": rec["pid"],
+                        "db_path": rec["db_path"],
+                    }
+                )
+            )
+        else:
+            console.print_json(json.dumps({"running": False}))
+
+
+@app.command("stop")
+def mcp_stop() -> None:
+    """Stop the running MCP server gracefully.
+
+    Sends a ``stop`` op via the control socket; waits up to 5 s for the
+    socket file to disappear (confirming clean exit).  Falls back to SIGTERM
+    on the PID-file PID if the socket is unavailable.
+
+    R3 (stale socket): ``ConnectionRefusedError`` / ``FileNotFoundError`` are
+    caught — never hangs on a dead socket.
+    """
+    import socket as _socket
+    import time
+
+    from sqlcg.server.control import is_pid_alive, read_pid, sock_path
+
+    sp = sock_path()
+    try:
+        with _socket.socket(_socket.AF_UNIX, _socket.SOCK_STREAM) as s:
+            s.settimeout(2)
+            s.connect(str(sp))
+            s.sendall(json.dumps({"op": "stop"}).encode() + b"\n")
+            s.recv(128)
+        # Wait up to 5 s for the socket file to disappear (confirms clean exit)
+        for _ in range(10):
+            if not sp.exists():
+                break
+            time.sleep(0.5)
+        console.print("[green]Server stopped.[/green]")
+    except (FileNotFoundError, ConnectionRefusedError, OSError):
+        # Socket unavailable — fall back to SIGTERM via PID file
+        import signal
+
+        rec = read_pid()
+        if rec and is_pid_alive(rec["pid"]):
+            os.kill(rec["pid"], signal.SIGTERM)
+            console.print(f"[yellow]Socket unavailable — sent SIGTERM to PID {rec['pid']}[/yellow]")
+        else:
+            console.print("[yellow]No server found to stop.[/yellow]")
+
+
+@app.command("restart")
+def mcp_restart() -> None:
+    """Stop the server. The client (editor) must respawn.
+
+    v1.1 cannot re-parent an editor-spawned stdio process.  This command
+    stops the current server and prints guidance for the user to restart
+    the MCP server via their editor's MCP configuration.
+
+    True auto-restart (re-parenting stdio) is deferred to v1.2.
+    """
+    mcp_stop()
+    console.print(
+        "[yellow]Server stopped. Please restart via your editor's MCP configuration.[/yellow]"
+    )
+    console.print("[dim]True auto-restart (re-parenting stdio) is deferred to v1.2.[/dim]")

sqlcg/cli/commands/reindex.py

@@ -18,6 +18,12 @@ from rich.console import Console
 
 console = Console()
 
+# Client-side socket timeout for the --notify control-socket path.
+# A real DWH server-side resync_changed measured ~89 s (41 changed files + closure);
+# 300 s covers that with headroom while keeping the wait bounded on a wedged server.
+# This is a CLI transport bound, NOT a KuzuConfig/indexer constant.
+_NOTIFY_SOCKET_TIMEOUT_S = 300
+
 
 def reindex_cmd(  # noqa: B008
     path: Path = typer.Argument(..., help="Repository root directory to resync"),  # noqa: B008
@@ -39,10 +45,18 @@ def reindex_cmd(  # noqa: B008
         help="Files per KuzuDB transaction (same default as index command)",
     ),
     timeout_per_file: int = typer.Option(  # noqa: B008
-        5,
+        10,
         "--timeout-per-file",
         help="Per-file parse timeout in seconds",
     ),
+    notify: bool = typer.Option(  # noqa: B008
+        False,
+        "--notify",
+        help=(
+            "If a server is live on this DB, route the reindex through the server "
+            "(avoids lock contention). Falls back to direct write if no server is found."
+        ),
+    ),
 ) -> None:
     """Incrementally resync the graph after a git branch change or pull.
 
@@ -56,17 +70,99 @@ def reindex_cmd(  # noqa: B008
     Exits with an error if the database schema version does not match the current
     build — run 'sqlcg db reset && sqlcg db init && sqlcg index <path>' to re-init.
     """
-    from sqlcg.core.config import get_backend, get_db_path, get_dialect
+    import json
+    import socket as _socket
+
+    from sqlcg.core.config import config_file_present, get_backend, get_db_path, get_dialect
     from sqlcg.core.schema import SCHEMA_VERSION
     from sqlcg.indexer.indexer import Indexer
+    from sqlcg.server.control import sock_path
 
     # Resolve to absolute path so ignore-spec and git delta receive an absolute root
     path = path.resolve()
 
+    # --notify: if a server is live, route reindex through the socket (R3 fallback)
+    if notify:
+        sp = sock_path()
+        try:
+            with _socket.socket(_socket.AF_UNIX, _socket.SOCK_STREAM) as s:
+                s.settimeout(_NOTIFY_SOCKET_TIMEOUT_S)
+                s.connect(str(sp))
+                # Resolve SHAs before sending — standalone mode reads from DB via socket
+                effective_from = from_sha
+                if effective_from is None:
+                    # Standalone mode: we cannot read stored SHA here without opening the
+                    # DB (which would conflict with the running server).  If no --from is
+                    # given with --notify, we send from="stored" as a sentinel and fall
+                    # back to direct write; the caller should pass --from explicitly.
+                    raise OSError(  # noqa: TRY301
+                        "--notify without --from requires direct DB access; falling through"
+                    )
+                # Resolve symbolic refs (HEAD, branch names) to concrete 40-char SHAs
+                # before sending — prevents literal "HEAD" from being stored in the graph.
+                effective_from = _resolve_ref(path, effective_from)
+                effective_to = _resolve_ref(path, to_sha) if to_sha else _get_head(path)
+                payload = {
+                    "op": "reindex",
+                    "root": str(path),
+                    "from": effective_from,
+                    "to": effective_to,
+                    "dialect": dialect,
+                }
+                s.sendall(json.dumps(payload).encode() + b"\n")
+                data = s.recv(65536)
+            result = json.loads(data)
+            if "error" in result:
+                console.print(f"[red]Server reindex error: {result['error']}[/red]")
+                raise typer.Exit(1)
+            if not quiet:
+                srv_summary = result.get("summary", {})
+                console.print(
+                    f"[green]Resynced via server[/green] "
+                    f"+{srv_summary.get('added', 0)} added, "
+                    f"~{srv_summary.get('modified', 0)} modified, "
+                    f"-{srv_summary.get('deleted', 0)} deleted"
+                )
+            raise typer.Exit(0)
+        except TimeoutError:
+            # Bug 1 fix: server is alive and working (accepted the connection, holds the
+            # lock, will finish and persist).  Do NOT fall through to the direct-write
+            # path — that would hit the held lock and produce a false "Database is locked"
+            # error.  Exit 0 so the git hook stays non-fatal; the server will complete.
+            # (socket.timeout is an alias of TimeoutError, a subclass of OSError — this
+            # clause must be listed before the broad OSError clause below.)
+            import sys
+
+            print(
+                f"Server is still applying the reindex (timed out waiting after "
+                f"{_NOTIFY_SOCKET_TIMEOUT_S}s); the graph will update when it finishes "
+                f"— check 'sqlcg mcp status'.",
+                file=sys.stderr,
+            )
+            raise typer.Exit(0) from None
+        except (FileNotFoundError, ConnectionRefusedError, OSError):
+            # R3: no live server (stale socket, socket absent, fallback condition) —
+            # fall through to the existing direct-write path unchanged.
+            # NOTE: socket.timeout / TimeoutError is an OSError subclass, so the
+            # dedicated timeout clause above must be listed first (already is).
+            pass
+        except typer.Exit:
+            raise
+        except Exception as exc:
+            console.print(f"[red]--notify routing failed: {exc}[/red]")
+            raise typer.Exit(1) from exc
+
     # Resolve dialect
     if dialect == "auto":
         dialect = get_dialect(path)
 
+    if not quiet and not config_file_present(path):
+        console.print(
+            f"[yellow]No .sqlcg.toml found at {path}/.sqlcg.toml — "
+            "using defaults (snowflake dialect, no aliases/prefixes). "
+            "Create .sqlcg.toml in the index directory to customise.[/yellow]"
+        )
+
     db_path = get_db_path()
     db_path.parent.mkdir(parents=True, exist_ok=True)
 
@@ -88,15 +184,17 @@ def reindex_cmd(  # noqa: B008
 
         # ---- Determine mode -------------------------------------------------------
         if from_sha is not None:
-            # Explicit-SHA mode
-            effective_to = to_sha or _get_head(path)
+            # Explicit-SHA mode — resolve symbolic refs to concrete SHAs before storing
+            effective_from = _resolve_ref(path, from_sha)
+            effective_to = _resolve_ref(path, to_sha) if to_sha else _get_head(path)
             if not quiet:
                 console.print(
-                    f"Resyncing [cyan]{path}[/cyan] [dim]{from_sha[:8]}..{effective_to[:8]}[/dim]"
+                    f"Resyncing [cyan]{path}[/cyan] "
+                    f"[dim]{effective_from[:8]}..{effective_to[:8]}[/dim]"
                 )
             summary = indexer.resync_changed(
                 path,
-                from_sha,
+                effective_from,
                 effective_to,
                 backend,
                 dialect,
@@ -150,24 +248,36 @@ def reindex_cmd(  # noqa: B008
                 )
 
 
-def _get_head(root: Path) -> str:
-    """Return the current HEAD SHA for the git repo at root.
+def _resolve_ref(root: Path, ref: str) -> str:
+    """Resolve a git ref (HEAD, branch, tag, or concrete SHA) to a 40-char SHA.
 
-    Raises typer.Exit(1) if git is unavailable or root is not a git repo.
+    A concrete SHA resolves to itself (idempotent), so callers may pass either a
+    symbolic ref or a SHA without branching.
+
+    Raises typer.Exit(1) if git is unavailable or the ref cannot be resolved.
     """
     try:
         result = subprocess.run(
-            ["git", "rev-parse", "HEAD"],
+            ["git", "rev-parse", ref],
             cwd=str(root),
             capture_output=True,
             text=True,
         )
         if result.returncode != 0:
             console.print(
-                f"[red]Could not determine HEAD SHA in {root}: {result.stderr.strip()}[/red]"
+                f"[red]Could not resolve ref '{ref}' in {root}: {result.stderr.strip()}[/red]"
             )
             raise typer.Exit(1)
         return result.stdout.strip()
     except FileNotFoundError:
-        console.print("[red]git is not available — cannot determine HEAD SHA[/red]")
+        console.print("[red]git is not available — cannot resolve ref[/red]")
         raise typer.Exit(1) from None
+
+
+def _get_head(root: Path) -> str:
+    """Return the current HEAD SHA for the git repo at root.
+
+    Delegates to _resolve_ref so there is one git-rev-parse code path.
+    Raises typer.Exit(1) if git is unavailable or root is not a git repo.
+    """
+    return _resolve_ref(root, "HEAD")

sqlcg/core/config.py

@@ -71,6 +71,21 @@ def get_db_path() -> Path:
     return KuzuConfig.from_env().db_path
 
 
+def config_file_present(path: Path) -> bool:
+    """Return True when a .sqlcg.toml file exists at the given directory.
+
+    Single source of truth for the config filename so callers never hard-code
+    ".sqlcg.toml" independently.
+
+    Args:
+        path: Directory to check for .sqlcg.toml
+
+    Returns:
+        True if path/.sqlcg.toml exists, False otherwise.
+    """
+    return (Path(path) / ".sqlcg.toml").exists()
+
+
 def get_dialect(path: Path) -> str:
     """Get the SQL dialect from .sqlcg.toml or fall back to snowflake.
 
@@ -266,6 +281,71 @@ def get_presentation_prefixes(path: Path) -> list[str]:
     return []
 
 
+class ExternalConsumerSpec(BaseModel):
+    """Specification for a single external downstream consumer declared in .sqlcg.toml."""
+
+    name: str
+    consumer_type: str
+    consumes: list[str]
+
+
+def get_external_consumers(path: Path) -> list[ExternalConsumerSpec]:
+    """Get external downstream consumer declarations from .sqlcg.toml.
+
+    Reads [[sqlcg.external_consumers]] array-of-tables from .sqlcg.toml. Each
+    table must have ``name`` and ``consumes`` (non-empty list). Rows without a
+    ``name`` or with an empty ``consumes`` list are silently skipped. The
+    ``kind`` field is stored as ``consumer_type`` (lowercased). **Defaults to an
+    empty list** when the section is absent — when unset, the ingestion pass is a
+    no-op (correct generic behaviour for any user). No hardcoded fallback::
+
+        [[sqlcg.external_consumers]]
+        name = "Tableau: Sales Dashboard"
+        kind = "tableau"
+        consumes = ["ia_sales.fct_orders"]
+
+    Args:
+        path: Root directory to search for .sqlcg.toml
+
+    Returns:
+        List of ExternalConsumerSpec objects. Defaults to an empty list.
+    """
+    config_file = Path(path) / ".sqlcg.toml"
+    if config_file.exists():
+        try:
+            with open(config_file, "rb") as f:
+                config = tomllib.load(f)
+            raw = config.get("sqlcg", {}).get("external_consumers", [])
+            if not isinstance(raw, list):
+                return []
+            specs: list[ExternalConsumerSpec] = []
+            for entry in raw:
+                if not isinstance(entry, dict):
+                    continue
+                name = entry.get("name", "")
+                if not name or not isinstance(name, str):
+                    continue
+                consumes_raw = entry.get("consumes", [])
+                if not isinstance(consumes_raw, list) or not consumes_raw:
+                    continue
+                consumes = [c.lower() for c in consumes_raw if isinstance(c, str)]
+                if not consumes:
+                    continue
+                kind = entry.get("kind", "")
+                consumer_type = kind.lower() if isinstance(kind, str) else ""
+                specs.append(
+                    ExternalConsumerSpec(
+                        name=name,
+                        consumer_type=consumer_type,
+                        consumes=consumes,
+                    )
+                )
+            return specs
+        except Exception:
+            pass
+    return []
+
+
 def get_backend() -> "GraphBackend":
     """Get a graph backend instance respecting the SQLCG_BACKEND env var.
 

sqlcg/core/freshness.py

@@ -0,0 +1,134 @@
+"""Shared freshness helper — computes indexed-vs-HEAD delta for any repo root.
+
+This module is deliberately free of backend imports so it can be unit-tested
+with only a real git repo and no KuzuDB instance.  Callers obtain the
+``indexed_sha`` from the backend and pass it in.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class Freshness:
+    """Snapshot of how fresh the indexed graph is relative to the current HEAD."""
+
+    indexed_sha: str | None
+    """Git SHA recorded at the last successful index run (from SchemaVersion)."""
+
+    head_sha: str | None
+    """Current HEAD SHA of the repo at *root*. None when root is not a git repo."""
+
+    stale_by_commits: int | None
+    """How many commits HEAD is ahead of *indexed_sha*.
+
+    - ``0``  → graph is up to date.
+    - ``N>0`` → graph is N commits behind HEAD.
+    - ``None`` → distance is unknown (indexed SHA not in history, shallow clone,
+      or git unavailable).
+    """
+
+    dirty: bool
+    """True when the working tree contains uncommitted changes (whole-tree check)."""
+
+    branch: str | None
+    """Current branch name (``git rev-parse --abbrev-ref HEAD``), or None."""
+
+
+# ---------------------------------------------------------------------------
+# Internal git helper
+# ---------------------------------------------------------------------------
+
+
+def _git(root: Path, *args: str) -> str | None:
+    """Run a git command; return stdout stripped, or None on any failure.
+
+    Never raises — on any subprocess error or non-zero exit code, returns None.
+    """
+    try:
+        r = subprocess.run(
+            ["git", *args],
+            cwd=str(root),
+            capture_output=True,
+            text=True,
+        )
+        return r.stdout.strip() if r.returncode == 0 else None
+    except Exception:
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def compute_freshness(root: Path, indexed_sha: str | None) -> Freshness:
+    """Compute freshness relative to the git repo at *root*.
+
+    Returns a :class:`Freshness` with all-None/False fields when *root* is not
+    a git repo or git is unavailable — **never raises**.
+
+    Args:
+        root: Filesystem path used as the ``cwd`` for git commands.  This is
+            typically the ``r.path`` value read from the ``Repo`` graph node.
+        indexed_sha: The SHA recorded by ``KuzuBackend.get_indexed_sha()``.
+            May be ``None`` when the graph was never indexed, or a sentinel
+            like ``"<head>+dirty"`` written by ``index --include-working-tree``.
+    """
+    head = _git(root, "rev-parse", "HEAD")
+    branch = _git(root, "rev-parse", "--abbrev-ref", "HEAD")
+    dirty_out = _git(root, "status", "--porcelain")
+    dirty = bool(dirty_out)
+
+    stale: int | None = None
+    if head and indexed_sha:
+        if indexed_sha == head:
+            stale = 0
+        else:
+            raw = _git(root, "rev-list", "--count", f"{indexed_sha}..{head}")
+            if raw is not None:
+                try:
+                    stale = int(raw)
+                except ValueError:
+                    stale = None
+            # If indexed_sha is unknown (rebased/shallow), raw is None → stale stays None
+
+    return Freshness(
+        indexed_sha=indexed_sha,
+        head_sha=head,
+        stale_by_commits=stale,
+        dirty=dirty,
+        branch=branch,
+    )
+
+
+def render_freshness_line(f: Freshness) -> str:
+    """Return a one-line human summary of graph freshness.
+
+    Examples::
+
+        "indexed at abc12345 (up to date)"
+        "indexed at abc12345 (2 commit(s) behind HEAD)"
+        "indexed at abc12345 (2 commit(s) behind HEAD, working tree dirty)"
+        "indexed at abc12345 (commit distance unknown (SHA not in history))"
+        "freshness: not available (graph was never indexed from a git repo)"
+    """
+    if f.indexed_sha is None:
+        return "freshness: not available (graph was never indexed from a git repo)"
+
+    parts: list[str] = []
+    if f.stale_by_commits is None:
+        parts.append("commit distance unknown (SHA not in history)")
+    elif f.stale_by_commits == 0:
+        parts.append("up to date")
+    else:
+        parts.append(f"{f.stale_by_commits} commit(s) behind HEAD")
+    if f.dirty:
+        parts.append("working tree dirty")
+
+    summary = ", ".join(parts)
+    sha8 = f.indexed_sha[:8]
+    return f"indexed at {sha8} ({summary})"

sqlcg/core/graph_db.py

@@ -204,6 +204,8 @@ class GraphBackend(ABC):
                 return "path"
             case NodeLabel.TABLE:
                 return "qualified"
+            case NodeLabel.EXTERNAL_CONSUMER:
+                return "name"
             case _:
                 return "id"
 

sqlcg/core/queries.cypher

@@ -13,17 +13,17 @@ DETACH DELETE t
 -- DELETE_FILE
 MATCH (f:File {path: $path}) DETACH DELETE f
 
--- STALE_VIEWS
-MATCH (f:File {path: $path})<-[:DEFINED_IN]-(t:SqlTable)
-<-[:SELECTS_FROM]-(q:SqlQuery)-[:DECLARES]->(v:SqlTable {kind: 'VIEW'})
-RETURN DISTINCT v.qualified AS view_name
-
 -- INDEX_REPO_FILES
 MATCH (f:File) WHERE f.path STARTS WITH $repo_prefix RETURN f.path AS path
 
 -- TRACE_COLUMN_LINEAGE
 MATCH (dst:SqlColumn {id: $id})<-[r:COLUMN_LINEAGE]-(src:SqlColumn)
-RETURN src.id AS id, src.col_name AS col_name, src.table_qualified AS table_qualified, r.transform AS transform, r.confidence AS confidence
+OPTIONAL MATCH (q:SqlQuery {id: r.query_id})
+OPTIONAL MATCH (t:SqlTable {qualified: src.table_qualified})
+RETURN src.id AS id, src.col_name AS col_name, src.table_qualified AS table_qualified,
+       r.transform AS transform, r.confidence AS confidence,
+       q.file_path AS file, q.start_line AS line, q.sql AS expression,
+       t.kind AS table_kind
 
 -- FIND_TABLE_USAGES
 MATCH (t:SqlTable {name: $name})<-[:SELECTS_FROM]-(q:SqlQuery)
@@ -38,6 +38,12 @@ RETURN dst.id AS id, dst.col_name AS col_name, dst.table_qualified AS table_qual
 MATCH (dst:SqlColumn {id: $id})<-[:COLUMN_LINEAGE]-(src:SqlColumn)
 RETURN src.id AS id, src.col_name AS col_name, src.table_qualified AS table_qualified
 
+-- GET_UPSTREAM_DEPENDENCIES_FILTERED
+MATCH (dst:SqlColumn {id: $id})<-[:COLUMN_LINEAGE]-(src:SqlColumn)
+MATCH (t:SqlTable {qualified: src.table_qualified})
+WHERE t.kind IN ['table', 'external']
+RETURN src.id AS id, src.col_name AS col_name, src.table_qualified AS table_qualified
+
 -- SEARCH_SQL_PATTERN
 MATCH (q:SqlQuery)-[:QUERY_DEFINED_IN]->(f:File)
 WHERE contains(q.sql, $query)
@@ -112,3 +118,15 @@ LIMIT $k
 UNWIND $tables AS tbl
 MATCH (t:SqlTable {qualified: tbl})<-[:SELECTS_FROM]-(q:SqlQuery)-[:QUERY_DEFINED_IN]->(f:File)
 RETURN DISTINCT f.path AS path
+
+-- GET_TABLE_EXTERNAL_CONSUMERS
+MATCH (t:SqlTable {qualified: $table_qualified})-[:CONSUMED_BY]->(e:ExternalConsumer)
+RETURN e.name AS name, e.consumer_type AS consumer_type
+
+-- GET_TABLES_EXTERNAL_CONSUMERS_BATCH
+UNWIND $table_qualifieds AS tq
+MATCH (t:SqlTable {qualified: tq})-[:CONSUMED_BY]->(e:ExternalConsumer)
+RETURN tq AS table_qualified, e.name AS name, e.consumer_type AS consumer_type
+
+-- COUNT_EXTERNAL_CONSUMERS
+MATCH ()-[r:CONSUMED_BY]->() RETURN count(r) AS n

sqlcg/core/queries.py

@@ -23,12 +23,12 @@ DELETE_COLUMNS_FOR_FILE = _Q["DELETE_COLUMNS_FOR_FILE"]
 DELETE_QUERIES_FOR_FILE = _Q["DELETE_QUERIES_FOR_FILE"]
 DELETE_TABLES_FOR_FILE = _Q["DELETE_TABLES_FOR_FILE"]
 DELETE_FILE = _Q["DELETE_FILE"]
-STALE_VIEWS_QUERY = _Q["STALE_VIEWS"]
 INDEX_REPO_FILES_QUERY = _Q["INDEX_REPO_FILES"]
 TRACE_COLUMN_LINEAGE_QUERY = _Q["TRACE_COLUMN_LINEAGE"]
 FIND_TABLE_USAGES_QUERY = _Q["FIND_TABLE_USAGES"]
 GET_DOWNSTREAM_DEPENDENCIES_QUERY = _Q["GET_DOWNSTREAM_DEPENDENCIES"]
 GET_UPSTREAM_DEPENDENCIES_QUERY = _Q["GET_UPSTREAM_DEPENDENCIES"]
+GET_UPSTREAM_DEPENDENCIES_FILTERED_QUERY = _Q["GET_UPSTREAM_DEPENDENCIES_FILTERED"]
 SEARCH_SQL_PATTERN_QUERY = _Q["SEARCH_SQL_PATTERN"]
 LIST_DIALECTS_AND_REPOS_QUERY = _Q["LIST_DIALECTS_AND_REPOS"]
 EXPAND_STAR_SOURCES_QUERY = _Q["EXPAND_STAR_SOURCES"]
@@ -42,3 +42,6 @@ GET_TABLES_DEFINED_IN_FILE_QUERY = _Q["GET_TABLES_DEFINED_IN_FILE"]
 ANALYZE_UNUSED_TABLES_QUERY = _Q["ANALYZE_UNUSED_TABLES"]
 HUB_RANKING_QUERY = _Q["HUB_RANKING"]
 DEPENDENT_FILES_OF_TABLES_QUERY = _Q["DEPENDENT_FILES_OF_TABLES"]
+GET_TABLE_EXTERNAL_CONSUMERS_QUERY = _Q["GET_TABLE_EXTERNAL_CONSUMERS"]
+GET_TABLES_EXTERNAL_CONSUMERS_BATCH_QUERY = _Q["GET_TABLES_EXTERNAL_CONSUMERS_BATCH"]
+COUNT_EXTERNAL_CONSUMERS_QUERY = _Q["COUNT_EXTERNAL_CONSUMERS"]

sqlcg/core/schema.cypher

@@ -44,7 +44,8 @@ CREATE NODE TABLE SqlQuery (
     target_table STRING,
     parse_failed BOOLEAN,
     confidence FLOAT,
-    parsing_mode STRING
+    parsing_mode STRING,
+    start_line INT64
 );
 
 -- File -> Repo: file belongs to this repository
@@ -114,3 +115,14 @@ CREATE NODE TABLE SchemaVersion (
     version STRING PRIMARY KEY,
     indexed_sha STRING
 );
+
+-- External consumer node: one per declared downstream consumer in .sqlcg.toml
+CREATE NODE TABLE ExternalConsumer (
+    name STRING PRIMARY KEY,
+    consumer_type STRING
+);
+
+-- Table -> ExternalConsumer: this table is consumed by an external system
+CREATE REL TABLE CONSUMED_BY (
+    FROM SqlTable TO ExternalConsumer
+);

sqlcg/core/schema.py

@@ -3,7 +3,7 @@
 from enum import StrEnum
 from importlib.resources import files
 
-SCHEMA_VERSION = "4"
+SCHEMA_VERSION = "6"
 
 
 class NodeLabel(StrEnum):
@@ -13,6 +13,7 @@ class NodeLabel(StrEnum):
     COLUMN = "SqlColumn"
     QUERY = "SqlQuery"
     SCHEMA_VERSION = "SchemaVersion"
+    EXTERNAL_CONSUMER = "ExternalConsumer"
 
 
 class RelType(StrEnum):
@@ -27,6 +28,7 @@ class RelType(StrEnum):
     COLUMN_LINEAGE = "COLUMN_LINEAGE"
     DECLARES = "DECLARES"
     STAR_SOURCE = "STAR_SOURCE"
+    CONSUMED_BY = "CONSUMED_BY"
 
 
 # Backward-compatible aliases
@@ -36,6 +38,7 @@ NODE_TABLE = NodeLabel.TABLE
 NODE_COLUMN = NodeLabel.COLUMN
 NODE_QUERY = NodeLabel.QUERY
 NODE_SCHEMA_VERSION = NodeLabel.SCHEMA_VERSION
+NODE_EXTERNAL_CONSUMER = NodeLabel.EXTERNAL_CONSUMER
 
 REL_DEFINED_IN = RelType.DEFINED_IN
 REL_HAS_COLUMN = RelType.HAS_COLUMN
@@ -45,5 +48,6 @@ REL_DELETES_FROM = RelType.DELETES_FROM
 REL_UPDATES = RelType.UPDATES
 REL_COLUMN_LINEAGE = RelType.COLUMN_LINEAGE
 REL_DECLARES = RelType.DECLARES
+REL_CONSUMED_BY = RelType.CONSUMED_BY
 
 SCHEMA_DDL: str = files("sqlcg.core").joinpath("schema.cypher").read_text(encoding="utf-8")