sql-code-graph 0.3.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

sqlcg/core/kuzu_backend.py

@@ -23,17 +23,64 @@ from sqlcg.utils.logging import getLogger
 logger = getLogger(__name__)
 
 
+def _find_lock_holder(db_path: str) -> str:
+    """Return a human-readable PID string for the process holding the DB lock.
+
+    Uses lsof on Linux/macOS. Returns a descriptive fallback if lsof is
+    unavailable or returns no results.
+    """
+    import shutil
+    import subprocess
+
+    if not shutil.which("lsof"):
+        return "PID unknown (lsof not available)"
+    try:
+        result = subprocess.run(
+            ["lsof", "-t", db_path],
+            capture_output=True,
+            text=True,
+            timeout=3,
+        )
+        pids = result.stdout.strip().split()
+        if pids:
+            return f"PID {', '.join(pids)}"
+    except Exception:
+        pass
+    return "PID unknown"
+
+
 class KuzuBackend(GraphBackend):
     """KùzuDB implementation of the graph database backend."""
 
-    def __init__(self, db_path: str):
+    def __init__(self, db_path: str, buffer_pool_size_mb: int = 0, read_only: bool = False):
         """Initialize KùzuDB backend.
 
         Args:
             db_path: Path to the KùzuDB database file (or ':memory:' for in-memory)
+            buffer_pool_size_mb: Buffer pool size in MB (0 = use KuzuDB default)
+            read_only: Open in read-only mode (allows concurrent indexing)
+
+        Raises:
+            RuntimeError: If the database is locked or cannot be opened.
         """
         self._db_path = db_path
-        self._db = kuzu.database.Database(db_path)
+        try:
+            kwargs: dict = {"read_only": read_only}
+            if buffer_pool_size_mb > 0:
+                kwargs["buffer_pool_size"] = buffer_pool_size_mb * 1024 * 1024
+            self._db = kuzu.database.Database(db_path, **kwargs)
+        except RuntimeError as exc:
+            if "Could not set lock" in str(exc) or "lock" in str(exc).lower():
+                # Attempt to find the holding PID via lsof
+                pid_hint = _find_lock_holder(db_path)
+                pid_str = pid_hint.split()[-1] if pid_hint else "<PID>"
+                msg = (
+                    f"Database is locked — another sqlcg process is running "
+                    f"({pid_hint}). "
+                    f"Wait for it to finish or kill it with: kill {pid_str}"
+                )
+                raise RuntimeError(msg) from exc
+            raise
         self._conn = kuzu.Connection(self._db)
         self._in_transaction = False
 
@@ -160,6 +207,93 @@ class KuzuBackend(GraphBackend):
             logger.error(f"upsert_edge failed: {src_label} -> {rel_type} -> {dst_label}: {e}")
             raise
 
