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

{sql_code_graph-1.35.2.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.2
+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.2.dist-info → sql_code_graph-1.36.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sqlcg/__init__.py,sha256=sSDhQAnJp2faEog8JFBrO4lRnTvl7Wgp2Wx6TVXKHr8,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
@@ -34,7 +34,7 @@ sqlcg/indexer/__init__.py,sha256=Wh20Unz2OHs1oIyWLrpurPAasF0BET2g4iXtNk7mh2U,56
 sqlcg/indexer/dbt_adapter.py,sha256=EB5x1WU5Z9d-I97ADDj88S_hG1C4z4nbrv8JUCzXfy8,686
 sqlcg/indexer/error_classify.py,sha256=-sp8cRmuOBHu_CxnCtaXf34YxHFYwIFNjIrn4LaEv6M,7142
 sqlcg/indexer/git_delta.py,sha256=zYdH5q-jV7w_ne8Oxdywsy0N3rwUjpd5RjEDurlrMSA,5026
-sqlcg/indexer/indexer.py,sha256=u6fIhgLfBs9fKJoAyO4hJrm9152YMe08EHycncctQx8,102697
+sqlcg/indexer/indexer.py,sha256=LNc5pI3_WwIMT2iTnCu9VB1Kk21T1qAmN7fupyiQu2s,105315
 sqlcg/indexer/pool.py,sha256=iMmCQtpDRKBTQBep2_EUq9THcsE18Zgk0hdaFB_CwiA,19006
 sqlcg/indexer/walker.py,sha256=Cft6JiJtdBFy0HR6L9pJdr5Fg0eRR3XBW1OMtM2apto,1947
 sqlcg/indexer/watcher.py,sha256=mJQq1LASRLKKwhz0WhCUWPLLqyPR2_-FD_8efYU6gE8,8442
@@ -46,11 +46,11 @@ sqlcg/metrics/store.py,sha256=KuDtxvyAgug9_KtiSCpvgKM2VZM7VSaI3D11uMLjJJk,10604
 sqlcg/parsers/__init__.py,sha256=AamA8wBbDZV9_zEtZCI4Hyen5UAVKHmBwjTghTt2PZE,785
 sqlcg/parsers/ansi_parser.py,sha256=RX6eVj7gt1qmsHNJLAF_a4jyW3RCI5W2oF4rd53cKNg,39336
 sqlcg/parsers/base.py,sha256=d5s5_LSv96jrww9vx52GujjrLHwpxy_UOhmIlWcKglw,106489
-sqlcg/parsers/bigquery_parser.py,sha256=mOnWTfXB_Dp4JwFE1PVYOB6CDPf5nYE0Dea8kJCl9uQ,2827
+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.2.dist-info/METADATA,sha256=JWm-CPL2l16Ckt8gzIULybRvhwHgd8H4v4WxoWdNsIs,17791
-sql_code_graph-1.35.2.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-sql_code_graph-1.35.2.dist-info/entry_points.txt,sha256=Wfe49sVzV9p4eVFGo5RxcV-frr3HOP0yzzst8JBxQLQ,46
-sql_code_graph-1.35.2.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.2"
+__version__ = "1.36.0"
 
 __all__ = ["__version__"]

sqlcg/indexer/indexer.py

@@ -388,7 +388,7 @@ def _flush_row_batch(
     )
 
 
-def _subprocess_parse_worker(parser_cls, dialect, path, sql, q):
+def _subprocess_parse_worker(parser_cls, dialect, path, sql, q, rel_path=None):
     """Parse a single file in a subprocess; queue the ParsedFile (or exception).
 
     parser_cls must be the *class* (pickleable), not an instance. The worker
@@ -398,10 +398,16 @@ def _subprocess_parse_worker(parser_cls, dialect, path, sql, q):
     T-09-04: Parser constructors require a SchemaResolver. The subprocess gets a
     fresh empty resolver; column resolution runs in infer-only mode, the same as
     small-repo mode.
+
+    #171: rel_path is the repo-relative posix path used for CTE/temp namespace
+    keying.  It MUST be forwarded so the incremental path produces the same keys
+    as index_repo (which threads rel_path through its task dict); without it the
+    namespace falls back to the absolute OS path, creating duplicate CTE/temp
+    nodes after an incremental reindex.
     """
     try:
         parser = parser_cls(SchemaResolver(dialect=str(dialect) if dialect else None))
-        out = parser.parse_file(path, sql)
+        out = parser.parse_file(path, sql, rel_path=rel_path)
         q.put(out)
     except BaseException as exc:
         # Send the exception back; parent will re-raise.
@@ -1129,6 +1135,22 @@ class Indexer:
         schema_resolver = SchemaResolver(dialect=dialect)
         parser = get_parser(dialect, schema_resolver)
 
+        # #170/#171: load schema_aliases and compute repo-relative posix paths the
+        # SAME way index_repo does, so the incremental path applies the same alias
+        # normalisation (#170) and CTE/temp namespace keys (#171).  Without these,
+        # a branch-switch resync produced phantom *_tmp.* nodes (aliases unapplied)
+        # and duplicate CTE/temp nodes (absolute-path keys).
+        from sqlcg.core.config import get_schema_aliases
+
+        schema_aliases = get_schema_aliases(root)
+        root_resolved = Path(root).resolve()
+
+        def _rel_posix(fp: Path) -> str:
+            try:
+                return fp.resolve().relative_to(root_resolved).as_posix()
+            except ValueError:
+                return fp.as_posix()
+
         pass1_results: list[ParsedFile] = []
         for file_path in reparse_set:
             try:
@@ -1141,7 +1163,9 @@ class Indexer:
                 pass1_results.append(placeholder)
                 continue
             try:
-                parsed = self._index_single_file(parser, file_path, sql, timeout_per_file)
+                parsed = self._index_single_file(
+                    parser, file_path, sql, timeout_per_file, rel_path=_rel_posix(file_path)
+                )
             except Exception as exc:
                 logger.warning("resync_changed: parse failed %s: %s", file_path, exc)
                 parsed = ParsedFile(path=file_path, dialect=dialect)
@@ -1287,7 +1311,11 @@ class Indexer:
                         def_path = Path(definer_fp)
                         def_sql = def_path.read_text(encoding="utf-8")
                         def_parsed = self._index_single_file(
-                            parser, def_path, def_sql, timeout_per_file
+                            parser,
+                            def_path,
+                            def_sql,
+                            timeout_per_file,
+                            rel_path=_rel_posix(def_path),
                         )
                         # Harvest only — register for cross_file_sources but do NOT upsert
                         aggregator.register_pass1(def_parsed)
@@ -1315,7 +1343,7 @@ class Indexer:
                 )
                 continue
             try:
