sql-code-graph 1.35.3__py3-none-any.whl → 1.36.1__py3-none-any.whl

{sql_code_graph-1.35.3.dist-info → sql_code_graph-1.36.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-code-graph
-Version: 1.35.3
+Version: 1.36.1
 Summary: SQL code graph analyzer and lineage tracer
 Project-URL: Homepage, https://github.com/Warhorze/sql-code-graph
 Project-URL: Repository, https://github.com/Warhorze/sql-code-graph
@@ -85,7 +85,8 @@ for that project.
 
 1. **Initialize**: `sqlcg db init`
 2. **Index**: `sqlcg index ./sql --dialect snowflake`
-3. **Keep fresh**: `sqlcg git install-hooks` (optional)
+3. **Keep fresh**: `sqlcg git install-hooks` (auto-reindex on branch switch), or
+   `sqlcg watch ./sql` to re-index automatically as you edit files (both optional)
 
 ## Full setup (recommended)
 
@@ -303,7 +304,8 @@ sqlcg analyze empty-impact <table>...  # downstream blast radius when named tabl
 sqlcg analyze pr-impact --base <ref>   # detect producers a PR dropped + their blast radius (code-regression detection)
 sqlcg analyze upstream/downstream      # trace lineage from the CLI
 sqlcg find table/column/pattern        # search the graph
-sqlcg watch <path>                     # watch for file changes
+sqlcg watch <path>                     # watch a directory and re-index on SQL file changes
+sqlcg viz                              # generate a self-contained graph-explorer HTML
 sqlcg db info                          # graph stats + freshness (indexed SHA vs HEAD)
 sqlcg git install-hooks                # install post-checkout + post-merge resync hooks
 sqlcg gain                             # show usage metrics
@@ -316,7 +318,7 @@ sqlcg mcp restart                      # stop the server (client must respawn it
 sqlcg version                          # show installed version
 ```
 
-### Staying on the latest build (v1.5.0)
+### Staying on the latest build
 
 The installed package, the CLI, and the running MCP server all report the **same**
 version (`sqlcg.__version__`). After upgrading, an editor may still be talking to an
@@ -325,7 +327,7 @@ server's `version` and a `stale_by_version` flag that is `true` when the live se
 differs from the installed build. Re-running `sqlcg install` stops the stale server so
 your editor respawns it on the new build, so you never debug against an outdated server.
 
-### Reads while the server is running (v1.2.0)
+### Reads while the server is running
 
 DuckDB takes an exclusive lock on the database file, so while the MCP server is
 live it holds that lock (other processes cannot open the file, even read-only).
@@ -336,6 +338,34 @@ running they open the database directly, exactly as before. If the server is
 mid-reindex the read waits for it to finish rather than failing with
 "Database is locked".
 
+### Visualising the graph (`viz`)
+
+`sqlcg viz` generates a **self-contained graph-explorer HTML** from the live
+graph — every node, edge, the force-graph library, and the facet data are inlined
+into a single file, so it opens by double-click in a browser with no server or
+external resources.
+
+```bash
+sqlcg viz                              # writes table_graph.html in the current dir
+sqlcg viz --out lineage.html           # choose the output path
+```
+
+In the browser the filter composes schema ∩ kind ∩ tag (multi-select per facet)
+plus a job dropdown; an edge renders only when both endpoints are visible. Table,
+view, and temp nodes are on by default; CTE and derived nodes are off (toggleable).
+
+Two optional CSV facets let you colour and slice the graph by your own
+conventions — both are `pattern,label[,color]` with a required header, patterns
+are case-insensitive `fnmatch` globs (`*`, `?`) matched against the qualified
+table name:
+
+```bash
+sqlcg viz --tags tags.csv              # legend swatches: colour + filter the graph
+sqlcg viz --jobs jobs.csv              # populate the job dropdown (filter only)
+```
+
+Omit `--tags` to hide the tag legend; omit `--jobs` to leave the dropdown empty.
+
 ## Supported dialects
 
 sqlcg is built on [sqlglot](https://github.com/tobymao/sqlglot), so other dialects

{sql_code_graph-1.35.3.dist-info → sql_code_graph-1.36.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sqlcg/__init__.py,sha256=iuiB1QBl9EVtoW0aNt89z6gr_yDaZ5RV7phaFO8zX0Y,116
+sqlcg/__init__.py,sha256=1pTarvYKeyADzesOkchbID_Tn8DRtdOiq2qMb535jXQ,116
 sqlcg/__main__.py,sha256=1YoFLcqEgTwYq1J3TbUwpkdG0zeeLIf2fJvwWI-CLFU,109
 sqlcg/cli/__init__.py,sha256=W8fD0LpMq2xm_5WKGNMvJh2WBL1ho5E8hUeAqXQYT1g,28
 sqlcg/cli/coverage.py,sha256=Xm9ITzZDHv2mJ70Q5jCacVuhDStVrE3gq12_-Ypvtd8,43823
@@ -49,8 +49,8 @@ sqlcg/parsers/base.py,sha256=d5s5_LSv96jrww9vx52GujjrLHwpxy_UOhmIlWcKglw,106489
 sqlcg/parsers/bigquery_parser.py,sha256=g0B6aIpMyxLMVQ3ohAAjzR4nEmMh-WGkFcYLMiKdLxs,3177
 sqlcg/parsers/dynamic_name.py,sha256=q0QAa9iAcmRW4e_0G2b2j-xTbI3VR1-Wwa-nJRLtrQw,6836
 sqlcg/parsers/postgres_parser.py,sha256=lYfUpQY6j4Qm7ndXBtXbgPoGzYqYddWt5YeFnWKdA6I,946
-sqlcg/parsers/registry.py,sha256=LXy1F6rqQI6VdxpRvZg_tNpoEucW3mXZHYBMlMONbX4,1496
-sqlcg/parsers/snowflake_parser.py,sha256=cv7bzBm6Wmwa8uY41Y59ebfFjnP1Gk0Sjp2KN_QBGD8,47542
+sqlcg/parsers/registry.py,sha256=Ur-J8_CVvW05aYthGqN-LhEcIoBwcekubAGxQ8SerRw,1761
+sqlcg/parsers/snowflake_parser.py,sha256=Egg2CkfnAxcr6_yB83uIx1YePKB1w61egP_NeyhzWo4,53059
 sqlcg/parsers/tsql_parser.py,sha256=RRj1pACtAk2tLTDaFWRYF67a0IDvaf5A1YQXWIz0bpQ,956
 sqlcg/server/__init__.py,sha256=n4wuNE7xyJIJxJZBtmtdccCMQfvTdF-IqIaZVbC4FC4,35
 sqlcg/server/control.py,sha256=qUcztb_aDhL-_X_Nq4q6uGx17cUlbLnI6vUpoZsEjbo,4506
@@ -73,7 +73,7 @@ sqlcg/viz/render.py,sha256=BINkGbJbbb_iqhrkN795RaQsdg8nqCiJtsEFF1yo22Y,2737
 sqlcg/viz/tags.py,sha256=6zRnGlHjuGmEeB6yN1uhzm8rqL7ZGoyL1Ki7jI5oM6A,5368
 sqlcg/viz/assets/force-graph.min.js,sha256=jNdYdDdrYiUdUlElxRkolPBt30rstQk2q15Q32VVdzc,177272
 sqlcg/viz/assets/template.html,sha256=9_j-mvo1ZxwgiJPDdVrNmca37dTrTjjYVd3977u-DxE,12294
-sql_code_graph-1.35.3.dist-info/METADATA,sha256=bR0GUYuujbDEYNj4602aE5Olejev4X6hp7KYlaezZjg,17791
-sql_code_graph-1.35.3.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-sql_code_graph-1.35.3.dist-info/entry_points.txt,sha256=Wfe49sVzV9p4eVFGo5RxcV-frr3HOP0yzzst8JBxQLQ,46
-sql_code_graph-1.35.3.dist-info/RECORD,,
+sql_code_graph-1.36.1.dist-info/METADATA,sha256=NR-127QkvaJ20LcGYPpd2HRAhZPDXHAPUdjNc0kmp6M,19208
+sql_code_graph-1.36.1.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+sql_code_graph-1.36.1.dist-info/entry_points.txt,sha256=Wfe49sVzV9p4eVFGo5RxcV-frr3HOP0yzzst8JBxQLQ,46
+sql_code_graph-1.36.1.dist-info/RECORD,,

sqlcg/__init__.py

@@ -1,5 +1,5 @@
 """SQL Code Graph - SQL lineage and dependency analysis tool."""
 
-__version__ = "1.35.3"
+__version__ = "1.36.1"
 
 __all__ = ["__version__"]

sqlcg/parsers/registry.py

@@ -1,6 +1,6 @@
 """Parser registry and factory for dialect-specific SQL parsers."""
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, TypeVar
 
 if TYPE_CHECKING:
     from sqlcg.lineage.schema_resolver import SchemaResolver
@@ -9,6 +9,8 @@ if TYPE_CHECKING:
 # Global registry of dialect -> parser class mapping
 PARSERS: dict[str | None, type["SqlParser"]] = {}
 
+_ParserT = TypeVar("_ParserT", bound="type[SqlParser]")
+
 
 def register(dialect: str | None):
     """Decorator to register a parser class for a dialect.
@@ -17,10 +19,12 @@ def register(dialect: str | None):
         dialect: SQL dialect identifier (None for ANSI, "snowflake", etc.)
 
     Returns:
-        Decorator function
+        Decorator function. It returns the decorated class *unchanged* and with its
+        concrete type preserved, so dialect-specific static methods (e.g.
+        ``SnowflakeParser.is_dynamic_name_sink``) remain accessible to type checkers.
     """
 
-    def decorator(cls: type["SqlParser"]) -> type["SqlParser"]:
+    def decorator(cls: _ParserT) -> _ParserT:
         PARSERS[dialect] = cls
         return cls
 

sqlcg/parsers/snowflake_parser.py

@@ -10,6 +10,7 @@ import sqlglot.expressions as exp
 from sqlcg.lineage.schema_resolver import SchemaResolver
 from sqlcg.parsers.ansi_parser import AnsiParser
 from sqlcg.parsers.base import ParsedFile, ParseQuality
+from sqlcg.parsers.dynamic_name import resolve_dynamic_name
 from sqlcg.parsers.registry import register
 from sqlcg.utils.logging import getLogger
 
@@ -356,12 +357,34 @@ class SnowflakeParser(AnsiParser):
         # `EXECUTE IMMEDIATE (:var)` Command node below can resolve its inner literal.
         # Only single-string-literal RHS values are captured (the statically-recoverable
         # case); a concatenation / CONCAT / bind-var RHS is not a literal and is skipped.
+        #
+        # Generic-var-name resolution (PR-2): build a SECOND, additive map ``var_rhs``
+        # holding the full RHS *AST* (not just literal strings) for both ``var := <expr>``
+        # (exp.PropertyEQ) and ``SET var = <expr>`` (exp.Set) assignments. The fold core
+        # (``resolve_dynamic_name``) runs on these ASTs on demand from an IDENTIFIER($var)
+        # sink. ``var_literals`` stays intact and literal-only — the EXECUTE IMMEDIATE
+        # path below still consumes it, and must not be regressed by this addition.
+        # Last-write-wins in file source order (plan §var-pre-scan).
         var_literals: dict[str, str] = {}
+        var_rhs: dict[str, exp.Expression] = {}  # type: ignore[attr-defined]
         for stmt in statements:
-            if isinstance(stmt, exp.PropertyEQ) and isinstance(stmt.expression, exp.Literal):
-                lit = stmt.expression
-                if lit.is_string and stmt.this is not None and stmt.this.name:
-                    var_literals[stmt.this.name.lower()] = str(lit.this)
+            if isinstance(stmt, exp.PropertyEQ):
+                if stmt.this is not None and stmt.this.name and stmt.expression is not None:
+                    var_rhs[stmt.this.name.lower()] = stmt.expression
+                    if isinstance(stmt.expression, exp.Literal) and stmt.expression.is_string:
+                        var_literals[stmt.this.name.lower()] = str(stmt.expression.this)
+            elif isinstance(stmt, exp.Set):
+                for item in stmt.expressions:
+                    if not isinstance(item, exp.SetItem):
+                        continue
+                    eq = item.this
+                    if (
+                        isinstance(eq, exp.EQ)
+                        and eq.this is not None
+                        and eq.this.name
+                        and eq.expression is not None
+                    ):
+                        var_rhs[eq.this.name.lower()] = eq.expression
 
         for stmt in statements:
             if stmt is None:
@@ -419,10 +442,20 @@ class SnowflakeParser(AnsiParser):
 
             # PR-6 Phase 1: a `var := '<literal>'` assignment is a scripting-variable
             # binding, not a query — suppress it (mirrors the USE-statement suppression).
+            # NOTE (PR-2): the `SET var = <expr>` form (exp.Set) is NOT suppressed — it
+            # flows through as an OTHER-kind statement (existing parse-classification
+            # contract, test_set_session_variable_not_parse_failed). Its RHS was already
+            # captured in var_rhs above for IDENTIFIER($var) resolution; suppressing it
+            # would regress that contract for no benefit.
             if isinstance(stmt, exp.PropertyEQ):
                 result.append(None)
                 continue
 
+            # Generic-var-name resolution (PR-2): rewrite IDENTIFIER($var) table sinks
+            # to their resolved [db.]name BEFORE qualification, so a catalog-less resolved
+            # tail still inherits the active USE SCHEMA prefix from _qualify_bare_tables.
+            self._resolve_identifier_tables(stmt, var_rhs)
+
             # Qualify bare table references in this statement if we have a schema context.
             if current_schema:
                 self._qualify_bare_tables(stmt, current_schema)
@@ -431,6 +464,83 @@ class SnowflakeParser(AnsiParser):
 
         return result
 
+    @staticmethod
+    def is_dynamic_name_sink(table: Any) -> Any:
+        """Return the ``$var`` Parameter if ``table`` is ``IDENTIFIER($var)``, else None.
+
+        Snowflake's ``IDENTIFIER()`` is the dynamic-name sink. In a table position it
+        parses to an ``exp.Table`` whose ``.this`` is an ``exp.Anonymous`` named
+        ``IDENTIFIER`` wrapping a single ``exp.Parameter`` (the session ``$var``).
+
+        The IDENTIFIER name is matched **case-insensitively** — sqlglot emits the
+        function name UPPERCASE (``IDENTIFIER``), so a literal lowercase compare would
+        match nothing and every dynamic-name test would silently pass as a no-op
+        (plan gate-correction (b)).
+
+        This is the SOLE dialect-coupled piece of generic var-name resolution. Non-DML
+        IDENTIFIER uses (``ALTER WAREHOUSE IDENTIFIER($w)``, ``CALL p($t)``) parse to
+        ``exp.Command`` and never produce an ``exp.Table``, so they are auto-excluded —
+        no name blocklist is needed (plan §sink-predicate).
+
+        Args:
+            table: an ``exp.Table`` candidate sink.
+
+        Returns:
+            The wrapped ``exp.Parameter`` (the ``$var``) when ``table`` is
+            ``IDENTIFIER($var)``; ``None`` otherwise.
+        """
+        anon = getattr(table, "this", None)
+        if not isinstance(anon, exp.Anonymous):
+            return None
+        if (anon.name or "").lower() != "identifier":
+            return None
+        args = anon.expressions
+        if len(args) != 1:
+            return None
+        param = args[0]
+        if not isinstance(param, exp.Parameter):
+            return None
+        return param
+
+    def _resolve_identifier_tables(
+        self,
+        stmt: Any,
+        var_rhs: dict[str, exp.Expression],  # type: ignore[attr-defined]
+    ) -> None:
+        """In-place: rewrite ``IDENTIFIER($var)`` table sinks to their resolved TableRef.
+
+        Demand-driven, once per statement (no qualify/expand/sg_lineage): walk this
+        statement's ``exp.Table`` sinks, and for each ``IDENTIFIER($var)`` sink look the
+        ``$var`` RHS AST up in ``var_rhs`` and fold it with the dialect-agnostic core
+        (``resolve_dynamic_name``, chain_depth=1). On a resolved ``exp.Table`` replace the
+        sink in place, preserving the original alias. On an honest give-up (``None``) leave
+        the IDENTIFIER sink untouched (dropped, as today). See plan §wiring.
+
+        Args:
+            stmt: sqlglot AST node to mutate in place.
+            var_rhs: lowercased var name -> its RHS AST (pre-scanned this file).
+        """
+        if not isinstance(stmt, exp.Expression):  # type: ignore[attr-defined]
+            return
+        for table in stmt.find_all(exp.Table):
+            param = self.is_dynamic_name_sink(table)
+            if param is None:
+                continue
+            var_name = param.name
+            if not var_name:
+                continue
+            rhs = var_rhs.get(var_name.lower())
+            if rhs is None:
+                continue
+            resolved = resolve_dynamic_name(rhs, var_rhs, chain_depth=1)
+            if resolved is None:
+                continue
+            # Preserve the original alias (FROM/INSERT alias survives the rewrite).
+            alias = table.args.get("alias")
+            if alias is not None:
+                resolved.set("alias", alias)
+            table.replace(resolved)
+
     @staticmethod
     def _qualify_bare_tables(stmt: Any, schema: str) -> None:
         """In-place: prefix all bare (no db/catalog) exp.Table refs with ``schema``.