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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-code-graph
-Version: 1.35.3
+Version: 1.36.0
 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

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

@@ -1,4 +1,4 @@
-sqlcg/__init__.py,sha256=iuiB1QBl9EVtoW0aNt89z6gr_yDaZ5RV7phaFO8zX0Y,116
+sqlcg/__init__.py,sha256=XPECmPOL0Clmm8vi1OTnN9oS6T6x-udm0Qb_r_tQoEA,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.0.dist-info/METADATA,sha256=qmHQutd2-IfpHk1ETAPDISdRiprgHJSe8DvFQokUOa8,17791
+sql_code_graph-1.36.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+sql_code_graph-1.36.0.dist-info/entry_points.txt,sha256=Wfe49sVzV9p4eVFGo5RxcV-frr3HOP0yzzst8JBxQLQ,46
+sql_code_graph-1.36.0.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.0"
 
 __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``.