-                cl_parsed = parser.parse_file(cl_path, cl_sql)
+                cl_parsed = parser.parse_file(cl_path, cl_sql, rel_path=_rel_posix(cl_path))
             except Exception as exc:
                 logger.warning("resync_changed: parse failed for closure file %s: %s", cl_path, exc)
                 cl_parsed = ParsedFile(path=cl_path, dialect=dialect)
@@ -1325,7 +1353,19 @@ class Indexer:
         # ---- Step 7: Batched bulk upsert (same _flush_batch path as index_repo) ----
         all_results = pass1_results + closure_results
 
-        # Build a registry for duplicate DDL detection
+        # #170: key-normalisation choke point — apply schema_aliases + empty-identity
+        # guard to EVERY parse result BEFORE the defined_table_registry is built and
+        # before _upsert_file_batch.  index_repo (line ~797) and reindex_file
+        # (line ~1421) both do this; resync_changed previously did not, so a
+        # branch-switch incremental reindex left staging-alias schemas (e.g. ba_tmp)
+        # un-normalised, producing phantom *_tmp.* nodes that a from-scratch index
+        # never creates.  O(edges) per file, once per resync — outside the hot loop.
+        from sqlcg.parsers.base import normalize_keys as _normalize_keys
+
+        for pf in all_results:
+            _normalize_keys(pf, schema_aliases)
+
+        # Build a registry for duplicate DDL detection (post-normalisation full_ids)
         defined_table_registry: dict[str, str] = {}
         for pf in all_results:
             for table in pf.defined_tables:
@@ -1432,7 +1472,14 @@ class Indexer:
         # join-column edges until the next full index (plan-review BLOCKER).
         self._resolve_join_columns(db)
 
-    def _index_single_file(self, parser, path: Path, sql: str, timeout: int) -> ParsedFile:
+    def _index_single_file(
+        self,
+        parser,
+        path: Path,
+        sql: str,
+        timeout: int,
+        rel_path: str | None = None,
+    ) -> ParsedFile:
         """Parse one file, with optional timeout via subprocess isolation.
 
         T-09-04: Subprocess isolation via multiprocessing.Process + spawn context.
@@ -1446,12 +1493,17 @@ class Indexer:
             path: Path to the file
             sql: SQL text
             timeout: Timeout in seconds (0 = no timeout)
+            rel_path: Repo-relative posix path for CTE/temp namespace keying
+                (#171).  Threaded through to parse_file (both the in-process and
+                subprocess branch) so the incremental path produces the same
+                namespace keys as index_repo.  Falls back to str(path) inside the
+                parser when None.
 
         Returns:
             ParsedFile with parse_failed flag set if timeout occurs
         """
         if timeout <= 0:
-            return parser.parse_file(path, sql)
+            return parser.parse_file(path, sql, rel_path=rel_path)
 
         ctx = mp.get_context("spawn")  # avoid fork-inherit pitfalls (KuzuDB connection FD etc.)
         # Unbounded queue: the child writes one large ParsedFile (192–552 KB pickled).
@@ -1462,7 +1514,7 @@ class Indexer:
         q: mp.Queue = ctx.Queue()
         proc = ctx.Process(
             target=_subprocess_parse_worker,
-            args=(parser.__class__, parser.DIALECT, path, sql, q),
+            args=(parser.__class__, parser.DIALECT, path, sql, q, rel_path),
             daemon=True,
         )
         proc.start()

sqlcg/parsers/bigquery_parser.py

@@ -35,12 +35,16 @@ class BigQueryParser(AnsiParser):
         """
         super().__init__(schema_resolver, schema_aliases=schema_aliases)
 
-    def parse_file(self, path: Path, sql: str) -> ParsedFile:
+    def parse_file(self, path: Path, sql: str, rel_path: str | None = None) -> ParsedFile:
         """Parse BigQuery SQL file with scripting block detection.
 
         Args:
             path: Path to the source file
             sql: SQL text to parse
+            rel_path: Repo-relative posix path for CTE/temp namespace keying.
+                Accepted for signature parity with the other parsers (the pool and
+                resync paths always pass it); scripting-fallback BigQuery files do
+                not register CTE/temp nodes, so it is currently unused here.
 
         Returns:
             ParsedFile with parsed statements and metadata

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``.