Neo4j node/relation inconsistencies - neo4j

When fetching or when I try to delete a specifc node like
MATCH (p)
where ID(p)=79259223
OPTIONAL MATCH (p)-[r]-()
//drops p's relations
DELETE r,p
I get the following error
While loading relationships for Node[79259223] a Relationship[87331456] was encountered that had startNode: 80312215 and endNode: 83719851, i.e. which had neither start nor end node as the node we're loading relationships for
I also run the ConsistencyChecker what resulted in a big list of inconsistencys. However how can you fix these inconsistencys? I can not delete the nodes for instance

Here is a possible way to "fix" an occurrence of this error. Unfortunately, it is a fairly manual approach that has to be used for every node that encounters the same problem.
Before you delete the node, you can try to delete the inconsistent relationship by its native neo4j ID. For example:
MATCH ()-[r]->()
WHERE ID(r) = 87331456
DELETE r;
NOTE: Before deleting that relationship, you should first try to take a look at it (e.g., replace DELETE WITH RETURN) to understand what you are planning to delete. You may want to do something else first or instead.
If that deletion works, then try to delete the node again, as follows:
MATCH (p)
WHERE ID(p) = 79259223
DETACH DELETE p;
Notice that I use the DETACH DELETE syntax, which will attempt to delete all the relationships for the specified node.

Related

Unable to load NODE with id

I recently upgraded my Neo4j database to v. 3 (3.0.6). Since then I am having trouble when trying to delete nodes with Cypher. This is a new problem since the upgrade. They Cypher query is:
MATCH (p) WHERE id(p) = 83624
OPTIONAL MATCH (p)-[r]-(n)
OPTIONAL MATCH (p)-[r2]-(n2)
WHERE NOT ('Entity' in labels(n2))
DELETE r, r2, p, n2
This now results in the error Unable to load NODE with id 83624
The exact query with RETURN instead of DELETE returns the node. I've also tried swapping out DELETE with DETACH DELETE of the nodes, but that gives me the same error.
It looks like this question has been asked before but without a solution. Any idea what is causing this error?
I'm a little confused by this query. Both of your optional matches are identical, in that they will match to any relationship to any node connected to p.
Let me make sure I understand what you're trying to do: Find a node by ID, then delete that node along with any connected node that is not an Entity (as well as the relationships connecting them). Is that right?
If so, this query might work better:
MATCH (p) WHERE id(p) = 83624
OPTIONAL MATCH (p)--(n)
WHERE NOT n:Entity
DETACH DELETE n
DETACH DELETE p
Detaching a node deletes all relationships connected to that node, and you can only delete a node that has zero relationships.
Also, just to note, it's not a good idea to use the internal ids for uniquely identifying nodes. It's recommended to use your own unique IDs instead, and create unique constraints on that property for that label.

Neo4j cypher: Deleting a collection of relationships

I think this may be a bug, however, when deleting a collection of relationships the start node is also deleted. I am running neo4j community edition 2.3.3 and have run the following queries in order.
match (u:User)-[]->(p:Pie)-[c:CONSISTS_OF*1]->() where id(u) = 6398 and id(p)= 6436 return p,c Which returns Displaying 3 nodes, 2 relationships. and the graph in the image
match (u:User)-[]->(p:Pie)-[c:CONSISTS_OF*1]->() where id(u) = 6398 and id(p)= 6436 FOREACH( q in c | DELETE q) Which results in Deleted 2 relationships, statement executed in 103 ms.
And then what I am finding is instead of the collection of relationships c being deleted, the node p is also deleted…
match (u:User)-[]->(p:Pie)-[c:CONSISTS_OF*1]->() where id(u) = 6398 and id(p)= 6436 return p Which results in (no rows)
I would simply like to delete the collection of relationships. I also feel like this feature is something that makes sense but hasn’t been revisited since late 2013… https://github.com/neo4j/neo4j/issues/1612
EDIT: In an earlier version of the question I had DETACH DELETE instead of DELETE. This was a mistake in the posting of the question. I have since revised it. It should be noted that the reason I think this may be a bug is because both DETACH DELETE and DELETE behave the same in this scenario.
In the MATCH query that you use to check whether the (p:Pie) node exists after deleting the relationships you still include the -[c:CONSISTS_OF*1]-> part of the pattern. That part doesn't match anything, because you deleted those relationships. But then the whole pattern won't match anything either, whether or not the node still exists.
You can use MATCH (p:Pie) WHERE id(p) = 6436 to test that the (p:Pie) node still exists.

Cypher delete a node and all related nodes if they don't have a further relations

