PyPI - sql-code-graph - Versions diffs - 1.2.2__py3-none-any.whl → 1.4.0__py3-none-any.whl - Mend

sql-code-graph 1.2.2py3-none-any.whl → 1.4.0py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (33) hide show

{sql_code_graph-1.2.2.dist-info → sql_code_graph-1.4.0.dist-info}/METADATA +2 -4
{sql_code_graph-1.2.2.dist-info → sql_code_graph-1.4.0.dist-info}/RECORD +31 -30
sqlcg/__init__.py +1 -1
sqlcg/cli/commands/analyze.py +138 -127
sqlcg/cli/commands/db.py +49 -51
sqlcg/cli/commands/find.py +5 -9
sqlcg/cli/commands/gain.py +14 -16
sqlcg/cli/commands/git.py +11 -4
sqlcg/cli/commands/index.py +173 -21
sqlcg/cli/commands/mcp.py +70 -3
sqlcg/cli/commands/reindex.py +147 -77
sqlcg/cli/commands/uninstall.py +9 -20
sqlcg/core/__init__.py +1 -3
sqlcg/core/config.py +25 -81
sqlcg/core/duckdb_backend.py +764 -0
sqlcg/core/freshness.py +1 -1
sqlcg/core/graph_db.py +20 -4
sqlcg/core/queries.py +26 -7
sqlcg/core/queries.sql +249 -0
sqlcg/core/schema.py +1 -1
sqlcg/indexer/indexer.py +27 -36
sqlcg/metrics/store.py +49 -1
sqlcg/server/control.py +1 -1
sqlcg/server/noise_filter.py +1 -1
sqlcg/server/read_client.py +2 -2
sqlcg/server/server.py +184 -86
sqlcg/server/skill.py +2 -2
sqlcg/server/tools.py +119 -41
sqlcg/server/writer.py +459 -0
sqlcg/core/kuzu_backend.py +0 -445
sqlcg/core/neo4j_backend.py +0 -233
{sql_code_graph-1.2.2.dist-info → sql_code_graph-1.4.0.dist-info}/WHEEL +0 -0
{sql_code_graph-1.2.2.dist-info → sql_code_graph-1.4.0.dist-info}/entry_points.txt +0 -0

sqlcg/core/freshness.py CHANGED Viewed

@@ -74,7 +74,7 @@ def compute_freshness(root: Path, indexed_sha: str | None) -> Freshness:
     Args:
         root: Filesystem path used as the ``cwd`` for git commands.  This is
             typically the ``r.path`` value read from the ``Repo`` graph node.
-        indexed_sha: The SHA recorded by ``KuzuBackend.get_indexed_sha()``.
+        indexed_sha: The SHA recorded by ``DuckDBBackend.get_indexed_sha()``.
             May be ``None`` when the graph was never indexed, or a sentinel
             like ``"<head>+dirty"`` written by ``index --include-working-tree``.
     """

sqlcg/core/graph_db.py CHANGED Viewed

@@ -77,7 +77,7 @@ class GraphBackend(ABC):
         Each row dict must contain the primary-key field for `label` (see _pk_field)
         plus any other properties to SET. All rows must share the same property-key
-        set; backends MAY raise if rows are heterogeneous (KuzuBackend does).
+        set; backends MAY raise if rows are heterogeneous (DuckDBBackend does).
         Idempotent MERGE semantics, identical to upsert_node per row.
@@ -118,7 +118,7 @@ class GraphBackend(ABC):
         """Execute a read-only query and return results.
         Args:
-            query: Query string (Cypher for KùzuDB/Neo4j)
+            query: Query string (SQL)
             params: Parameters to bind in the query
         Returns:
@@ -130,7 +130,7 @@ class GraphBackend(ABC):
         """Execute a write query (mutation).
         Args:
-            query: Query string (Cypher for KùzuDB/Neo4j)
+            query: Query string (SQL)
             params: Parameters to bind in the query
         """