+    def upsert_nodes_bulk(self, label: str, rows: list[dict[str, Any]]) -> None:
+        """Bulk-upsert nodes of one label in a single backend round-trip."""
+        if not rows:
+            return
+        # Validate all property keys across all rows (same guard as upsert_node)
+        for row in rows:
+            self._validate_props(row)
+
+        pk_field = self._pk_field(label)
+        # Determine the property key set from the first row; require homogeneity.
+        keys = list(rows[0].keys())
+        if pk_field not in keys:
+            raise ValueError(
+                f"upsert_nodes_bulk({label}): every row must include primary key '{pk_field}'"
+            )
+        for i, row in enumerate(rows[1:], 1):
+            if set(row.keys()) != set(keys):
+                raise ValueError(
+                    f"upsert_nodes_bulk({label}): row {i} has property keys "
+                    f"{sorted(row.keys())}, expected {sorted(keys)}"
+                )
+
+        set_keys = [k for k in keys if k != pk_field]
+        # UNWIND $rows AS row MERGE (n:Label {pk: row.pk}) SET n.k = row.k, ...
+        query = f"UNWIND $rows AS row MERGE (n:{label} {{{pk_field}: row.{pk_field}}})"
+        if set_keys:
+            set_parts = [f"n.{k} = row.{k}" for k in set_keys]
+            query += f" SET {', '.join(set_parts)}"
+
+        try:
+            self._conn.execute(query, {"rows": rows})
+        except Exception as e:
+            logger.error(f"upsert_nodes_bulk failed: {label} ({len(rows)} rows): {e}")
+            raise
+
+    def upsert_edges_bulk(
+        self,
+        src_label: str,
+        dst_label: str,
+        rel_type: str,
+        rows: list[dict[str, Any]],
+    ) -> None:
+        """Bulk-upsert edges of one (src_label, rel_type, dst_label) triple."""
+        if not rows:
+            return
+        for row in rows:
+            # src_key/dst_key are not graph properties; validate the remainder.
+            props = {k: v for k, v in row.items() if k not in ("src_key", "dst_key")}
+            self._validate_props(props)
+
+        src_pk = self._pk_field(src_label)
+        dst_pk = self._pk_field(dst_label)
+
+        keys = list(rows[0].keys())
+        for required in ("src_key", "dst_key"):
+            if required not in keys:
+                raise ValueError(
+                    f"upsert_edges_bulk({src_label}->{rel_type}->{dst_label}): "
+                    f"every row must include '{required}'"
+                )
+        for i, row in enumerate(rows[1:], 1):
+            if set(row.keys()) != set(keys):
+                raise ValueError(
+                    f"upsert_edges_bulk: row {i} has property keys {sorted(row.keys())}, "
+                    f"expected {sorted(keys)}"
+                )
+
+        prop_keys = [k for k in keys if k not in ("src_key", "dst_key")]
+        query = (
+            f"UNWIND $rows AS row "
+            f"MATCH (src:{src_label} {{{src_pk}: row.src_key}}) "
+            f"MATCH (dst:{dst_label} {{{dst_pk}: row.dst_key}}) "
+            f"MERGE (src)-[r:{rel_type}]->(dst)"
+        )
+        if prop_keys:
+            set_parts = [f"r.{k} = row.{k}" for k in prop_keys]
+            query += f" SET {', '.join(set_parts)}"
+
+        try:
+            self._conn.execute(query, {"rows": rows})
+        except Exception as e:
+            logger.error(
+                f"upsert_edges_bulk failed: {src_label}->{rel_type}->{dst_label} "
+                f"({len(rows)} rows): {e}"
+            )
+            raise
+
     def run_read(self, query: str, params: dict[str, Any]) -> list[dict[str, Any]]:
         """Execute a read-only query and return results."""
         try:
@@ -231,6 +365,38 @@ class KuzuBackend(GraphBackend):
             logger.warning(f"Failed to read schema version: {e}")
             return None
 
+    def set_indexed_sha(self, sha: str) -> None:
+        """Persist the git SHA of the last successful index.
+
+        Uses MERGE so the call is safe whether the SchemaVersion node already
+        exists or not.  Mirrors the init_schema MERGE pattern.
+
+        Args:
+            sha: Git commit SHA string.
+        """
+        try:
+            self._conn.execute(
+                "MERGE (v:SchemaVersion {version: $version}) SET v.indexed_sha = $sha",
+                {"version": SCHEMA_VERSION, "sha": sha},
+            )
+        except Exception as e:
+            logger.warning(f"Failed to write indexed_sha: {e}")
+
+    def get_indexed_sha(self) -> str | None:
+        """Retrieve the git SHA of the last successful index.
+
+        Returns:
+            The stored SHA string, or None if never set.
+        """
+        try:
+            result = self.run_read(
+                "MATCH (v:SchemaVersion) RETURN v.indexed_sha AS sha LIMIT 1", {}
+            )
+            return result[0]["sha"] if result else None
+        except Exception as e:
+            logger.warning(f"Failed to read indexed_sha: {e}")
+            return None
+
     def close(self) -> None:
         """Close the database connection."""
         try:
@@ -261,11 +427,16 @@ class KuzuBackend(GraphBackend):
             yield self
             self._conn.execute("COMMIT")
             self._in_transaction = False
-        except Exception:
+        except Exception as exc:
+            self._in_transaction = False
+            if "No active transaction" in str(exc):
+                # KuzuDB killed the transaction internally (e.g. KU_UNREACHABLE assertion
+                # during a bulk write). Individual failures were already logged; the batch
+                # is lost but the indexer can continue.
+                logger.warning("Transaction invalidated by KuzuDB — batch not committed")
+                return
             try:
                 self._conn.execute("ROLLBACK")
-                self._in_transaction = False
             except Exception as rollback_err:
-                logger.error(f"Rollback failed: {rollback_err}")
-                self._in_transaction = False  # defensive reset
+                logger.debug("Rollback skipped: %s", rollback_err)
             raise

sqlcg/core/neo4j_backend.py

