Deleting a Neo4j node from a Spring application - neo4j

Question

I'm trying to delete a node from an embedded graph.
I'm using SDN 3.3.2.RELEASE and my Neo4j is 2.2.4.
But the node is still around after the repository call:
org.junit.ComparisonFailure: expected:<null> but was:<Manufacturer [name=Siemens]>
Here is my test:
#Test
public void testDeleteById() {
Neo4JManufacturer loadedManufacturer = neo4JManufacturerRepository.findOne(manufacturer0.getId());
assertThatManufacturer(loadedManufacturer).exists();
neo4JManufacturerRepository.deleteManufacturer(manufacturer0.getId());
assertThatManufacturer(loadedManufacturer).doesNotExist();
}
The repository is:
public interface Neo4JManufacturerRepository extends GraphRepository<Neo4JManufacturer> {
#Transactional
#Query("start u = node({id}) match u-[r]-() delete u,r")
public void deleteManufacturer(#Param("id") Long id);
Before trying to delete with the deleteManufacturer() method, I was trying to delete with the delete() method, as in:
neo4JManufacturerRepository.delete(manufacturer0.getId());
But I would get the exact same test failure:
org.junit.ComparisonFailure: expected:<null> but was:<Manufacturer [name=Siemens]>
This is my node class:
#NodeEntity
#SequenceGenerator(name = "id_generator", sequenceName = "sq_id_manufacturer")
public class Neo4JManufacturer extends BaseEntity {
#Column(nullable = false, unique = true)
#Indexed
private String name;
public Neo4JManufacturer() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
#Override
public String toString() {
return "Manufacturer [name=" + name + "]";
}
}
UPDATE:
Following the two comments, I added another find call after the delete call so as to trigger a flush to the data store:
Neo4JManufacturer loadedManufacturer = neo4JManufacturerRepository.findOne(manufacturer0.getId());
assertThatManufacturer(loadedManufacturer).exists();
neo4JManufacturerRepository.delete(manufacturer0.getId());
loadedManufacturer = neo4JManufacturerRepository.findOne(manufacturer0.getId());
assertThatManufacturer(loadedManufacturer).doesNotExist();
And I also added the optional clause in the query:
#Transactional
#Query("START u = node({id}) OPTIONAL MATCH u-[r]-() DELETE u,r")
public void deleteManufacturer(#Param("id") Long id);
Now, I get a different error:
No primary SDN label exists .. (i.e one starting with _)
I suppose the flush after the delete is being attempted, but fails for another reason ?
Also, I wonder if the flushing and transactin behavior is the same when using JPA and when using Neo4j. Indeed the following JPA test works just as expected:
#Test
public void testDeleteByUserId() {
User loadedUser = userRepository.findOne(user0.getId());
assertThatUser(loadedUser).exists();
loadedUser = userRepository.deleteByUserId(user0.getId());
loadedUser = userRepository.findOne(user0.getId());
assertThatUser(loadedUser).doesNotExist();
}
My idea is to do the same with the Neo4j database.
UPDATE: I'm now deleting on a transactional service instead of directly on the repository:
#Modifying
#Transactional(rollbackFor = EntityNotFoundException.class)
#Override
public Neo4JManufacturer delete(Long id) throws EntityNotFoundException {
Neo4JManufacturer manufacturer = findById(id);
if (manufacturer == null) {
throw new EntityNotFoundException();
} else {
neo4jManufacturerRepository.delete(manufacturer.getId());
return manufacturer;
}
}
The service is called like:
#Test
public void testDeleteById() {
Neo4JManufacturer loadedManufacturer = neo4JManufacturerRepository.findOne(manufacturer0.getId());
assertThatManufacturer(loadedManufacturer).exists();
neo4JManufacturerService.delete(manufacturer0.getId());
Neo4JManufacturer anotherManufacturer = neo4JManufacturerRepository.findOne(manufacturer0.getId());
assertThatManufacturer(anotherManufacturer).doesNotExist();
}
But I still get the same exception:
testDeleteById(it.kahoot.robot.data.neo4j.Neo4JManufacturerRepositoryTest) Time elapsed: 0.137 sec <<< ERROR!
org.springframework.dao.InvalidDataAccessApiUsageException: No primary SDN label exists .. (i.e one starting with _) ; nested exception is java.lang.IllegalStateException: No primary SDN label exists .. (i.e one starting with _)
at org.springframework.data.neo4j.support.typerepresentation.LabelBasedNodeTypeRepresentationStrategy.readAliasFrom(LabelBasedNodeTypeRepresentationStrategy.java:136)
at org.springframework.data.neo4j.support.typerepresentation.LabelBasedNodeTypeRepresentationStrategy.readAliasFrom(LabelBasedNodeTypeRepresentationStrategy.java:40)
at org.springframework.data.neo4j.support.mapping.TRSTypeAliasAccessor.readAliasFrom(TRSTypeAliasAccessor.java:36)
at org.springframework.data.neo4j.support.mapping.TRSTypeAliasAccessor.readAliasFrom(TRSTypeAliasAccessor.java:26)
at org.springframework.data.convert.DefaultTypeMapper.readType(DefaultTypeMapper.java:102)
UPDATE II: I have now a test that passes fine and behaves as expected. Still the test is under a #Transactional annotation. And it does not do any manual flush. The interesting part, and the reason the test stopped giving the error:
No primary SDN label exists .. (i.e one starting with _)
is that the findById or findOne calls were replaced by a findByName call. Doing either a findById or findOne call would trigger the above error.
Here is how the working test looks like:
#Test
public void testIsDelete() {
Neo4JManufacturer loadedManufacturer = neo4JManufacturerRepository.findOne(manufacturer0.getId());
assertThatManufacturer(loadedManufacturer).exists();
neo4JManufacturerRepository.delete(manufacturer0.getId());
loadedManufacturer = neo4JManufacturerService.findByName(loadedManufacturer.getName());
assertThatManufacturer(loadedManufacturer).doesNotExist();
}
The repository findByName is:
Neo4JManufacturer findByName(String name);
I had a logger in place which showed the id being set above 0
DEBUG [Neo4JManufacturerRepositoryTest] ==========>> Id: 4 Name: Siemens
Still, using a findById instead of a findByName was giving the above error.
And I wonder why.
UPDATE III:
I have now removed the transactional annotation from the test.
Here is the test:
#Test
public void testDelete() {
Neo4JManufacturer loadedManufacturer = neo4JManufacturerRepository.findOne(manufacturer0.getId());
assertThatManufacturer(loadedManufacturer).exists();
neo4JManufacturerRepository.delete(manufacturer0.getId());
loadedManufacturer = neo4JManufacturerRepository.findOne(manufacturer0.getId());
assertThatManufacturer(loadedManufacturer).doesNotExist();
assertThatManufacturer(manufacturer0).exists();
manufacturer0 = neo4JManufacturerRepository.save(manufacturer0);
}
The console says:
2016-09-01 14:45:57,769 DEBUG [main] c.t.d.n.Neo4JManufacturerRepositoryTest ==========>> Before - Created manufacturer0 - Id: 0
2016-09-01 14:45:58,127 DEBUG [main] c.t.d.n.Neo4JManufacturerRepositoryTest ==========>> After - Deleted manufacturer0 - Id: 0
2016-09-01 14:45:58,320 DEBUG [main] c.t.d.n.Neo4JManufacturerRepositoryTest ==========>> Before - Created manufacturer0 - Id: 4
2016-09-01 14:45:58,850 DEBUG [main] c.t.d.n.Neo4JManufacturerRepositoryTest ==========>> After - Deleted manufacturer0 - Id: 4
2016-09-01 14:45:59,035 DEBUG [main] c.t.d.n.Neo4JManufacturerRepositoryTest ==========>> Before - Created manufacturer0 - Id: 8
Tests run: 4, Failures: 0, Errors: 2, Skipped: 0, Time elapsed: 23.625 sec <<< FAILURE! - in com.thalasoft.data.neo4j.Neo4JManufacturerRepositoryTest
testDelete(com.thalasoft.data.neo4j.Neo4JManufacturerRepositoryTest) Time elapsed: 0.334 sec <<< ERROR!
org.springframework.dao.DataRetrievalFailureException: Node 8 not found; nested exception is org.neo4j.graphdb.NotFoundException: Node 8 not found
It errors on the last source code line of the test, the one doing the save() operation.
Why does it look for a node ? Why does it complain it is not found ? Shouldn't it be not found since I'm trying to create it ?

Answer 1

Since your Cypher query is using MATCH u-[r]-(), it will fail if the specified node does not participate in any relationships.
You should use OPTIONAL MATCH instead, which allows the query to succeed even if the specified node does not participate in any relationships:
"START u = node({id}) OPTIONAL MATCH u-[r]-() DELETE u,r"

Answer 2

Within the same transaction the node is still visible, and as your test is very probably #Transactional per method, the tx is only finished (rolled back) after the method finishes
see: http://neo4j.com/docs/stable/transactions-delete.html
If you add a transactional handling (commit) after the delete without having the #Transactional on top of your test. You should not be able to see the node anymore.
Update
I ran your test, it is as I explained.
Your test (via its superclass) had a #Transactional annotation, so that all operations within the test method are executed in one transaction and afterwards rolled back.
If you want to see the real world behavior the deletion would have to happen in it's own tx (as part of your service call) after that transaction is finished, the node is no longer visible.
Also your assert tested that the previously loaded node would be null, which is never the case because the already existing variable is not changed as part of your delete operation.
I removed the global #Transactional annotation from your test-superclass and changed the test method to this:
#Test
public void testDeleteById() {
Neo4JManufacturer loadedManufacturer = neo4JManufacturerRepository.findOne(manufacturer0.getId());
assertThatManufacturer(loadedManufacturer).exists();
neo4JManufacturerService.delete(manufacturer0.getId());
loadedManufacturer = neo4JManufacturerRepository.findOne(manufacturer0.getId());
// both would work
// loadedManufacturer = neo4JManufacturerService.findById(manufacturer0.getId());
assertThatManufacturer(loadedManufacturer).doesNotExist();
}
Now it passes and exhibits the expected behavior: after the tx with the delete is completed the node is gone.