@@ -213,7 +213,7 @@ class GraphBackend(ABC):
     def _validate_props(properties: dict[str, Any]) -> None:
         """Validate that all property keys are safe identifiers.
-        Guards against Cypher injection via property key interpolation.
+        Guards against SQL injection via property key interpolation.
         Args:
             properties: Dictionary of properties to validate
@@ -244,3 +244,19 @@ class GraphBackend(ABC):
             yield self
         except Exception:
             raise
+    def clear_all_tables(self) -> None:
+        """Delete all node and edge rows, preserving the schema structure.
+        Used by the server drain body for the full-rebuild-in-transaction
+        reindex path. Concrete backends must override this.
+        """
+        raise NotImplementedError(f"{type(self).__name__} does not support clear_all_tables")
+    def expand_star_sources(self) -> int:
+        """Expand SELECT * lineage into per-column STAR_EXPANSION edges.
+        Runs once per index after ingestion. Concrete backends must override
+        this; returns the total STAR_EXPANSION edge count.
+        """
+        raise NotImplementedError(f"{type(self).__name__} does not support expand_star_sources")

sqlcg/core/queries.py CHANGED Viewed

@@ -1,20 +1,35 @@
-"""Cypher query loader. All query strings live in queries.cypher."""
+"""SQL query loader. All query strings live in queries.sql."""
 import re
 from pathlib import Path
-_CYPHER_FILE = Path(__file__).parent / "queries.cypher"
+_SQL_FILE = Path(__file__).parent / "queries.sql"
 def _load() -> dict[str, str]:
-    """Load named Cypher blocks from queries.cypher.
+    """Load named SQL blocks from queries.sql.
     Format: blocks are separated by lines matching "-- BLOCK_NAME" at the start.
-    Each block name becomes a key in the returned dict.
+    Each block name becomes a key in the returned dict.  Comment lines that start
+    with "-- " followed by lowercase words (e.g. "-- params: ...") are included in
+    the block text so the regex split is only on UPPER_SNAKE_CASE block headers.
     """
-    text = _CYPHER_FILE.read_text(encoding="utf-8")
-    blocks = re.split(r"^--\s+(\w+)\s*$", text, flags=re.MULTILINE)
-    return {blocks[i]: blocks[i + 1].strip() for i in range(1, len(blocks), 2)}
+    text = _SQL_FILE.read_text(encoding="utf-8")
+    # Split on lines like "-- BLOCK_NAME" (all-caps with underscores, start of line)
+    blocks = re.split(r"^--\s+([A-Z][A-Z0-9_]+)\s*$", text, flags=re.MULTILINE)
+    result: dict[str, str] = {}
+    for i in range(1, len(blocks), 2):
+        name = blocks[i]
+        body = blocks[i + 1].strip()
+        # Strip leading comment lines (-- params: ...) from block body
+        body_lines = []
+        for line in body.splitlines():
+            stripped = line.strip()
+            if stripped.startswith("--"):
+                continue
+            body_lines.append(line)
+        result[name] = "\n".join(body_lines).strip()
+    return result
 _Q = _load()
@@ -30,7 +45,11 @@ GET_DOWNSTREAM_DEPENDENCIES_QUERY = _Q["GET_DOWNSTREAM_DEPENDENCIES"]
 GET_UPSTREAM_DEPENDENCIES_QUERY = _Q["GET_UPSTREAM_DEPENDENCIES"]
 SEARCH_SQL_PATTERN_QUERY = _Q["SEARCH_SQL_PATTERN"]
 LIST_DIALECTS_AND_REPOS_QUERY = _Q["LIST_DIALECTS_AND_REPOS"]
+# EXPAND_STAR_SOURCES is implemented as three DML steps in DuckDBBackend.expand_star_sources()
+# rather than a single query (DuckDB cannot do MERGE in the Cypher sense).
 EXPAND_STAR_SOURCES_QUERY = _Q["EXPAND_STAR_SOURCES"]
+EXPAND_STAR_SOURCES_HAS_COLUMN_QUERY = _Q["EXPAND_STAR_SOURCES_HAS_COLUMN"]
+EXPAND_STAR_SOURCES_LINEAGE_QUERY = _Q["EXPAND_STAR_SOURCES_LINEAGE"]
 COUNT_STAR_SOURCES_QUERY = _Q["COUNT_STAR_SOURCES"]
 COUNT_STAR_EXPANSIONS_QUERY = _Q["COUNT_STAR_EXPANSIONS"]
 FIND_DEFINITION_QUERY = _Q["FIND_DEFINITION"]

sqlcg/core/queries.sql ADDED Viewed