@@ -110,6 +110,30 @@ class Neo4jBackend(GraphBackend):
             logger.error(f"upsert_edge failed: {src_label} -> {rel_type} -> {dst_label}: {e}")
             raise
 
+    def upsert_nodes_bulk(self, label: str, rows: list[dict[str, Any]]) -> None:
+        """Bulk-upsert nodes of one label.
+
+        Neo4j adapter is not currently implemented. Use KuzuBackend instead.
+        """
+        raise NotImplementedError(
+            "Neo4j bulk upsert is not yet implemented. Use KuzuBackend instead."
+        )
+
+    def upsert_edges_bulk(
+        self,
+        src_label: str,
+        dst_label: str,
+        rel_type: str,
+        rows: list[dict[str, Any]],
+    ) -> None:
+        """Bulk-upsert edges of one (src_label, rel_type, dst_label) triple.
+
+        Neo4j adapter is not currently implemented. Use KuzuBackend instead.
+        """
+        raise NotImplementedError(
+            "Neo4j bulk upsert is not yet implemented. Use KuzuBackend instead."
+        )
+
     def run_read(self, query: str, params: dict[str, Any]) -> list[dict[str, Any]]:
         """Execute a read-only query and return results."""
         try:
@@ -160,6 +184,20 @@ class Neo4jBackend(GraphBackend):
             logger.warning(f"Failed to read schema version: {e}")
             return None
 
+    def set_indexed_sha(self, sha: str) -> None:
+        """Persist the git SHA of the last successful index (Neo4j stub).
+
+        Neo4j support for indexed_sha is not yet implemented.
+        """
+        raise NotImplementedError("set_indexed_sha is not yet implemented for Neo4jBackend")
+
+    def get_indexed_sha(self) -> str | None:
+        """Retrieve the git SHA of the last successful index (Neo4j stub).
+
+        Neo4j support for indexed_sha is not yet implemented.
+        """
+        raise NotImplementedError("get_indexed_sha is not yet implemented for Neo4jBackend")
+
     def close(self) -> None:
         """Close the database connection."""
         try:

sqlcg/core/queries.cypher

@@ -0,0 +1,114 @@
+-- DELETE_COLUMNS_FOR_FILE
+MATCH (f:File {path: $path})<-[:DEFINED_IN]-(t:SqlTable)-[:HAS_COLUMN]->(c:SqlColumn)
+DETACH DELETE c
+
+-- DELETE_QUERIES_FOR_FILE
+MATCH (f:File {path: $path})<-[:QUERY_DEFINED_IN]-(q:SqlQuery)
+DETACH DELETE q
+
+-- DELETE_TABLES_FOR_FILE
+MATCH (f:File {path: $path})<-[:DEFINED_IN]-(t:SqlTable)
+DETACH DELETE t
+
+-- DELETE_FILE
+MATCH (f:File {path: $path}) DETACH DELETE f
+
+-- STALE_VIEWS
+MATCH (f:File {path: $path})<-[:DEFINED_IN]-(t:SqlTable)
+<-[:SELECTS_FROM]-(q:SqlQuery)-[:DECLARES]->(v:SqlTable {kind: 'VIEW'})
+RETURN DISTINCT v.qualified AS view_name
+
+-- INDEX_REPO_FILES
+MATCH (f:File) WHERE f.path STARTS WITH $repo_prefix RETURN f.path AS path
+
+-- TRACE_COLUMN_LINEAGE
+MATCH (dst:SqlColumn {id: $id})<-[r:COLUMN_LINEAGE]-(src:SqlColumn)
+RETURN src.id AS id, src.col_name AS col_name, src.table_qualified AS table_qualified, r.transform AS transform, r.confidence AS confidence
+
+-- FIND_TABLE_USAGES
+MATCH (t:SqlTable {name: $name})<-[:SELECTS_FROM]-(q:SqlQuery)
+-[:QUERY_DEFINED_IN]->(f:File)
+RETURN f.path AS file, q.sql AS sql, q.kind AS kind
+
+-- GET_DOWNSTREAM_DEPENDENCIES
+MATCH (src:SqlColumn {id: $id})-[:COLUMN_LINEAGE]->(dst:SqlColumn)
+RETURN dst.id AS id, dst.col_name AS col_name, dst.table_qualified AS table_qualified
+
+-- GET_UPSTREAM_DEPENDENCIES
+MATCH (dst:SqlColumn {id: $id})<-[:COLUMN_LINEAGE]-(src:SqlColumn)
+RETURN src.id AS id, src.col_name AS col_name, src.table_qualified AS table_qualified
+
+-- SEARCH_SQL_PATTERN
+MATCH (q:SqlQuery)-[:QUERY_DEFINED_IN]->(f:File)
+WHERE contains(q.sql, $query)
+RETURN f.path AS file, q.sql AS sql, q.kind AS kind
+LIMIT $limit
+
+-- LIST_DIALECTS_AND_REPOS
+MATCH (r:Repo)<-[:BELONGS_TO]-(f:File)
+RETURN r.path AS path, r.name AS name, collect(DISTINCT f.dialect) AS dialects
+
+-- EXPAND_STAR_SOURCES
+MATCH (q:SqlQuery)-[s:STAR_SOURCE]->(t:SqlTable)-[:HAS_COLUMN]->(c:SqlColumn)
+WHERE q.target_table <> ''
+MATCH (tgt:SqlTable {qualified: q.target_table})
+MERGE (dst:SqlColumn {id: q.target_table + '.' + c.col_name})
+  ON CREATE SET dst.col_name = c.col_name,
+                dst.table_qualified = q.target_table,
+                dst.catalog = tgt.catalog,
+                dst.db = tgt.db,
+                dst.table_name = tgt.name
+MERGE (tgt)-[:HAS_COLUMN]->(dst)
+MERGE (c)-[r:COLUMN_LINEAGE]->(dst)
+  ON CREATE SET r.transform = 'STAR_EXPANSION',
+                r.confidence = 0.8,
+                r.query_id = q.id
+RETURN count(r) AS edges_created
+
+-- COUNT_STAR_SOURCES
+MATCH ()-[r:STAR_SOURCE]->() RETURN count(r) AS n
+
+-- COUNT_STAR_EXPANSIONS
+MATCH ()-[r:COLUMN_LINEAGE {transform: 'STAR_EXPANSION'}]->() RETURN count(r) AS n
+
+-- FIND_DEFINITION
+MATCH (t:SqlTable {qualified: $table_qualified})-[:DEFINED_IN]->(f:File)
+RETURN t.qualified AS table_qualified, t.kind AS kind, t.defined_in_file AS defined_in_file, f.path AS file_path
+
+-- GET_TABLE_DEFINING_FILES
+MATCH (t:SqlTable {qualified: $table_qualified})-[:DEFINED_IN]->(f:File)
+RETURN f.path AS file_path, t.kind AS kind
+
+-- GET_TABLE_DIRECT_UPSTREAMS
+MATCH (q:SqlQuery {target_table: $table_qualified})-[:SELECTS_FROM]->(src:SqlTable)
+WHERE src.qualified <> $table_qualified
+OPTIONAL MATCH (q)-[:QUERY_DEFINED_IN]->(f:File)
+RETURN DISTINCT src.qualified AS upstream_table, f.path AS in_file
+
+-- GET_COLUMNS_FOR_TABLE
+MATCH (t:SqlTable {qualified: $table_qualified})-[:HAS_COLUMN]->(c:SqlColumn)
+RETURN c.id AS col_id, c.col_name AS col_name
+
+-- GET_TABLES_DEFINED_IN_FILE
+MATCH (f:File {path: $file_path})<-[:DEFINED_IN]-(t:SqlTable)
+RETURN t.qualified AS table_qualified
+
+-- ANALYZE_UNUSED_TABLES
+MATCH (t:SqlTable)
+WHERE NOT (t)<-[:SELECTS_FROM]-()
+RETURN t.qualified AS table_qualified
+ORDER BY t.qualified
+
+-- HUB_RANKING
+MATCH (t:SqlTable)<-[:SELECTS_FROM]-(q:SqlQuery)
+WHERE q.target_table <> ''
+WITH t.qualified AS table_qualified, q.target_table AS consumer_table
+WHERE consumer_table <> table_qualified
+RETURN table_qualified, count(DISTINCT consumer_table) AS downstream_dependents
+ORDER BY downstream_dependents DESC, table_qualified
+LIMIT $k
+
+-- DEPENDENT_FILES_OF_TABLES
+UNWIND $tables AS tbl
+MATCH (t:SqlTable {qualified: tbl})<-[:SELECTS_FROM]-(q:SqlQuery)-[:QUERY_DEFINED_IN]->(f:File)
+RETURN DISTINCT f.path AS path

