3737
3838Nodes are MERGE-upserted, never blindly deleted, so a declaration another
3939(unchanged) module still references survives and its incoming edges stay valid.
40- ``:PyExternal`` / ``:PyPackage`` / ``:PyDecorator`` are shared ( no ``_module``) and are
40+ ``:PyExternal`` / ``:PyPackage`` / ``:PyDecorator`` have no owning module and are
4141MERGE-only.
4242
43- Every ``_module`` match is anchored on the python-owned labels
44- (``schema.MODULE_OWNED_PATTERN``). ``_module`` is a shared convention, not a python-private
45- one -- codeanalyzer-java and codeanalyzer-typescript set it on their nodes too -- so an
46- unlabelled match reaches a sibling analyzer's graph in a shared database (#171).
43+ **Every destructive statement is scoped on the ``can://`` id prefix** (#173). The id is a
44+ path — ``can://python/<app>/<file>/...`` — so ``id = <module-id> OR id STARTS WITH
45+ <module-id> + '/'`` is containment, and it is one language, one application and one
46+ module at once. That is what neither a label anchor nor the retired ``_module`` property
47+ could give: two python applications sharing ``src/foo.py`` carry identical labels and an
48+ identical file key, and only the id tells them apart. ``:PyCanNode`` anchors the predicate
49+ so it seeks an index instead of scanning the store; it carries no safety claim.
4750
4851The ``neo4j`` driver is imported lazily so it stays an optional dependency and
4952off the default (json) output path entirely.
5356from dataclasses import dataclass
5457from typing import Dict , List , Optional
5558
56- from codeanalyzer .neo4j .rows import EdgeRow , GraphRows , NodeRow , chunk
57- from codeanalyzer .neo4j .schema import CONSTRAINTS , INDEXES , MODULE_OWNED_PATTERN
59+ from codeanalyzer .neo4j .rows import (
60+ CAN_NODE , EdgeRow , GraphRows , NodeRow , application_prefix , chunk , descendant_prefix ,
61+ )
62+ from codeanalyzer .neo4j .schema import CONSTRAINTS , INDEXES
5863from codeanalyzer .utils import logger
5964
60- DESCENDANTS = (
61- "[:PY_DECLARES|PY_HAS_METHOD|PY_HAS_ATTRIBUTE|PY_DECLARES_VAR"
62- "|PY_HAS_CALLSITE|PY_HAS_BODY_NODE*1..]"
63- )
6465BATCH = 1000
6566
67+ # The per-module purge (#173): the module by equality, its subtree by prefix. Anchored
68+ # on :PyCanNode only so the predicate can seek (see ``rows.CAN_NODE``).
69+ PURGE_MODULE_EDGES = (
70+ f"MATCH (x:{ CAN_NODE }
71+ "MATCH (x)-[r]->() DELETE r"
72+ )
73+ PURGE_VANISHED_NODES = (
74+ f"MATCH (x:{ CAN_NODE }
75+ "AND NOT x.id IN $keys DETACH DELETE x"
76+ )
77+ # The orphan prune: modules inside this application's prefix that the run no longer
78+ # emits, and everything under each. Batched — deleting a large application in one
79+ # transaction exhausts dbms.memory.transaction.total.max (typescript#116).
80+ PRUNE_VANISHED_MODULES = (
81+ f"MATCH (m:PyModule:{ CAN_NODE }
82+ f"CALL {{ WITH m MATCH (x:{ CAN_NODE }
83+ "DETACH DELETE x } IN TRANSACTIONS OF 1000 ROWS "
84+ "RETURN count(*) AS pruned"
85+ )
86+
6687
6788@dataclass
6889class BoltConfig :
@@ -93,35 +114,44 @@ def session():
93114 for stmt in [* CONSTRAINTS , * INDEXES ]:
94115 s .run (stmt )
95116
96- # The application anchor (a shared node) — used to scope the orphan prune
97- # so it never touches modules belonging to a different :PyApplication.
117+ # The application anchor. Every destructive statement below is scoped to
118+ # ``can://python/<app>/``; an empty application id is refused up front rather
119+ # than becoming ``STARTS WITH ''`` (every node in the database).
98120 app_name = next (
99121 (n .value for n in rows .nodes if n .labels and n .labels [0 ] == "PyApplication" ),
100122 None ,
101123 )
124+ app_prefix = application_prefix (app_name )
102125
103- # Partition nodes by owning module; shared nodes have no _module.
126+ # Partition nodes by owning module (an in-memory field, never emitted, #173);
127+ # shared nodes have none.
104128 by_module : Dict [str , List [NodeRow ]] = {}
105129 shared : List [NodeRow ] = []
106130 module_of : Dict [str , str ] = {} # node value → owning module
107131 for n in rows .nodes :
108- m = n .props .get ("_module" )
109- if isinstance (m , str ):
110- by_module .setdefault (m , []).append (n )
111- module_of [n .value ] = m
132+ if n .module is not None :
133+ by_module .setdefault (n .module , []).append (n )
134+ module_of [n .value ] = n .module
112135 else :
113136 shared .append (n )
114137
115- # 2. diff content_hash.
138+ # 2. diff content_hash, keyed by module id inside this application's prefix.
139+ # Keyed by file key it was application-blind: a second application whose
140+ # module shares the path and the hash looked "unchanged" and was never written.
116141 db_hash : Dict [str , Optional [str ]] = {}
117142 with session () as s :
118- res = s .run ("MATCH (m:PyModule) RETURN m.file_key AS k, m.content_hash AS h" )
143+ res = s .run (
144+ f"MATCH (m:PyModule:{ CAN_NODE }
145+ "RETURN m.id AS k, m.content_hash AS h" ,
146+ app = app_prefix ,
147+ )
119148 for rec in res :
120149 db_hash [rec ["k" ]] = rec ["h" ]
121150 changed = set ()
122151 for m , nodes in by_module .items ():
123- row_hash = _hash_of (nodes , m )
124- if m not in db_hash or row_hash is None or row_hash != db_hash .get (m ):
152+ mid = _module_id_of (nodes )
153+ row_hash = _hash_of (nodes )
154+ if mid not in db_hash or row_hash is None or row_hash != db_hash .get (mid ):
125155 changed .add (m )
126156 logger .info (
127157 f"neo4j(bolt): { len (by_module )} { len (changed )}
@@ -139,23 +169,19 @@ def session():
139169 if not eager :
140170 _upsert_nodes (session , neo4j , nodes )
141171 continue
172+ # The module id comes from the module's own row, never by splitting a
173+ # declaration's id: a file key may itself contain '/'.
174+ module_id = _module_id_of (nodes )
175+ if module_id is None or not module_id .startswith (app_prefix ):
176+ raise ValueError (
177+ f"neo4j: module { m !r} { app_prefix !r}
178+ "refusing to purge"
179+ )
142180 with session () as s :
143- def _purge (tx , module = m , node_keys = keys ):
144- # Anchored on python-owned labels: `_module` is also set by the java
145- # and typescript analyzers, so an unlabelled match would delete a
146- # sibling's nodes wherever a file key collides (#171).
147- tx .run (
148- f"MATCH (x:{ MODULE_OWNED_PATTERN }
149- "MATCH (x)-[r]->() DELETE r" ,
150- m = module ,
151- )
152- tx .run (
153- f"MATCH (x:{ MODULE_OWNED_PATTERN }
154- "AND NOT coalesce(x.signature, x.id, x.file_key) IN $keys "
155- "DETACH DELETE x" ,
156- m = module ,
157- keys = node_keys ,
158- )
181+ def _purge (tx , mid = module_id , node_keys = keys ):
182+ params = {"mid" : mid , "pre" : descendant_prefix (mid )}
183+ tx .run (PURGE_MODULE_EDGES , ** params )
184+ tx .run (PURGE_VANISHED_NODES , keys = node_keys , ** params )
159185
160186 s .execute_write (_purge )
161187 _upsert_nodes (session , neo4j , nodes )
@@ -169,19 +195,13 @@ def _purge(tx, module=m, node_keys=keys):
169195 _upsert_edges (session , neo4j , edges )
170196
171197 # 6. orphan prune — only safe on a full run (a targeted run can't tell deleted from untargeted).
172- # Scope to THIS application's anchor so a full run for application B never
173- # deletes application A's modules from a shared database.
174- if full_run and eager and app_name is not None :
175- present = list (by_module .keys ())
198+ # Scoped to ``can://python/<app>/`` so a full run for application B never deletes
199+ # application A's modules from a shared database — even when both are python and
200+ # share a module path.
201+ if full_run and eager :
202+ present = [mid for mid in (_module_id_of (ns ) for ns in by_module .values ()) if mid ]
176203 with session () as s :
177- res = s .run (
178- "MATCH (:PyApplication {name: $app})-[:PY_HAS_MODULE]->(m:PyModule) "
179- "WHERE NOT m.file_key IN $present "
180- f"OPTIONAL MATCH (m)-{ DESCENDANTS }
181- "RETURN count(m) AS pruned" ,
182- app = app_name ,
183- present = present ,
184- )
204+ res = s .run (PRUNE_VANISHED_MODULES , app = app_prefix , present = present )
185205 pruned = res .single ()
186206 pruned_count = pruned ["pruned" ] if pruned else 0
187207 logger .info (f"neo4j(bolt): pruned { pruned_count } )
@@ -263,12 +283,19 @@ def _upsert_edges(session, neo4j, edges: List[EdgeRow]) -> None:
263283# ----------------------------------------------------------------------------------------------
264284
265285
266- def _hash_of (nodes : List [NodeRow ], file_key : str ) -> Optional [str ]:
267- for n in nodes :
268- if n .labels [0 ] == "PyModule" and n .value == file_key :
269- h = n .props .get ("content_hash" )
270- return h if isinstance (h , str ) else None
271- return None
286+ def _module_row (nodes : List [NodeRow ]) -> Optional [NodeRow ]:
287+ return next ((n for n in nodes if n .labels [0 ] == "PyModule" ), None )
288+
289+
290+ def _module_id_of (nodes : List [NodeRow ]) -> Optional [str ]:
291+ row = _module_row (nodes )
292+ return row .value if row is not None else None
293+
294+
295+ def _hash_of (nodes : List [NodeRow ]) -> Optional [str ]:
296+ row = _module_row (nodes )
297+ h = row .props .get ("content_hash" ) if row is not None else None
298+ return h if isinstance (h , str ) else None
272299
273300
274301def _to_params (props , neo4j ) -> dict :
0 commit comments