@@ -0,0 +1,249 @@
+-- DuckDB SQL query library.
+-- Format identical to queries.cypher: blocks separated by "-- BLOCK_NAME" lines.
+-- All queries use ? positional parameters (list order matches the named params below).
+-- Named params in comments are for documentation — callers pass values as a list.
+-- DELETE_COLUMNS_FOR_FILE
+-- params: [path, path]
+DELETE FROM "SqlColumn" WHERE id IN (
+  SELECT hc.dst_key FROM "HAS_COLUMN" hc
+  WHERE hc.src_key IN (
+    SELECT di.src_key FROM "DEFINED_IN" di WHERE di.dst_key = ?
+  )
+)
+-- DELETE_QUERIES_FOR_FILE
+-- params: [path]
+DELETE FROM "SqlQuery" WHERE file_path = ?
+-- DELETE_TABLES_FOR_FILE
+-- params: [path, path]
+DELETE FROM "SqlTable" WHERE qualified IN (
+  SELECT di.src_key FROM "DEFINED_IN" di WHERE di.dst_key = ?
+)
+-- DELETE_FILE
+-- params: [path]
+DELETE FROM "File" WHERE path = ?
+-- INDEX_REPO_FILES
+-- params: [repo_prefix]
+SELECT path FROM "File" WHERE path LIKE ? || '%'
+-- TRACE_COLUMN_LINEAGE
+-- params: [id]
+SELECT
+  src.id         AS id,
+  src.col_name   AS col_name,
+  src.table_qualified AS table_qualified,
+  cl.transform   AS transform,
+  cl.confidence  AS confidence,
+  q.file_path    AS file,
+  q.start_line   AS line,
+  q.sql          AS expression,
+  t.kind         AS table_kind
+FROM "COLUMN_LINEAGE" cl
+JOIN "SqlColumn" src ON src.id = cl.src_key
+LEFT JOIN "SqlQuery" q ON q.id = cl.query_id
+LEFT JOIN "SqlTable" t ON t.qualified = src.table_qualified
+WHERE cl.dst_key = ?
+-- FIND_TABLE_USAGES
+-- params: [name]
+SELECT f.path AS file, q.sql AS sql, q.kind AS kind
+FROM "SqlTable" t
+JOIN "SELECTS_FROM" sf ON sf.dst_key = t.qualified
+JOIN "SqlQuery" q ON q.id = sf.src_key
+JOIN "QUERY_DEFINED_IN" qdi ON qdi.src_key = q.id
+JOIN "File" f ON f.path = qdi.dst_key
+WHERE t.name = ?
+-- GET_DOWNSTREAM_DEPENDENCIES
+-- params: [id]
+SELECT dst.id AS id, dst.col_name AS col_name, dst.table_qualified AS table_qualified
+FROM "COLUMN_LINEAGE" cl
+JOIN "SqlColumn" dst ON dst.id = cl.dst_key
+WHERE cl.src_key = ?
+-- GET_UPSTREAM_DEPENDENCIES
+-- params: [id]
+SELECT src.id AS id, src.col_name AS col_name, src.table_qualified AS table_qualified
+FROM "COLUMN_LINEAGE" cl
+JOIN "SqlColumn" src ON src.id = cl.src_key
+WHERE cl.dst_key = ?
+-- SEARCH_SQL_PATTERN
+-- params: [query, limit]
+SELECT f.path AS file, q.sql AS sql, q.kind AS kind
+FROM "SqlQuery" q
+JOIN "QUERY_DEFINED_IN" qdi ON qdi.src_key = q.id
+JOIN "File" f ON f.path = qdi.dst_key
+WHERE q.sql LIKE '%' || ? || '%'
+LIMIT ?
+-- LIST_DIALECTS_AND_REPOS
+-- params: []
+SELECT r.path AS path, r.name AS name,
+       list(DISTINCT f.dialect) AS dialects
+FROM "Repo" r
+JOIN "BELONGS_TO" bt ON bt.dst_key = r.path
+JOIN "File" f ON f.path = bt.src_key
+GROUP BY r.path, r.name
+-- EXPAND_STAR_SOURCES
+-- Inserts new SqlColumn destination nodes and COLUMN_LINEAGE edges from STAR_SOURCE.
+-- Returns count of new edges created.
+-- params: []
+INSERT OR REPLACE INTO "SqlColumn" (id, col_name, table_qualified, catalog, db, table_name)
+SELECT DISTINCT
+  q.target_table || '.' || c.col_name AS id,
+  c.col_name,
+  q.target_table AS table_qualified,
+  tgt.catalog,
+  tgt.db,
+  tgt.name AS table_name
+FROM "STAR_SOURCE" ss
+JOIN "SqlQuery" q ON q.id = ss.src_key
+JOIN "SqlTable" t ON t.qualified = ss.dst_key
+JOIN "HAS_COLUMN" hc ON hc.src_key = t.qualified
+JOIN "SqlColumn" c ON c.id = hc.dst_key
+JOIN "SqlTable" tgt ON tgt.qualified = q.target_table
+WHERE q.target_table <> ''
+  AND q.target_table <> t.qualified
+-- EXPAND_STAR_SOURCES_HAS_COLUMN
+-- Insert HAS_COLUMN edges for the new destination columns.
+-- params: []
+INSERT OR REPLACE INTO "HAS_COLUMN" (src_key, dst_key, source)
+SELECT DISTINCT
+  q.target_table AS src_key,
+  q.target_table || '.' || c.col_name AS dst_key,
+  'star_expansion' AS source
+FROM "STAR_SOURCE" ss
+JOIN "SqlQuery" q ON q.id = ss.src_key
+JOIN "SqlTable" t ON t.qualified = ss.dst_key
+JOIN "HAS_COLUMN" hc ON hc.src_key = t.qualified
+JOIN "SqlColumn" c ON c.id = hc.dst_key
+JOIN "SqlTable" tgt ON tgt.qualified = q.target_table
+WHERE q.target_table <> ''
+  AND q.target_table <> t.qualified
+-- EXPAND_STAR_SOURCES_LINEAGE
+-- Insert COLUMN_LINEAGE edges for the star expansion.
+-- params: []
+INSERT OR REPLACE INTO "COLUMN_LINEAGE" (src_key, dst_key, transform, confidence, query_id)
+SELECT DISTINCT
+  c.id AS src_key,
+  q.target_table || '.' || c.col_name AS dst_key,
+  'STAR_EXPANSION' AS transform,
+  0.8 AS confidence,
+  q.id AS query_id
+FROM "STAR_SOURCE" ss
+JOIN "SqlQuery" q ON q.id = ss.src_key
+JOIN "SqlTable" t ON t.qualified = ss.dst_key
+JOIN "HAS_COLUMN" hc ON hc.src_key = t.qualified
+JOIN "SqlColumn" c ON c.id = hc.dst_key
+JOIN "SqlTable" tgt ON tgt.qualified = q.target_table
+WHERE q.target_table <> ''
+  AND q.target_table <> t.qualified
+-- COUNT_STAR_SOURCES
+-- params: []
+SELECT count(*) AS n FROM "STAR_SOURCE"
+-- COUNT_STAR_EXPANSIONS
+-- params: []
+SELECT count(*) AS n FROM "COLUMN_LINEAGE" WHERE transform = 'STAR_EXPANSION'
+-- FIND_DEFINITION
+-- params: [table_qualified]
+SELECT t.qualified AS table_qualified, t.kind AS kind,
+       t.defined_in_file AS defined_in_file, f.path AS file_path
+FROM "SqlTable" t
+JOIN "DEFINED_IN" di ON di.src_key = t.qualified
+JOIN "File" f ON f.path = di.dst_key
+WHERE t.qualified = ?
+-- GET_TABLE_DEFINING_FILES
+-- params: [table_qualified]
+SELECT f.path AS file_path, t.kind AS kind
+FROM "SqlTable" t
+JOIN "DEFINED_IN" di ON di.src_key = t.qualified
+JOIN "File" f ON f.path = di.dst_key
+WHERE t.qualified = ?
+-- GET_TABLE_DIRECT_UPSTREAMS
+-- params: [table_qualified, table_qualified]
+SELECT DISTINCT src.qualified AS upstream_table, f.path AS in_file
+FROM "SqlQuery" q
+JOIN "SELECTS_FROM" sf ON sf.src_key = q.id
+JOIN "SqlTable" src ON src.qualified = sf.dst_key
+LEFT JOIN "QUERY_DEFINED_IN" qdi ON qdi.src_key = q.id
+LEFT JOIN "File" f ON f.path = qdi.dst_key
+WHERE q.target_table = ?
+  AND src.qualified <> ?
+-- GET_COLUMNS_FOR_TABLE
+-- params: [table_qualified]
+SELECT c.id AS col_id, c.col_name AS col_name
+FROM "SqlTable" t
+JOIN "HAS_COLUMN" hc ON hc.src_key = t.qualified
+JOIN "SqlColumn" c ON c.id = hc.dst_key
+WHERE t.qualified = ?
+-- GET_TABLES_DEFINED_IN_FILE
+-- params: [file_path]
+SELECT t.qualified AS table_qualified
+FROM "SqlTable" t
+JOIN "DEFINED_IN" di ON di.src_key = t.qualified
+WHERE di.dst_key = ?
+-- ANALYZE_UNUSED_TABLES
+-- params: []
+SELECT t.qualified AS table_qualified
+FROM "SqlTable" t
+WHERE t.qualified NOT IN (SELECT DISTINCT dst_key FROM "SELECTS_FROM")
+ORDER BY t.qualified
+-- HUB_RANKING
+-- params: [k]
+SELECT t.qualified AS table_qualified,
+       count(DISTINCT q.target_table) AS downstream_dependents
+FROM "SqlTable" t
+JOIN "SELECTS_FROM" sf ON sf.dst_key = t.qualified
+JOIN "SqlQuery" q ON q.id = sf.src_key
+WHERE q.target_table <> ''
+  AND q.target_table <> t.qualified
+GROUP BY t.qualified
+ORDER BY downstream_dependents DESC, t.qualified
+LIMIT ?
+-- DEPENDENT_FILES_OF_TABLES
+-- params: [tables]  (list — caller must expand with unnest or IN clause)
+SELECT DISTINCT f.path AS path
+FROM "SqlTable" t
+JOIN "SELECTS_FROM" sf ON sf.dst_key = t.qualified
+JOIN "SqlQuery" q ON q.id = sf.src_key
+JOIN "QUERY_DEFINED_IN" qdi ON qdi.src_key = q.id
+JOIN "File" f ON f.path = qdi.dst_key
+WHERE t.qualified = ANY(?)
+-- GET_TABLE_EXTERNAL_CONSUMERS
+-- params: [table_qualified]
+SELECT e.name AS name, e.consumer_type AS consumer_type
+FROM "SqlTable" t
+JOIN "CONSUMED_BY" cb ON cb.src_key = t.qualified
+JOIN "ExternalConsumer" e ON e.name = cb.dst_key
+WHERE t.qualified = ?
+-- GET_TABLES_EXTERNAL_CONSUMERS_BATCH
+-- params: [table_qualifieds]  (list)
+SELECT t.qualified AS table_qualified, e.name AS name, e.consumer_type AS consumer_type
+FROM "SqlTable" t
+JOIN "CONSUMED_BY" cb ON cb.src_key = t.qualified
+JOIN "ExternalConsumer" e ON e.name = cb.dst_key
+WHERE t.qualified = ANY(?)
+-- COUNT_EXTERNAL_CONSUMERS
+-- params: []
+SELECT count(*) AS n FROM "CONSUMED_BY"

