@Test
public void testAddProperty() {
String key3 = "key3";
Node node1 = getGraphDb().getNodeById(node1Id);
Node node2 = getGraphDb().getNodeById(node2Id);
Relationship rel = node1.getSingleRelationship(MyRelTypes.TEST, Direction.BOTH);
// add new property
node2.setProperty(key3, int1);
rel.setProperty(key3, int2);
assertTrue(node1.hasProperty(key1));
assertTrue(node2.hasProperty(key1));
assertTrue(node1.hasProperty(key2));
assertTrue(node2.hasProperty(key2));
assertTrue(node1.hasProperty(arrayKey));
assertTrue(node2.hasProperty(arrayKey));
assertTrue(rel.hasProperty(arrayKey));
assertTrue(!node1.hasProperty(key3));
assertTrue(node2.hasProperty(key3));
assertEquals(int1, node1.getProperty(key1));
assertEquals(int2, node2.getProperty(key1));
assertEquals(string1, node1.getProperty(key2));
assertEquals(string2, node2.getProperty(key2));
assertEquals(int1, rel.getProperty(key1));
assertEquals(string1, rel.getProperty(key2));
assertEquals(int2, rel.getProperty(key3));
}
@Override
public NodePointer getImmediateParentPointer() {
Node parentNode =
node.getSingleRelationship(RelType.HAS_CHILD, Direction.INCOMING).getStartNode();
return (new Neo4jNodePointer(this, parentNode));
}
protected Node findLeafContainingGeometryNode(Node geomNode, boolean throwExceptionIfNotFound) {
if (!geomNode.hasRelationship(RTreeRelationshipTypes.RTREE_REFERENCE, Direction.INCOMING)) {
if (throwExceptionIfNotFound) {
throw new RuntimeException("GeometryNode not indexed with an RTree: " + geomNode.getId());
} else {
return null;
}
}
Node indexNodeLeaf =
geomNode
.getSingleRelationship(RTreeRelationshipTypes.RTREE_REFERENCE, Direction.INCOMING)
.getStartNode();
Node root = null;
Node child = indexNodeLeaf;
while (root == null) {
Node parent = getIndexNodeParent(child);
if (parent == null) {
root = child;
} else {
child = parent;
}
}
if (root.getId() != getIndexRoot().getId()) {
if (throwExceptionIfNotFound) {
throw new RuntimeException("GeometryNode not indexed in this RTree: " + geomNode.getId());
} else {
return null;
}
} else {
return indexNodeLeaf;
}
}
@After
public void deleteTestingGraph() {
Node node1 = getGraphDb().getNodeById(node1Id);
Node node2 = getGraphDb().getNodeById(node2Id);
node1.getSingleRelationship(MyRelTypes.TEST, Direction.BOTH).delete();
node1.delete();
node2.delete();
}
private Node getIndexNodeParent(Node indexNode) {
Relationship relationship =
indexNode.getSingleRelationship(RTreeRelationshipTypes.RTREE_CHILD, Direction.INCOMING);
if (relationship == null) {
return null;
} else {
return relationship.getStartNode();
}
}
private void createNewRoot(Node oldRoot, Node newIndexNode) {
Node newRoot = database.createNode();
addChild(newRoot, RTreeRelationshipTypes.RTREE_CHILD, oldRoot);
addChild(newRoot, RTreeRelationshipTypes.RTREE_CHILD, newIndexNode);
Node layerNode = getRootNode();
layerNode.getSingleRelationship(RTreeRelationshipTypes.RTREE_ROOT, Direction.OUTGOING).delete();
layerNode.createRelationshipTo(newRoot, RTreeRelationshipTypes.RTREE_ROOT);
}
/**
* Wraps a {@link Node#getSingleRelationship(RelationshipType, Direction)} in a transaction.
*
* @param node the {@link Node}.
* @param type the {@link RelationshipType}
* @param direction the {@link Direction}.
* @return the result from {@link Node#getSingleRelationship(RelationshipType, Direction)}.
*/
public Relationship getSingleRelationship(Node node, RelationshipType type, Direction direction) {
Transaction tx = graphDb().beginTx();
try {
Relationship singleRelationship = node.getSingleRelationship(type, direction);
tx.success();
return singleRelationship;
} finally {
tx.finish();
}
}
@Override
public void removeAll(final boolean deleteGeomNodes, final Listener monitor) {
Node indexRoot = getIndexRoot();
monitor.begin(count());
try {
// delete all geometry nodes
visitInTx(
new SpatialIndexVisitor() {
public boolean needsToVisit(Envelope indexNodeEnvelope) {
return true;
}
public void onIndexReference(Node geomNode) {
geomNode
.getSingleRelationship(RTreeRelationshipTypes.RTREE_REFERENCE, Direction.INCOMING)
.delete();
if (deleteGeomNodes) {
deleteNode(geomNode);
}
monitor.worked(1);
}
},
indexRoot.getId());
} finally {
monitor.done();
}
try (Transaction tx = database.beginTx()) {
// delete index root relationship
indexRoot
.getSingleRelationship(RTreeRelationshipTypes.RTREE_ROOT, Direction.INCOMING)
.delete();
// delete tree
deleteRecursivelySubtree(indexRoot);
// delete tree metadata
Relationship metadataNodeRelationship =
getRootNode()
.getSingleRelationship(RTreeRelationshipTypes.RTREE_METADATA, Direction.OUTGOING);
Node metadataNode = metadataNodeRelationship.getEndNode();
metadataNodeRelationship.delete();
metadataNode.delete();
tx.success();
}
countSaved = false;
totalGeometryCount = 0;
}
public void remove(long geomNodeId, boolean deleteGeomNode, boolean throwExceptionIfNotFound) {
Node geomNode = null;
// getNodeById throws NotFoundException if node is already removed
try {
geomNode = database.getNodeById(geomNodeId);
} catch (NotFoundException nfe) {
// propagate exception only if flag is set
if (throwExceptionIfNotFound) {
throw nfe;
}
}
if (geomNode == null && !throwExceptionIfNotFound) {
// fail silently
return;
}
// be sure geomNode is inside this RTree
Node indexNode = findLeafContainingGeometryNode(geomNode, throwExceptionIfNotFound);
if (indexNode == null) {
return;
}
// remove the entry
final Relationship geometryRtreeReference =
geomNode.getSingleRelationship(RTreeRelationshipTypes.RTREE_REFERENCE, Direction.INCOMING);
if (geometryRtreeReference != null) {
geometryRtreeReference.delete();
}
if (deleteGeomNode) {
deleteNode(geomNode);
}
// reorganize the tree if needed
if (countChildren(indexNode, RTreeRelationshipTypes.RTREE_REFERENCE) == 0) {
indexNode = deleteEmptyTreeNodes(indexNode, RTreeRelationshipTypes.RTREE_REFERENCE);
adjustParentBoundingBox(indexNode, RTreeRelationshipTypes.RTREE_CHILD);
} else {
adjustParentBoundingBox(indexNode, RTreeRelationshipTypes.RTREE_REFERENCE);
}
adjustPathBoundingBox(indexNode);
countSaved = false;
totalGeometryCount--;
}
@Test
public void testNodeChangeProperty() {
Node node1 = getGraphDb().getNodeById(node1Id);
Node node2 = getGraphDb().getNodeById(node2Id);
Relationship rel = node1.getSingleRelationship(MyRelTypes.TEST, Direction.BOTH);
// test change property
node1.setProperty(key1, int2);
node2.setProperty(key1, int1);
rel.setProperty(key1, int2);
int[] newIntArray = new int[] {3, 2, 1};
node1.setProperty(arrayKey, newIntArray);
node2.setProperty(arrayKey, newIntArray);
rel.setProperty(arrayKey, newIntArray);
}
private void deleteRecursivelySubtree(Node indexNode) {
for (Relationship relationship :
indexNode.getRelationships(RTreeRelationshipTypes.RTREE_CHILD, Direction.OUTGOING)) {
deleteRecursivelySubtree(relationship.getEndNode());
}
Relationship relationshipWithFather =
indexNode.getSingleRelationship(RTreeRelationshipTypes.RTREE_CHILD, Direction.INCOMING);
// the following check is needed because rootNode doesn't have this relationship
if (relationshipWithFather != null) {
relationshipWithFather.delete();
}
indexNode.delete();
}
@Test
public void insert() throws InterruptedException {
// START SNIPPET: insert
BatchInserter inserter = null;
try {
inserter =
BatchInserters.inserter(
new File("target/batchinserter-example").getAbsolutePath(), fileSystem);
Label personLabel = DynamicLabel.label("Person");
inserter.createDeferredSchemaIndex(personLabel).on("name").create();
Map<String, Object> properties = new HashMap<>();
properties.put("name", "Mattias");
long mattiasNode = inserter.createNode(properties, personLabel);
properties.put("name", "Chris");
long chrisNode = inserter.createNode(properties, personLabel);
RelationshipType knows = DynamicRelationshipType.withName("KNOWS");
inserter.createRelationship(mattiasNode, chrisNode, knows, null);
} finally {
if (inserter != null) {
inserter.shutdown();
}
}
// END SNIPPET: insert
// try it out from a normal db
GraphDatabaseService db =
new TestGraphDatabaseFactory()
.setFileSystem(fileSystem)
.newImpermanentDatabase(new File("target/batchinserter-example").getAbsolutePath());
try (Transaction tx = db.beginTx()) {
Label personLabelForTesting = DynamicLabel.label("Person");
Node mNode = db.findNode(personLabelForTesting, "name", "Mattias");
Node cNode =
mNode
.getSingleRelationship(DynamicRelationshipType.withName("KNOWS"), Direction.OUTGOING)
.getEndNode();
assertThat((String) cNode.getProperty("name"), is("Chris"));
assertThat(db.schema().getIndexes(personLabelForTesting).iterator().hasNext(), is(true));
} finally {
db.shutdown();
}
}
private Node deleteEmptyTreeNodes(Node indexNode, RelationshipType relType) {
if (countChildren(indexNode, relType) == 0) {
Node parent = getIndexNodeParent(indexNode);
if (parent != null) {
indexNode
.getSingleRelationship(RTreeRelationshipTypes.RTREE_CHILD, Direction.INCOMING)
.delete();
indexNode.delete();
return deleteEmptyTreeNodes(parent, RTreeRelationshipTypes.RTREE_CHILD);
} else {
// root
return indexNode;
}
} else {
return indexNode;
}
}
@Test
public void testNodeRemoveProperty() {
Node node1 = getGraphDb().getNodeById(node1Id);
Node node2 = getGraphDb().getNodeById(node2Id);
Relationship rel = node1.getSingleRelationship(MyRelTypes.TEST, Direction.BOTH);
// test remove property
assertEquals(1, node1.removeProperty(key1));
assertEquals(2, node2.removeProperty(key1));
assertEquals(1, rel.removeProperty(key1));
assertEquals(string1, node1.removeProperty(key2));
assertEquals(string2, node2.removeProperty(key2));
assertEquals(string1, rel.removeProperty(key2));
assertTrue(node1.removeProperty(arrayKey) != null);
assertTrue(node2.removeProperty(arrayKey) != null);
assertTrue(rel.removeProperty(arrayKey) != null);
}
/**
* Tries to get a sub reference node with relationship type <code>type</code>. If it doesn't
* exist, it is created. There can be only one of any given type.
*
* <p>[NodeSpaceReferenceNode] -- type --> [SubReferenceNode]
*
* @param type the relationship type.
* @param direction the direction of the relationship.
* @return the sub-reference node.
*/
public Node getOrCreateSubReferenceNode(RelationshipType type, Direction direction) {
Transaction tx = graphDb().beginTx();
try {
Node referenceNode = getReferenceNode();
Node node = null;
Relationship singleRelationship = referenceNode.getSingleRelationship(type, direction);
if (singleRelationship != null) {
node = singleRelationship.getOtherNode(referenceNode);
} else {
node = graphDb().createNode();
referenceNode.createRelationshipTo(node, type);
}
tx.success();
return node;
} finally {
tx.finish();
}
}
@Test
public void testDirectedRelationship1() {
Node node1 = getGraphDb().getNodeById(node1Id);
Relationship rel = node1.getSingleRelationship(MyRelTypes.TEST, Direction.BOTH);
Node nodes[] = rel.getNodes();
assertEquals(2, nodes.length);
Node node2 = getGraphDb().getNodeById(node2Id);
assertTrue(nodes[0].equals(node1) && nodes[1].equals(node2));
assertEquals(node1, rel.getStartNode());
assertEquals(node2, rel.getEndNode());
Relationship relArray[] =
getRelationshipArray(node1.getRelationships(MyRelTypes.TEST, Direction.OUTGOING));
assertEquals(1, relArray.length);
assertEquals(rel, relArray[0]);
relArray = getRelationshipArray(node2.getRelationships(MyRelTypes.TEST, Direction.INCOMING));
assertEquals(1, relArray.length);
assertEquals(rel, relArray[0]);
}
private void initIndexMetadata() {
Node layerNode = getRootNode();
if (layerNode.hasRelationship(RTreeRelationshipTypes.RTREE_METADATA, Direction.OUTGOING)) {
// metadata already present
metadataNode =
layerNode
.getSingleRelationship(RTreeRelationshipTypes.RTREE_METADATA, Direction.OUTGOING)
.getEndNode();
maxNodeReferences = (Integer) metadataNode.getProperty("maxNodeReferences");
} else {
// metadata initialization
metadataNode = database.createNode();
layerNode.createRelationshipTo(metadataNode, RTreeRelationshipTypes.RTREE_METADATA);
metadataNode.setProperty("maxNodeReferences", maxNodeReferences);
}
saveCount();
}
@Test
public void simple_persistent_storage() throws Exception {
long firstNodeId = createDb();
GraphDatabaseService graphDb = new GraphDatabaseFactory().newEmbeddedDatabase(DB_PATH);
try {
Node firstNode = graphDb.getNodeById(firstNodeId);
Relationship relationship = firstNode.getSingleRelationship(KNOWS, Direction.OUTGOING);
Node secondNode = relationship.getEndNode();
out.println("I just loaded this from the data store:");
out.println(firstNode.getProperty("message"));
out.println(firstNode.getProperty("someJson"));
out.println(relationship.getProperty("message"));
out.println(secondNode.getProperty("message"));
} finally {
graphDb.shutdown();
}
}
public void deletePerson(Person person) {
Transaction tx = graphDb.beginTx();
try {
Node personNode = person.getUnderlyingNode();
index.remove(personNode, Person.NAME, person.getName());
for (Person friend : person.getFriends()) {
person.removeFriend(friend);
}
personNode.getSingleRelationship(RelTypes.A_PERSON, Direction.INCOMING).delete();
for (StatusUpdate status : person.getStatus()) {
Node statusNode = status.getUnderlyingNode();
for (Relationship r : statusNode.getRelationships()) {
r.delete();
}
statusNode.delete();
}
personNode.delete();
tx.success();
} finally {
tx.finish();
}
}
@Test
public void testGetDirectedRelationship() {
Node node1 = getGraphDb().getNodeById(node1Id);
Relationship rel = node1.getSingleRelationship(MyRelTypes.TEST, Direction.OUTGOING);
assertEquals(int1, rel.getProperty(key1));
}
@Override
public Relationship getRelationTo() {
return node.getSingleRelationship(getMainRelationshipType(), Direction.INCOMING);
}