sqlcg/core/queries.py

@@ -1,82 +1,44 @@
-"""Centralized Cypher query strings for graph operations."""
-
-from sqlcg.core.schema import NodeLabel, RelType
-
-# Scope is bounded by exact path match; APOC procedures are not required.
-# Delete Column nodes for tables defined in a file
-DELETE_COLUMNS_FOR_FILE = (
-    f"MATCH (f:{NodeLabel.FILE} {{path: $path}})"
-    f"<-[:{RelType.DEFINED_IN}]-(t:{NodeLabel.TABLE})"
-    f"-[:{RelType.HAS_COLUMN}]->(c:{NodeLabel.COLUMN})"
-    " DETACH DELETE c"
-)
-
-# Delete Query nodes and their edges
-DELETE_QUERIES_FOR_FILE = (
-    f"MATCH (f:{NodeLabel.FILE} {{path: $path}})"
-    f"<-[:{RelType.QUERY_DEFINED_IN}]-(q:{NodeLabel.QUERY})"
-    " DETACH DELETE q"
-)
-
-# Delete Table nodes defined in a file
-DELETE_TABLES_FOR_FILE = (
-    f"MATCH (f:{NodeLabel.FILE} {{path: $path}})"
-    f"<-[:{RelType.DEFINED_IN}]-(t:{NodeLabel.TABLE})"
-    " DETACH DELETE t"
-)
-
-# Delete the File node itself
-DELETE_FILE = f"MATCH (f:{NodeLabel.FILE} {{path: $path}}) DETACH DELETE f"
-
-# Find views that depend on tables defined in a file
-STALE_VIEWS_QUERY = (
-    f"MATCH (f:{NodeLabel.FILE} {{path: $path}})"
-    f"<-[:{RelType.DEFINED_IN}]-(t:{NodeLabel.TABLE})"
-    f"<-[:{RelType.SELECTS_FROM}]-(q:{NodeLabel.QUERY})"
-    f"-[:{RelType.DECLARES}]->(v:{NodeLabel.TABLE} {{kind: 'VIEW'}})"
-    " RETURN DISTINCT v.qualified AS view_name"
-)
-
-# Get all files in a repo by path prefix
-INDEX_REPO_FILES_QUERY = (
-    "MATCH (f:File) WHERE f.path STARTS WITH $repo_prefix RETURN f.path AS path"
-)
-
-# Trace upstream lineage of a column
-TRACE_COLUMN_LINEAGE_QUERY = (
-    "MATCH (dst:SqlColumn {id: $id})<-[:COLUMN_LINEAGE]-(src:SqlColumn) "
-    "RETURN src.id AS id, src.col_name AS col_name"
-)
-
-# Find table usages in queries
-FIND_TABLE_USAGES_QUERY = (
-    "MATCH (t:SqlTable {name: $name})<-[:SELECTS_FROM]-(q:SqlQuery)"
-    "-[:QUERY_DEFINED_IN]->(f:File) "
-    "RETURN f.path AS file, q.sql AS sql, q.kind AS kind"
-)
-
-# Get downstream column dependencies
-GET_DOWNSTREAM_DEPENDENCIES_QUERY = (
-    "MATCH (src:SqlColumn {id: $id})-[:COLUMN_LINEAGE]->(dst:SqlColumn) "
-    "RETURN dst.id AS id, dst.col_name AS col_name"
-)
-
-# Get upstream column dependencies
-GET_UPSTREAM_DEPENDENCIES_QUERY = (
-    "MATCH (dst:SqlColumn {id: $id})<-[:COLUMN_LINEAGE]-(src:SqlColumn) "
-    "RETURN src.id AS id, src.col_name AS col_name"
-)
-
-# Search SQL patterns in indexed queries
-SEARCH_SQL_PATTERN_QUERY = (
-    "MATCH (q:SqlQuery)-[:QUERY_DEFINED_IN]->(f:File) "
-    "WHERE contains(q.sql, $query) "
-    "RETURN f.path AS file, q.sql AS sql, q.kind AS kind "
-    "LIMIT $limit"
-)
-
-# List dialects and repos
-LIST_DIALECTS_AND_REPOS_QUERY = (
-    "MATCH (r:Repo)<-[:BELONGS_TO]-(f:File) "
-    "RETURN r.path AS path, r.name AS name, collect(DISTINCT f.dialect) AS dialects"
-)
+"""Cypher query loader. All query strings live in queries.cypher."""
+
+import re
+from pathlib import Path
+
+_CYPHER_FILE = Path(__file__).parent / "queries.cypher"
+
+
+def _load() -> dict[str, str]:
+    """Load named Cypher blocks from queries.cypher.
+
+    Format: blocks are separated by lines matching "-- BLOCK_NAME" at the start.
+    Each block name becomes a key in the returned dict.
+    """
+    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)}
+
+
+_Q = _load()
+
+DELETE_COLUMNS_FOR_FILE = _Q["DELETE_COLUMNS_FOR_FILE"]
+DELETE_QUERIES_FOR_FILE = _Q["DELETE_QUERIES_FOR_FILE"]
+DELETE_TABLES_FOR_FILE = _Q["DELETE_TABLES_FOR_FILE"]
+DELETE_FILE = _Q["DELETE_FILE"]
+STALE_VIEWS_QUERY = _Q["STALE_VIEWS"]
+INDEX_REPO_FILES_QUERY = _Q["INDEX_REPO_FILES"]
+TRACE_COLUMN_LINEAGE_QUERY = _Q["TRACE_COLUMN_LINEAGE"]
+FIND_TABLE_USAGES_QUERY = _Q["FIND_TABLE_USAGES"]
+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_QUERY = _Q["EXPAND_STAR_SOURCES"]
+COUNT_STAR_SOURCES_QUERY = _Q["COUNT_STAR_SOURCES"]
+COUNT_STAR_EXPANSIONS_QUERY = _Q["COUNT_STAR_EXPANSIONS"]
+FIND_DEFINITION_QUERY = _Q["FIND_DEFINITION"]
+GET_TABLE_DEFINING_FILES_QUERY = _Q["GET_TABLE_DEFINING_FILES"]
+GET_TABLE_DIRECT_UPSTREAMS_QUERY = _Q["GET_TABLE_DIRECT_UPSTREAMS"]
+GET_COLUMNS_FOR_TABLE_QUERY = _Q["GET_COLUMNS_FOR_TABLE"]
+GET_TABLES_DEFINED_IN_FILE_QUERY = _Q["GET_TABLES_DEFINED_IN_FILE"]
+ANALYZE_UNUSED_TABLES_QUERY = _Q["ANALYZE_UNUSED_TABLES"]
+HUB_RANKING_QUERY = _Q["HUB_RANKING"]
+DEPENDENT_FILES_OF_TABLES_QUERY = _Q["DEPENDENT_FILES_OF_TABLES"]