sqlcg/core/schema.py CHANGED Viewed

@@ -1,4 +1,4 @@
-"""KùzuDB schema definition for sqlcg graph."""
+"""Graph schema definition for sqlcg (DuckDB backend)."""
 from enum import StrEnum
 from importlib.resources import files

sqlcg/indexer/indexer.py CHANGED Viewed

@@ -773,9 +773,13 @@ class Indexer:
         for cl_path in closure_files:
             try:
                 cl_rows = db.run_read(
-                    "MATCH (f:File {path: $path})<-[:QUERY_DEFINED_IN]-(q:SqlQuery) "
-                    "MATCH (q)-[:SELECTS_FROM]->(t:SqlTable) "
-                    "RETURN DISTINCT t.name AS name",
+                    "SELECT DISTINCT t.name AS name"
+                    ' FROM "File" f'
+                    ' JOIN "QUERY_DEFINED_IN" qdi ON qdi.dst_key = f.path'
+                    ' JOIN "SqlQuery" q ON q.id = qdi.src_key'
+                    ' JOIN "SELECTS_FROM" sf ON sf.src_key = q.id'
+                    ' JOIN "SqlTable" t ON t.qualified = sf.dst_key'
+                    " WHERE f.path = ?",
                     {"path": cl_path},
                 )
                 for row in cl_rows:
@@ -794,17 +798,21 @@ class Indexer:
             # first, but we do a broader search since the table might be qualified differently.
             try:
                 def_rows = db.run_read(
-                    "MATCH (t:SqlTable)-[:DEFINED_IN]->(f:File) "
-                    "WHERE t.name = $name "
-                    "RETURN DISTINCT f.path AS file_path",
-                    {"name": bare_name.upper()},
+                    "SELECT DISTINCT f.path AS file_path"
+                    ' FROM "SqlTable" t'
+                    ' JOIN "DEFINED_IN" di ON di.src_key = t.qualified'
+                    ' JOIN "File" f ON f.path = di.dst_key'
+                    " WHERE upper(t.name) = upper(?)",
+                    {"name": bare_name},
                 )
                 if not def_rows:
-                    # Try lowercase match
+                    # Try bare lowercase match
                     def_rows = db.run_read(
-                        "MATCH (t:SqlTable)-[:DEFINED_IN]->(f:File) "
-                        "WHERE t.name = $name "
-                        "RETURN DISTINCT f.path AS file_path",
+                        "SELECT DISTINCT f.path AS file_path"
+                        ' FROM "SqlTable" t'
+                        ' JOIN "DEFINED_IN" di ON di.src_key = t.qualified'
+                        ' JOIN "File" f ON f.path = di.dst_key'
+                        " WHERE lower(t.name) = lower(?)",
                         {"name": bare_name},
                     )
                 for row in def_rows:
@@ -1369,32 +1377,15 @@ class Indexer:
         return file_rows.counts
     def _expand_star_sources(self, db: GraphBackend) -> int:
-        """Run the post-ingestion star expansion query.
+        """Run the post-ingestion star expansion.
+        Calls the three-step DML expand_star_sources() method which returns the
+        total STAR_EXPANSION edge count.
         Returns:
-            Number of COLUMN_LINEAGE edges created by the expansion
+            Number of COLUMN_LINEAGE STAR_EXPANSION edges after expansion.
         """
-        from sqlcg.core.queries import EXPAND_STAR_SOURCES_QUERY
-        # Count COLUMN_LINEAGE edges before expansion
-        before = db.run_read(
-            "MATCH ()-[r:COLUMN_LINEAGE {transform: 'STAR_EXPANSION'}]->() RETURN count(r) AS n",
-            {},
-        )
-        before_count = before[0]["n"] if before else 0
-        # Run the expansion query (without explicit transaction, as caller may already be in one)
-        db.run_read(EXPAND_STAR_SOURCES_QUERY, {})
-        # Count COLUMN_LINEAGE edges after expansion
-        after = db.run_read(
-            "MATCH ()-[r:COLUMN_LINEAGE {transform: 'STAR_EXPANSION'}]->() RETURN count(r) AS n",
-            {},
-        )
-        after_count = after[0]["n"] if after else 0
-        # Return the number of new edges created
-        return max(0, after_count - before_count)
+        return db.expand_star_sources()
     def _ingest_external_consumers(self, db: GraphBackend, path: Path) -> dict:
         """Ingest declared external downstream consumers from .sqlcg.toml.
@@ -1417,10 +1408,10 @@ class Indexer:
         for spec in specs:
             all_targets.extend(spec.consumes)
-        # Single UNWIND round-trip to check which targets exist as SqlTable nodes
+        # Single round-trip to check which targets exist as SqlTable nodes
         if all_targets:
             existing_rows = db.run_read(
-                "UNWIND $names AS n MATCH (t:SqlTable {qualified: n}) RETURN n AS qualified",
+                'SELECT qualified FROM "SqlTable" WHERE qualified = ANY(?)',
                 {"names": all_targets},
             )
             existing_tables: set[str] = {row["qualified"] for row in existing_rows}

sqlcg/metrics/store.py CHANGED Viewed

@@ -1,6 +1,6 @@
 """SQLite-based metrics storage for SQL Code Graph.
-Importable without KùzuDB. All writes are wrapped in try/except with
+Importable without a graph backend. All writes are wrapped in try/except with
 WARNING-level logging on failure. Opt-out via SQLCG_METRICS=0.
 """