To keep my database clean from orphaned nodes, I want to delete a Node - identified by a given property value - and every related Node that does not have any other related nodes.
Is that possible? Currently I'm doing this:
MATCH (poi:PointOfInterest)-[r]-(allRelatedNodes)
WHERE poi.id="X007"
DETACH DELETE poi, r, allRelatedNodes;
But that deletes all related Nodes including the ones that would be connected to other Nodes if they weren't deleted.
Is there a way to delete a Node and all related Nodes that don't have relations to other Nodes?
Edit by the author:
The marked answer is correct. I finally solved my problem with
MATCH (poi:Node)-[r*0..1]-(allRelatedNodes)
WHERE poi.name = "A"
AND size((allRelatedNodes)--()) < 2
DETACH DELETE poi, allRelatedNodes;
If you make the allRelatedNodes match optional and ensure allRelatedNodes only have a single relationship to poi then you should be able to delete only the ones attached to X007 if they exist. Also, you don't need to specify r in the delete statement as DETACH takes care of that.
MATCH (poi:PointOfInterest)
WHERE poi.id = "X0007"
WITH poi
OPTIONAL MATCH (poi)-[r]-(allRelatedNodes)
WHERE size((allRelatedNodes)--()) = 1
DETACH DELETE poi, allRelatedNodes
Using Neo4j 3.0 and starting with the following graph...
And executing a close facsimile of the above query (listed below)...
MATCH (poi:Node)-[r]-(allRelatedNodes)
WHERE poi.name = "A"
AND size((allRelatedNodes)--()) = 1
DETACH DELETE poi, allRelatedNodes
I am left with this graph.
If that does not delete it all in one query you could use this instead and that should definitely take care of it.
MATCH (poi:PointOfInterest)-[r]-(allRelatedNodes)
WHERE poi.id = "X007"
AND size((allRelatedNodes)--()) = 1
WITH poi, collect(allRelatedNodes) as allRelatedNodes
DETACH DELETE poi
WITH allRelatedNodes
UNWIND allRelatedNodes as node
DELETE node

How to delete nodes in reverse order in neo4j

I have a database with nodes like
(u : Update)-[:HAS_COMMENT]->(latest_comment:Comment)-[:NEXT]->(c1: Comment)->(c2: Comment)
And so on.. Each Comment node has a relation with User node
(c : Comment)<-[:HAS_COMMENTED]-(u : User).
Now I have to delete the update node so with this all the comment nodes should be deleted and relation between User and Comment should also be deleted.
The solution that came to my mind is to traverse from last Comment node and start deleting relation with User node and delete Comment node and "NEXT" relation with the previous comment node. I am facing the problem to write such query.
Can someone help me with this?
Use a variable length path in an OPTIONAL MATCH statement to match on all Comments in the path (chained together with :NEXT relationships) then use DETACH DELETE to delete the nodes and relationships:
MATCH (u:Update {name: "UpdateToDelete"})-[:HAS_COMMENT]->(c:Comment)
OPTIONAL MATCH (c)-[:NEXT*]->(r:Comment)
DETACH DELETE u,c,r
DETACH DELETE will remove nodes and any relationships connected to the nodes being deleted.
Here is a Neo4j console to test.
Edit
The DETACH DELETE statement was added in Neo4j version 2.3. To accomplish this without using DETACH DELETE try this query:
MATCH (u:Update {name: "UpdateToDelete"})-[hc:HAS_COMMENT]->(c:Comment)
MATCH (c)-[n:NEXT*0..]->(r:Comment), (r)<-[h:HAS_COMMENTED]-(:User)
FOREACH (x IN n | DELETE x)
DELETE r,u,hc,c,h
The key difference is that without using DETACH DELETE we have to match on each relationship that connects a given node and delete those relationships when we delete the node. Since we have a variable length path (Comments connected by an arbitrary number of NEXT relationships) we can use the FOREACH function to iterate through the collection of NEXT relationships and delete them as we delete the Comment node(s).

unable to resolve an issue with Cypher query

I executed the below query and deleted all relations
START n=node:search('username:donna')
MATCH n-[rel18?:STATUS]->(n18)-[rel19?:NEXT*1..]->(n19)
WITH n, rel18, n18, rel19, n19
FOREACH(rel IN rel19: DELETE rel)
DELETE n19, n18, rel18;
Result: 6 relations and 6 nodes got deleted.
Now when I try to execute the same query again, I get an error Unknown identifier rel19
In fact even the below query gives the same error Unknown identifier rel19
START n=node:search('username:donna')
MATCH n-[rel18?:STATUS]->(n18)-[rel19?:NEXT*1..]->(n19)
RETURN n.username, rel18, n18, rel19, n19;
My domain model is same as this example,
http://docs.neo4j.org/chunked/milestone/cypher-cookbook-newsfeed.html
I am trying to implement delete for the same.
Also the above delete query (1st query) will be part of a bigger query appended using the WITH clause. So there will be cases when that particular user might not have any STATUS and NEXT relations but still the whole query should execute successfully. Can you please help in modifying the query so that query runs fine in all cases.
Thanks,
Pavan
[rel19?:NEXT*1..]->(n19) means an optional relationship, thus the match statement on this may or may not contain this path. if it will not contain this path, it will not parse it further to the return clause. than the return clause will output an error on identifier which does not exists. i suggest to put a WHERE condition before RETURN like this;
START n=node:search('username:donna')
MATCH n-[rel18?:STATUS]->(n18)-[rel19?:NEXT*1..]->(n19)
WITH n, rel18, n18, rel19, n19
WHERE n--n18
DELETE n19, n18, rel18
WITH rel19, n19
WHERE ()-[rel19:]-n19
DELETE n19
WITH rel19
FOREACH(rel IN rel19: DELETE rel)

Resources