sqlcg/core/schema.cypher

@@ -9,7 +9,9 @@ CREATE NODE TABLE File (
     path STRING PRIMARY KEY,
     repo_path STRING,
     sha STRING,
-    dialect STRING
+    dialect STRING,
+    parse_failed BOOLEAN,
+    parse_cause STRING
 );
 
 -- Table node: one per unique table reference
@@ -62,7 +64,8 @@ CREATE REL TABLE QUERY_DEFINED_IN (
 
 -- Table -> Column: table has this column
 CREATE REL TABLE HAS_COLUMN (
-    FROM SqlTable TO SqlColumn
+    FROM SqlTable TO SqlColumn,
+    source STRING
 );
 
 -- Query -> Table: query selects from table
@@ -98,7 +101,16 @@ CREATE REL TABLE DECLARES (
     FROM SqlQuery TO SqlTable
 );
 
+-- Query -> Table: query does SELECT * (or alias.*) from this table
+CREATE REL TABLE STAR_SOURCE (
+    FROM SqlQuery TO SqlTable,
+    qualifier STRING,
+    target_table STRING,
+    confidence FLOAT
+);
+
 -- Schema version tracking
 CREATE NODE TABLE SchemaVersion (
-    version STRING PRIMARY KEY
+    version STRING PRIMARY KEY,
+    indexed_sha STRING
 );

sqlcg/core/schema.py

@@ -3,7 +3,7 @@
 from enum import StrEnum
 from importlib.resources import files
 
-SCHEMA_VERSION = "1"
+SCHEMA_VERSION = "4"
 
 
 class NodeLabel(StrEnum):
@@ -26,6 +26,7 @@ class RelType(StrEnum):
     UPDATES = "UPDATES"
     COLUMN_LINEAGE = "COLUMN_LINEAGE"
     DECLARES = "DECLARES"
+    STAR_SOURCE = "STAR_SOURCE"
 
 
 # Backward-compatible aliases