@@ -117,6 +117,19 @@ class MetricsStore:
                 )
                 """
             )
+            self._conn.execute(
+                """
+                CREATE TABLE IF NOT EXISTS writer_queue_events (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    timestamp TEXT NOT NULL,
+                    event TEXT NOT NULL,
+                    op TEXT,
+                    reason TEXT,
+                    queue_depth INTEGER,
+                    duration_ms REAL
+                )
+                """
+            )
             self._conn.commit()
         except sqlite3.Error as e:
             logger.warning(f"Failed to initialize metrics schema: {e}")
@@ -228,6 +241,41 @@ class MetricsStore:
         except sqlite3.Error as e:
             logger.warning(f"Failed to record feedback: {e}")
+    def record_queue_event(
+        self,
+        event: str,
+        *,
+        op: str | None = None,
+        reason: str | None = None,
+        queue_depth: int | None = None,
+        duration_ms: float | None = None,
+    ) -> None:
+        """Record a writer-queue lifecycle event.
+        Args:
+            event: One of ``"enqueued"``, ``"coalesced"``, ``"drained"``.
+            op: The write op type (``"index"`` or ``"reindex"``).
+            reason: Coalesce reason constant (set for ``"coalesced"`` events).
+            queue_depth: Pending-queue depth at event time.
+            duration_ms: Drain wall-clock duration (set for ``"drained"``).
+        """
+        if not self._enabled or self._conn is None:
+            return
+        try:
+            timestamp = datetime.now(UTC).isoformat()
+            self._conn.execute(
+                """
+                INSERT INTO writer_queue_events
+                (timestamp, event, op, reason, queue_depth, duration_ms)
+                VALUES (?, ?, ?, ?, ?, ?)
+                """,
+                (timestamp, event, op, reason, queue_depth, duration_ms),
+            )
+            self._conn.commit()
+        except sqlite3.Error as e:
+            logger.warning(f"Failed to record queue event: {e}")
     def execute_query(self, query: str, params: tuple | None = None) -> list[tuple]:
         """Execute a read-only query.

sqlcg/server/control.py CHANGED Viewed

@@ -3,7 +3,7 @@
 Manages the ``.pid`` and ``.sock`` files that allow a second CLI process to
 discover, query, and stop the running MCP server.
-All paths are derived from ``get_db_path()`` (i.e. ``KuzuConfig.from_env().db_path``)
+All paths are derived from ``get_db_path()`` (i.e. ``DbConfig.from_env().db_path``)
 so that two servers on two different databases do not collide on a single control
 file.  Callers may pass an explicit ``db_path`` to override the default; this also
 makes unit tests straightforward (set ``SQLCG_DB_PATH=/tmp/test.db``, assert paths

sqlcg/server/noise_filter.py CHANGED Viewed

@@ -15,7 +15,7 @@ from sqlcg.core.config import (
 class NoiseFilter:
     """Config-driven filter for backup tables and schema-alias mirrors.
-    Loaded once per tool call from KuzuConfig.from_env().db_path parent dir
+    Loaded once per tool call from DbConfig.from_env().db_path parent dir
     (falls back to cwd). All methods are pure — no graph calls.
     """

sqlcg/server/read_client.py CHANGED Viewed

@@ -45,7 +45,7 @@ import typer
 # Client-side socket timeout for the query control-socket path.
 # Sized to cover the longest in-flight reindex (~89 s DWH resync_changed)
-# with headroom.  This is a CLI transport constant, NOT a KuzuConfig value —
+# with headroom.  This is a CLI transport constant, NOT a DbConfig value —
 # same convention as _NOTIFY_SOCKET_TIMEOUT_S in reindex.py.
 _QUERY_SOCKET_TIMEOUT_S = 300
@@ -92,7 +92,7 @@ def query_via_server(
     if not sp.exists():
         return None
-    req = {"op": "query", "cypher": cypher, "params": params}
+    req = {"op": "query", "sql": cypher, "params": params}  # "sql" is the canonical key
     req_bytes = json.dumps(req).encode()
     frame = f"{len(req_bytes)}\n".encode() + req_bytes

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

sql-code-graph 1.2.2py3-none-any.whl → 1.4.0py3-none-any.whl