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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-code-graph
-Version: 1.35.2
+Version: 1.35.3
 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.35.3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sqlcg/__init__.py,sha256=sSDhQAnJp2faEog8JFBrO4lRnTvl7Wgp2Wx6TVXKHr8,116
+sqlcg/__init__.py,sha256=iuiB1QBl9EVtoW0aNt89z6gr_yDaZ5RV7phaFO8zX0Y,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,7 +46,7 @@ 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
@@ -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.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,,

sqlcg/__init__.py

@@ -1,5 +1,5 @@
 """SQL Code Graph - SQL lineage and dependency analysis tool."""
 
-__version__ = "1.35.2"
+__version__ = "1.35.3"
 
 __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