sql-code-graph 1.1.3__py3-none-any.whl → 1.2.2__py3-none-any.whl

{sql_code_graph-1.1.3.dist-info → sql_code_graph-1.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-code-graph
-Version: 1.1.3
+Version: 1.2.2
 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
@@ -267,6 +267,16 @@ sqlcg mcp restart                      # stop the server (client must respawn it
 sqlcg version                          # show installed version
 ```
 
+### Reads while the server is running (v1.2.0)
+
+KuzuDB allows a single writer, so while the MCP server is live it holds the
+database lock. CLI **read** commands (`find`, `analyze`, `db info`, `list-repos`,
+`gain`) automatically route their query through the running server over its
+control socket and return rows as usual — no flag, no config. When no server is
+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".
+
 ## Supported dialects
 
 sqlcg is built on [sqlglot](https://github.com/tobymao/sqlglot), so other dialects

{sql_code_graph-1.1.3.dist-info → sql_code_graph-1.2.2.dist-info}/RECORD

@@ -1,12 +1,12 @@
-sqlcg/__init__.py,sha256=YGDRrWVIrONmQholAKWh6hSKxlPd2dLcM1AdHHdBhEA,115
+sqlcg/__init__.py,sha256=6jzbRxs0WG3Yq2KYIDG9bagxRZvhbhp6agviO4_nXwM,115
 sqlcg/__main__.py,sha256=1YoFLcqEgTwYq1J3TbUwpkdG0zeeLIf2fJvwWI-CLFU,109
 sqlcg/cli/__init__.py,sha256=W8fD0LpMq2xm_5WKGNMvJh2WBL1ho5E8hUeAqXQYT1g,28
 sqlcg/cli/main.py,sha256=WmdTjsOlz1ozi2Y3Aq4ezR_FCRl-Lc1YOKw3_d48dlY,1650
 sqlcg/cli/commands/__init__.py,sha256=oSHtr6VD-jNubOjuCQyZj2tBppjMEpQDh-IGQ8of9eA,30
-sqlcg/cli/commands/analyze.py,sha256=hiKj0R1m5i4ZmwrXBlVT14xGy6rs9jmv_ZDCLVZj4Tg,14282
-sqlcg/cli/commands/db.py,sha256=5VpknLqYaimK6YA516w6iQVX6JmHcD52o6MuW5d088c,7462
-sqlcg/cli/commands/find.py,sha256=SsK6q4YRPknrz_lIQ4Gun6HRoAdoVRGClwAYdm_s2OU,3168
-sqlcg/cli/commands/gain.py,sha256=hz36QmuaXJXutI4vyNMDfcNsBeLTXa6EOw2bWe2AhTQ,8939
+sqlcg/cli/commands/analyze.py,sha256=xr3RHmO4eFTP4VKZn4DAx3BJzSi60_DIZmdE-QLfsHI,13601
+sqlcg/cli/commands/db.py,sha256=iUPnSxkSjt2EZzj_zmXiIyM39NTTCpazD4Y8Q9iPZEc,7725
+sqlcg/cli/commands/find.py,sha256=zTYN9goILalYq4R9x6lIR6MmNcydDbR17UXkx1gPRsI,2913
+sqlcg/cli/commands/gain.py,sha256=Kws76u1na2XxmbWN_YWrPaYHYmYBLC6DDDf7xqnltqc,9126
 sqlcg/cli/commands/git.py,sha256=yMgWOuoTCTBr2P1QgmghRi5ikmUYHuxDUVyBDYerErw,5728
 sqlcg/cli/commands/index.py,sha256=xMnxKDiUt5LH_3lKAotoRctL4VSOvcw7Gq--idLPtm0,11091
 sqlcg/cli/commands/install.py,sha256=KNABvrLbamPyYnmnVdCaM_MNezbDc-pr6IkignCWI8k,9186
@@ -16,7 +16,7 @@ sqlcg/cli/commands/report.py,sha256=JU0qjyMxwOukE7bN3XvvIzOI7zMg_Gsnvk_8F6pKNpA,
 sqlcg/cli/commands/uninstall.py,sha256=IYwQaqnMmmzW0Nlls40wD-L3tVkMgKIMRXUkcXPMUc4,9398
 sqlcg/cli/commands/watch.py,sha256=7N6c-QuvxAEGHzDZ0C3CU2BkHSraZW9YtgoFnz7SaQo,2373
 sqlcg/core/__init__.py,sha256=uNsJCrCMVWVT80sHPtI_f39BYqIf5N0i6LSq8x8HsyI,283
-sqlcg/core/config.py,sha256=LuB8HWPsIt1OsjOshTT1bJdXWXN01w76ABl9M-VB9DM,14777
+sqlcg/core/config.py,sha256=qNR-yXkfYfS8Y8WX4Qo6Zkq8PPP_ZiTrvX0DLmEZkGY,14821
 sqlcg/core/freshness.py,sha256=gRb8pRPw5SdIUxAYkMXIJ00DTdQ6CegRZPAvWnv0rU0,4575
 sqlcg/core/graph_db.py,sha256=Aa85wPFg26H-Ud9SrZyxCHH-99iitAI5S3X9T_62Yyw,7957
 sqlcg/core/jobs.py,sha256=Je-fCdSKRgiSsv1W8SgNAlp36a7t7-pJZ-qKPbka9OE,3298
@@ -30,17 +30,17 @@ sqlcg/indexer/__init__.py,sha256=Wh20Unz2OHs1oIyWLrpurPAasF0BET2g4iXtNk7mh2U,56
 sqlcg/indexer/dbt_adapter.py,sha256=EB5x1WU5Z9d-I97ADDj88S_hG1C4z4nbrv8JUCzXfy8,686
 sqlcg/indexer/error_classify.py,sha256=MYjPVprwT-ARPjBCyCzu2F9DSrZfnTVtVIoBgm8s4H8,5329
 sqlcg/indexer/git_delta.py,sha256=P-QM4vnVURT2KLiE6u3cQynRUF-mTH13cbB4I20YHPQ,4468
-sqlcg/indexer/indexer.py,sha256=KyyowxiSNU3Gm4JE-mj8gVm6D80XERJPd-he59I2sIk,62018
+sqlcg/indexer/indexer.py,sha256=7TCgBLl3ml3mF8Z2q4YHZJ6HdxSuLH-rPJTibnUJUe4,66658
 sqlcg/indexer/pool.py,sha256=BTYx-pBe6zwUG89MHh0X7nzGNVlsHN-GjovYKanVI1s,18553
 sqlcg/indexer/walker.py,sha256=umNaqDbuerr75VYG1TEOv0ATsbI40O3SIw35f7XJcDE,1931
 sqlcg/indexer/watcher.py,sha256=mJQq1LASRLKKwhz0WhCUWPLLqyPR2_-FD_8efYU6gE8,8442
 sqlcg/lineage/__init__.py,sha256=Da1DlYwtK13WHv_RnHjAtNkHTOuFbhxqCjT1Le7DsWM,46
-sqlcg/lineage/aggregator.py,sha256=G1xsTjf981EVSgN1yIHcC_ecDvcTcSPvEp6Kb2HPXkY,4943
+sqlcg/lineage/aggregator.py,sha256=LVyNcmvLBHWbh8SrDsJJBKd7sLg3-2NhEWwEndG7Jbc,4144
 sqlcg/lineage/schema_resolver.py,sha256=iXt6LYF6UVWsGUpcfbmjmGn9wCgXl721lTGf_8AaWcc,7320
 sqlcg/metrics/__init__.py,sha256=hLJ6wm4St8qqYwKh3o9QG7lcEt1BEYM31ccqO9tGpIg,133
 sqlcg/metrics/store.py,sha256=BaMf7QYTmYMlX_Jzi1GNU8R2sMVkWdn07f-ZSndtcNk,8879
 sqlcg/parsers/__init__.py,sha256=AamA8wBbDZV9_zEtZCI4Hyen5UAVKHmBwjTghTt2PZE,785
-sqlcg/parsers/ansi_parser.py,sha256=tu1MWWaSYmpefKjgk2PPyGStIFjV47Z_1WjyBh5Zi2c,17180
+sqlcg/parsers/ansi_parser.py,sha256=mGZvijMOMQ4i1BybpwU29a8jnIGViefhy9fxzkSpsRM,17193
 sqlcg/parsers/base.py,sha256=IiOkVsm6jz9-48RqDCXiW-UXAraNxQ4pKXvSA7aolnA,49907
 sqlcg/parsers/bigquery_parser.py,sha256=mOnWTfXB_Dp4JwFE1PVYOB6CDPf5nYE0Dea8kJCl9uQ,2827
 sqlcg/parsers/postgres_parser.py,sha256=lYfUpQY6j4Qm7ndXBtXbgPoGzYqYddWt5YeFnWKdA6I,946
@@ -52,14 +52,15 @@ sqlcg/server/control.py,sha256=v-r21npODiHlHnJHuo_6KWrKclQKq_E1QyrzIWjqgtY,4508
 sqlcg/server/exceptions.py,sha256=EONw34icOByCTpppSQrvQBW6asc4hfqaGDCAFjv96II,469
 sqlcg/server/models.py,sha256=l7ORy6sbtzBW1y3qVaeLwEukbyAgBkz9S5VIm2q4b24,19378
 sqlcg/server/noise_filter.py,sha256=idSBGgdKWWccJdpOo9qgbM2350Oew-2l5W6Yc9GYQqY,6337
-sqlcg/server/server.py,sha256=gzeO5WbSNfGxgIKte01uy0VjO1_basI2ChSuAwr0dBc,14844
+sqlcg/server/read_client.py,sha256=ncoJK7UckGhWtN9bv1CgViNMNtac96zBUE7RPYQ8_WI,7783
+sqlcg/server/server.py,sha256=QBb7N4lc5o7KBh1Ik6MAiOvBV8SW81ahtkM1ZOVuyXE,18983
 sqlcg/server/skill.py,sha256=GE8eeimk6yiGGJ74erGypqYAviur5peSR6_2a4QQWVM,12828
 sqlcg/server/tools.py,sha256=JvijDC0h5uHjZyZUIZq9sztNG3W5sr-Yy5rHwOVuJec,66642
 sqlcg/utils/__init__.py,sha256=--iqt5ThTXmT8Wz7da8hs3n0zDfYPl8P-z5OgRJ_77E,154
 sqlcg/utils/hashing.py,sha256=H25-sYfxHKb3_IERFnHyAIYNiXN470Oqo5sJT_D3YOA,438
 sqlcg/utils/ignore.py,sha256=wJjwa0mjnQ_xJExOUxk25y00g065XmmzJapqV3ifD5o,1151
 sqlcg/utils/logging.py,sha256=u0fCmYsLj9o81vawm3xZTHaw68GQYVm7JxG-gP81u8A,840
-sql_code_graph-1.1.3.dist-info/METADATA,sha256=Z_aRnsDOgZ_ngAHkIr3x2XpEjF-x6UMUQwcIkAMlGjo,13615
-sql_code_graph-1.1.3.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sql_code_graph-1.1.3.dist-info/entry_points.txt,sha256=Wfe49sVzV9p4eVFGo5RxcV-frr3HOP0yzzst8JBxQLQ,46
-sql_code_graph-1.1.3.dist-info/RECORD,,
+sql_code_graph-1.2.2.dist-info/METADATA,sha256=e4llIRyH4QYoHbIznQIpZ_wreqsuscvDzuLBVQBv33M,14148
+sql_code_graph-1.2.2.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+sql_code_graph-1.2.2.dist-info/entry_points.txt,sha256=Wfe49sVzV9p4eVFGo5RxcV-frr3HOP0yzzst8JBxQLQ,46
+sql_code_graph-1.2.2.dist-info/RECORD,,

{sql_code_graph-1.1.3.dist-info → sql_code_graph-1.2.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.29.0
+Generator: hatchling 1.30.1
 Root-Is-Purelib: true
 Tag: py3-none-any

sqlcg/__init__.py

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

sqlcg/cli/commands/analyze.py

@@ -8,9 +8,9 @@ import typer
 from rich.console import Console
 from rich.table import Table
 
-from sqlcg.core.config import get_backend
 from sqlcg.core.queries import GET_TABLE_EXTERNAL_CONSUMERS_QUERY
 from sqlcg.core.schema import NodeLabel, RelType
+from sqlcg.server.read_client import run_read_routed
 
 if TYPE_CHECKING:
     from sqlcg.server.noise_filter import NoiseFilter
@@ -19,26 +19,36 @@ app = typer.Typer(help="Lineage analysis")
 console = Console()
 
 
-def _kind_filter(source_alias: str, include_intermediate: bool) -> str:
-    """Build the Half-B (#38) kind filter for the lineage traversal query.
+def _kind_filter(node_alias: str, *, include_intermediate: bool) -> str:
+    """Build the SqlTable kind-filter clause for upstream/downstream queries.
 
-    When ``include_intermediate`` is False, the filter uses ``OPTIONAL MATCH`` plus
-    ``t.kind IS NULL OR t.kind IN ['table', 'external']`` so a source whose SqlTable
-    node is ABSENT (a CTE-body source on a graph indexed before the #39 fix, or not yet
-    re-indexed) is KEPT rather than silently dropped.  Reverting this to an inner
-    ``MATCH (t:SqlTable {...}) ... WHERE t.kind IN [...]`` is the #38 regression:
-    node-less physical sources vanish from results.
+    Uses an OPTIONAL MATCH + explicit ``WITH … WHERE t.kind IS NULL OR …`` form
+    (Half B of the #38/#39 fix) so that a node-less physical source — one whose
+    SqlTable node is absent because it was only seen inside a CTE body before
+    re-index — is KEPT, not dropped.  CTE/derived intermediates carry
+    ``kind='cte'`` or ``kind='derived'`` and are excluded by the
+    ``kind IN [...]`` guard; ``IS NULL`` matches the absent-node case (t = NULL
+    → t.kind = NULL → IS NULL is TRUE).
 
-    ``source_alias`` is ``src`` for upstream and ``dst`` for downstream — it names both
-    the node whose table is looked up and the variable carried through the WITH clause.
-    This is the single production source of the filter string; the #40 recall guard
-    imports it so reverting Half B here turns the guard red.
+    The ``WITH {node_alias}, t WHERE`` clause is required: an OPTIONAL MATCH
+    WHERE clause in KuzuDB applies to the match attempt and does not filter the
+    surrounding row.  The subsequent WITH … WHERE is the actual row filter.
+
+    Args:
+        node_alias: The Cypher alias for the column node whose table is filtered
+                    (``"src"`` for upstream, ``"dst"`` for downstream).
+        include_intermediate: When True, return an empty string (no filtering);
+                              all intermediates including CTE nodes are kept.
+
+    Returns:
+        A Cypher fragment string (with trailing space) to embed directly in the
+        query, or an empty string when include_intermediate is True.
     """
     if include_intermediate:
         return ""
     return (
-        f"OPTIONAL MATCH (t:SqlTable {{qualified: {source_alias}.table_qualified}}) "
-        f"WITH c, {source_alias}, t WHERE t.kind IS NULL OR t.kind IN ['table', 'external'] "
+        f"OPTIONAL MATCH (t:SqlTable {{qualified: {node_alias}.table_qualified}}) "
+        f"WITH {node_alias}, t WHERE t.kind IS NULL OR t.kind IN ['table', 'external'] "
     )
 
 
@@ -57,49 +67,46 @@ def upstream(  # noqa: B008
         console.print("[red]Error: --depth must be between 1 and 100[/red]")
         raise typer.Exit(1)
 
-    # By default, filter out CTE/derived intermediate nodes; --include-intermediate restores them.
-    # Half B (#38): use OPTIONAL MATCH so a missing SqlTable node (e.g. CTE-body source not yet
-    # re-indexed after #39 fix) is KEPT rather than silently dropped.  WHERE t.kind IS NULL OR
-    # t.kind IN [...] means: keep when node absent (NULL) OR when kind is a physical source.
-    # CTE aliases (kind='cte') and derived tables (kind='derived') are filtered out.
-    kind_filter = _kind_filter("src", include_intermediate)
-
-    with get_backend(read_only=True) as backend:
-        results = backend.run_read(
-            f"MATCH (c:{NodeLabel.COLUMN} {{id: $ref}})"
+    # By default, filter out CTE/derived intermediate nodes; --include-intermediate restores them
+    kf = _kind_filter("src", include_intermediate=include_intermediate)
+
+    results = run_read_routed(
+        f"MATCH (c:{NodeLabel.COLUMN} {{id: $ref}})"
+        f"<-[:{RelType.COLUMN_LINEAGE}*1..{depth}]-(src:{NodeLabel.COLUMN}) "
+        f"{kf}"
+        f"OPTIONAL MATCH (src)-[srcedge:{RelType.COLUMN_LINEAGE}]->() "
+        "OPTIONAL MATCH (q:SqlQuery {id: srcedge.query_id}) "
+        "WITH src, min(q.start_line) AS line, min(q.file_path) AS file "
+        "RETURN src.id AS id, file AS file, line AS line LIMIT 100",
+        {"ref": ref},
+    )
+    if not results and len(ref.split(".")) >= 3:
+        bare = _bare_ref(ref)
+        fallback_results = run_read_routed(
+            f"MATCH (c:{NodeLabel.COLUMN} {{id: $bare}})"
             f"<-[:{RelType.COLUMN_LINEAGE}*1..{depth}]-(src:{NodeLabel.COLUMN}) "
-            f"{kind_filter}"
-            f"OPTIONAL MATCH (src)-[direct:{RelType.COLUMN_LINEAGE}]->(c) "
-            "OPTIONAL MATCH (q:SqlQuery {id: direct.query_id}) "
-            "RETURN src.id AS id, q.file_path AS file, q.start_line AS line LIMIT 100",
-            {"ref": ref},
+            f"{kf}"
+            f"OPTIONAL MATCH (src)-[srcedge:{RelType.COLUMN_LINEAGE}]->() "
+            "OPTIONAL MATCH (q:SqlQuery {id: srcedge.query_id}) "
+            "WITH src, min(q.start_line) AS line, min(q.file_path) AS file "
+            "RETURN src.id AS id, file AS file, line AS line LIMIT 100",
+            {"bare": bare},
         )
-        if not results and len(ref.split(".")) >= 3:
-            bare = _bare_ref(ref)
-            fallback_results = backend.run_read(
-                f"MATCH (c:{NodeLabel.COLUMN} {{id: $bare}})"
-                f"<-[:{RelType.COLUMN_LINEAGE}*1..{depth}]-(src:{NodeLabel.COLUMN}) "
-                f"{kind_filter}"
-                f"OPTIONAL MATCH (src)-[direct:{RelType.COLUMN_LINEAGE}]->(c) "
-                "OPTIONAL MATCH (q:SqlQuery {id: direct.query_id}) "
-                "RETURN src.id AS id, q.file_path AS file, q.start_line AS line LIMIT 100",
-                {"bare": bare},
+        if fallback_results:
+            console.print(
+                f"[yellow]Hint:[/yellow] No results for '{ref}'. "
+                f"Found {len(fallback_results)} edge(s) under bare name '{bare}'. "
+                "The INSERT target may have been indexed without a schema prefix. "
+                "Multiple tables with the same unqualified name in different schemas "
+                "would all match — re-index with an explicit schema for precise results."
             )
-            if fallback_results:
-                console.print(
-                    f"[yellow]Hint:[/yellow] No results for '{ref}'. "
-                    f"Found {len(fallback_results)} edge(s) under bare name '{bare}'. "
-                    "The INSERT target may have been indexed without a schema prefix. "
-                    "Multiple tables with the same unqualified name in different schemas "
-                    "would all match — re-index with an explicit schema for precise results."
-                )
-                results = fallback_results
-        if not raw:
-            from sqlcg.server.noise_filter import NoiseFilter
-
-            nf = NoiseFilter.from_config()  # repo_root=None → falls back to Path.cwd()
-            results = _filter_column_results(results, nf)
-        _print_table(_add_file_line_col(results), ["id", "file:line"])
+            results = fallback_results
+    if not raw:
+        from sqlcg.server.noise_filter import NoiseFilter
+
+        nf = NoiseFilter.from_config()  # repo_root=None → falls back to Path.cwd()
+        results = _filter_column_results(results, nf)
+    _print_table(_add_file_line_col(results), ["id", "file:line"])
 
 
 @app.command("downstream")
@@ -117,72 +124,70 @@ def downstream(  # noqa: B008
         console.print("[red]Error: --depth must be between 1 and 100[/red]")
         raise typer.Exit(1)
 
-    # By default, filter out CTE/derived intermediate nodes; --include-intermediate restores them.
-    # Half B (#38): OPTIONAL MATCH keeps sources whose SqlTable node is absent (NULL) or is a
-    # physical kind.  WITH c, dst, t carries the three variables in scope at this interpolation
-    # point; direct and q are bound later in the query.
-    kind_filter = _kind_filter("dst", include_intermediate)
-
-    with get_backend(read_only=True) as backend:
-        results = backend.run_read(
-            f"MATCH (c:{NodeLabel.COLUMN} {{id: $ref}})"
+    # By default, filter out CTE/derived intermediate nodes; --include-intermediate restores them
+    kf = _kind_filter("dst", include_intermediate=include_intermediate)
+
+    results = run_read_routed(
+        f"MATCH (c:{NodeLabel.COLUMN} {{id: $ref}})"
+        f"-[:{RelType.COLUMN_LINEAGE}*1..{depth}]->(dst:{NodeLabel.COLUMN}) "
+        f"{kf}"
+        f"OPTIONAL MATCH ()-[dstedge:{RelType.COLUMN_LINEAGE}]->(dst) "
+        "OPTIONAL MATCH (q:SqlQuery {id: dstedge.query_id}) "
+        "WITH dst, min(q.start_line) AS line, min(q.file_path) AS file "
+        "RETURN dst.id AS id, file AS file, line AS line LIMIT 100",
+        {"ref": ref},
+    )
+    if not results and len(ref.split(".")) >= 3:
+        bare = _bare_ref(ref)
+        fallback_results = run_read_routed(
+            f"MATCH (c:{NodeLabel.COLUMN} {{id: $bare}})"
             f"-[:{RelType.COLUMN_LINEAGE}*1..{depth}]->(dst:{NodeLabel.COLUMN}) "
-            f"{kind_filter}"
-            f"OPTIONAL MATCH (c)-[direct:{RelType.COLUMN_LINEAGE}]->(dst) "
-            "OPTIONAL MATCH (q:SqlQuery {id: direct.query_id}) "
-            "RETURN dst.id AS id, q.file_path AS file, q.start_line AS line LIMIT 100",
-            {"ref": ref},
+            f"{kf}"
+            f"OPTIONAL MATCH ()-[dstedge:{RelType.COLUMN_LINEAGE}]->(dst) "
+            "OPTIONAL MATCH (q:SqlQuery {id: dstedge.query_id}) "
+            "WITH dst, min(q.start_line) AS line, min(q.file_path) AS file "
+            "RETURN dst.id AS id, file AS file, line AS line LIMIT 100",
+            {"bare": bare},
         )
-        if not results and len(ref.split(".")) >= 3:
-            bare = _bare_ref(ref)
-            fallback_results = backend.run_read(
-                f"MATCH (c:{NodeLabel.COLUMN} {{id: $bare}})"
-                f"-[:{RelType.COLUMN_LINEAGE}*1..{depth}]->(dst:{NodeLabel.COLUMN}) "
-                f"{kind_filter}"
-                f"OPTIONAL MATCH (c)-[direct:{RelType.COLUMN_LINEAGE}]->(dst) "
-                "OPTIONAL MATCH (q:SqlQuery {id: direct.query_id}) "
-                "RETURN dst.id AS id, q.file_path AS file, q.start_line AS line LIMIT 100",
-                {"bare": bare},
+        if fallback_results:
+            console.print(
+                f"[yellow]Hint:[/yellow] No results for '{ref}'. "
+                f"Found {len(fallback_results)} edge(s) under bare name '{bare}'. "
+                "The INSERT target may have been indexed without a schema prefix. "
+                "Multiple tables with the same unqualified name in different schemas "
+                "would all match — re-index with an explicit schema for precise results."
             )
-            if fallback_results:
-                console.print(
-                    f"[yellow]Hint:[/yellow] No results for '{ref}'. "
-                    f"Found {len(fallback_results)} edge(s) under bare name '{bare}'. "
-                    "The INSERT target may have been indexed without a schema prefix. "
-                    "Multiple tables with the same unqualified name in different schemas "
-                    "would all match — re-index with an explicit schema for precise results."
-                )
-                results = fallback_results
-        if not raw:
-            from sqlcg.server.noise_filter import NoiseFilter
-
-            nf = NoiseFilter.from_config()  # repo_root=None → falls back to Path.cwd()
-            results = _filter_column_results(results, nf)
-        _print_table(_add_file_line_col(results), ["id", "file:line"])
-
-        # Append external consumer rows for terminal tables (scalar query, one per terminal).
-        # Resolve terminal tables from the column results; fall back to the root column's table.
-        terminal_tables: set[str] = set()
-        for r in results:
-            tbl = _col_id_to_table(r["id"])
-            if tbl:
-                terminal_tables.add(tbl)
-        # Also check the root column's table (in case no downstream columns were found).
-        root_parts = ref.rsplit(".", 1)
-        if len(root_parts) == 2:
-            terminal_tables.add(root_parts[0])
-        consumer_rows: list[dict] = []
-        for tbl in sorted(terminal_tables):
-            rows_ec = backend.run_read(
-                GET_TABLE_EXTERNAL_CONSUMERS_QUERY,
-                {"table_qualified": tbl},
+            results = fallback_results
+    if not raw:
+        from sqlcg.server.noise_filter import NoiseFilter
+
+        nf = NoiseFilter.from_config()  # repo_root=None → falls back to Path.cwd()
+        results = _filter_column_results(results, nf)
+    _print_table(_add_file_line_col(results), ["id", "file:line"])
+
+    # Append external consumer rows for terminal tables (scalar query, one per terminal).
+    # Resolve terminal tables from the column results; fall back to the root column's table.
+    terminal_tables: set[str] = set()
+    for r in results:
+        tbl = _col_id_to_table(r["id"])
+        if tbl:
+            terminal_tables.add(tbl)
+    # Also check the root column's table (in case no downstream columns were found).
+    root_parts = ref.rsplit(".", 1)
+    if len(root_parts) == 2:
+        terminal_tables.add(root_parts[0])
+    consumer_rows: list[dict] = []
+    for tbl in sorted(terminal_tables):
+        rows_ec = run_read_routed(
+            GET_TABLE_EXTERNAL_CONSUMERS_QUERY,
+            {"table_qualified": tbl},
+        )
+        for ec in rows_ec:
+            consumer_rows.append(
+                {"id": f"[external] {ec['name']} ({ec['consumer_type']})", "file:line": ""}
             )
-            for ec in rows_ec:
-                consumer_rows.append(
-                    {"id": f"[external] {ec['name']} ({ec['consumer_type']})", "file:line": ""}
-                )
-        if consumer_rows:
-            _print_table(consumer_rows, ["id", "file:line"])
+    if consumer_rows:
+        _print_table(consumer_rows, ["id", "file:line"])
 
 
 @app.command("impact")
@@ -191,19 +196,18 @@ def impact(  # noqa: B008
     raw: bool = typer.Option(False, "--raw", help="Disable noise filtering on results"),  # noqa: B008
 ) -> None:
     """Show all queries impacted by a table."""
-    with get_backend(read_only=True) as backend:
-        results = backend.run_read(
-            f"MATCH (t:{NodeLabel.TABLE} {{qualified: $t}})"
-            f"<-[:{RelType.SELECTS_FROM}]-(q:{NodeLabel.QUERY}) "
-            "RETURN DISTINCT q.id AS id, q.kind AS kind, q.target_table AS target LIMIT 100",
-            {"t": table},
-        )
-        if not raw:
-            from sqlcg.server.noise_filter import NoiseFilter
+    results = run_read_routed(
+        f"MATCH (t:{NodeLabel.TABLE} {{qualified: $t}})"
+        f"<-[:{RelType.SELECTS_FROM}]-(q:{NodeLabel.QUERY}) "
+        "RETURN DISTINCT q.id AS id, q.kind AS kind, q.target_table AS target LIMIT 100",
+        {"t": table},
+    )
+    if not raw:
+        from sqlcg.server.noise_filter import NoiseFilter
 
-            nf = NoiseFilter.from_config()
-            results = [r for r in results if not nf.is_noise(r.get("target", ""))]
-        _print_table(results, ["id", "kind"])
+        nf = NoiseFilter.from_config()
+        results = [r for r in results if not nf.is_noise(r.get("target", ""))]
+    _print_table(results, ["id", "kind"])
 
 
 @app.command("failures")
@@ -227,15 +231,14 @@ def failures(
     with 'sqlcg db reset && sqlcg index <path>' if the graph was built with
     an earlier version.
     """
-    with get_backend(read_only=True) as backend:
-        cypher = (
-            f"MATCH (f:{NodeLabel.FILE}) WHERE f.parse_failed = true "
-            "AND ($cause IS NULL OR f.parse_cause = $cause) "
-            "RETURN f.path AS path, f.parse_cause AS cause "
-            f"ORDER BY f.parse_cause LIMIT {limit}"
-        )
-        rows = backend.run_read(cypher, {"cause": cause})
-        _print_table(rows, ["path", "cause"])
+    cypher = (
+        f"MATCH (f:{NodeLabel.FILE}) WHERE f.parse_failed = true "
+        "AND ($cause IS NULL OR f.parse_cause = $cause) "
+        "RETURN f.path AS path, f.parse_cause AS cause "
+        f"ORDER BY f.parse_cause LIMIT {limit}"
+    )
+    rows = run_read_routed(cypher, {"cause": cause})
+    _print_table(rows, ["path", "cause"])
 
 
 @app.command("unused")
@@ -244,18 +247,17 @@ def unused(
     raw: bool = typer.Option(False, "--raw", help="Disable noise filtering on results"),  # noqa: B008
 ) -> None:
     """Find tables with no query references."""
-    with get_backend(read_only=True) as backend:
-        results = backend.run_read(
-            f"MATCH (t:{NodeLabel.TABLE}) WHERE NOT (t)<-[:{RelType.SELECTS_FROM}]-() "
-            "RETURN DISTINCT t.qualified AS qualified LIMIT 100",
-            {},
-        )
-        if not raw:
-            from sqlcg.server.noise_filter import NoiseFilter
+    results = run_read_routed(
+        f"MATCH (t:{NodeLabel.TABLE}) WHERE NOT (t)<-[:{RelType.SELECTS_FROM}]-() "
+        "RETURN DISTINCT t.qualified AS qualified LIMIT 100",
+        {},
+    )
+    if not raw:
+        from sqlcg.server.noise_filter import NoiseFilter
 
-            nf = NoiseFilter.from_config()
-            results = [r for r in results if not nf.is_noise(r["qualified"])]
-        _print_table(results, ["qualified"])
+        nf = NoiseFilter.from_config()
+        results = [r for r in results if not nf.is_noise(r["qualified"])]
+    _print_table(results, ["qualified"])
 
 
 def _bare_ref(ref: str) -> str: