// MMB-1889 public void testCreateRelationAndDeleteNode() { // Make a relation to an existing node. Then delete that node with the 'delete relations' // option'. Commit the transaction. // The new relations should not exist, since the node was deleted. // No errors. Cloud cloud = getCloud(); int urlCount = Queries.count(cloud.getNodeManager("urls").createQuery()); int relCount = Queries.count(cloud.getNodeManager("insrel").createQuery()); Node url = cloud.getNodeManager("urls").createNode(); url.commit(); Transaction t = cloud.getTransaction("relatedandelete"); Node turl = t.getNode(url.getNumber()); Node news = t.getNode(newNode); RelationManager rm = t.getRelationManager("urls", "news", "posrel"); Relation r = turl.createRelation(news, rm); r.commit(); turl.delete(true); t.commit(); int urlCountAfter = Queries.count(cloud.getNodeManager("urls").createQuery()); assertEquals(urlCount, urlCountAfter); int relCountAfter = Queries.count(cloud.getNodeManager("insrel").createQuery()); assertEquals(relCount, relCountAfter); }
// MMB-1893 public void testDeleteNodeWitRelationsAndCancel() { Cloud cloud = getCloud(); int urlCount0 = Queries.count(cloud.getNodeManager("urls").createQuery()); int relCount0 = Queries.count(cloud.getNodeManager("insrel").createQuery()); Node url = cloud.getNodeManager("urls").createNode(); url.commit(); Node news = cloud.getNode(newNode); RelationManager rm = cloud.getRelationManager("urls", "news", "posrel"); Relation r = url.createRelation(news, rm); r.commit(); int urlCount = Queries.count(cloud.getNodeManager("urls").createQuery()); int relCount = Queries.count(cloud.getNodeManager("insrel").createQuery()); assertEquals(urlCount0 + 1, urlCount); assertEquals(relCount0 + 1, relCount); Transaction t = cloud.getTransaction("deletewithrelationsandcancel"); Node turl = t.getNode(url.getNumber()); turl.delete(true); t.cancel(); int urlCountAfter = Queries.count(cloud.getNodeManager("urls").createQuery()); assertEquals(urlCount, urlCountAfter); int relCountAfter = Queries.count(cloud.getNodeManager("insrel").createQuery()); assertEquals(relCount, relCountAfter); // MMB-1893 }
public void testCreateAndDelete2() { // Create new node. Request the node again. Delete that. Commit the transaction. // The new node must not exist. Cloud cloud = getCloud(); int urlCount = Queries.count(cloud.getNodeManager("urls").createQuery()); Transaction t = cloud.getTransaction("testcreateandelete"); Node url = t.getNodeManager("urls").createNode(); url.commit(); assertEquals(1, t.getNodes().size()); Node reurl = t.getNode(url.getNumber()); reurl.delete(); assertEquals( 1, t.getNodes() .size()); // 0 would also be an option, but the node remaisn in the transaction as // 'NOLONGER' t.commit(); int urlCountAfter = Queries.count(cloud.getNodeManager("urls").createQuery()); assertEquals(urlCount, urlCountAfter); }
// same case as above, only no changes are made to the node. public void testDeleteNodeOutsideTransactionNodeInTransactionButNotChanged() { Cloud cloud = getCloud(); Transaction t = cloud.getTransaction("bar11"); Node nodeInTransaction = t.getNode(newNode2); // nodeInTransaction.setStringValue("title", "foo2"); { // now delete the node Node nodeOutTransaction = cloud.getNode(newNode2); nodeOutTransaction.delete(); assertFalse(cloud.hasNode(newNode2)); } try { // make a relation to the (deleted) node, but in the transaction, where the node still // exists. // This demonstrate that there is an actual problem if the node ends up non-existing now. Node url = t.getNodeManager("urls").createNode(); RelationManager rm = t.getRelationManager("news", "urls", "posrel"); Relation r = nodeInTransaction.createRelation(url, rm); t.commit(); } catch (Exception e) { // should not give exception. MMB-1680 log.error(e.getMessage(), e); fail(e.getMessage()); } assertTrue(cloud.hasNode(newNode2)); assertEquals(1, cloud.getNode(newNode2).countRelations()); }
public void testCancelDelete() { Cloud cloud = getCloud(); Transaction t = cloud.getTransaction("bar5"); Node node = t.getNode(newNode); node.delete(); t.cancel(); assertTrue(cloud.hasNode(newNode)); }
public void testCommitDelete() { Cloud cloud = getCloud(); Transaction t = cloud.getTransaction("bar6"); Node node = t.getNode(newNode); node.delete(); t.commit(); assertFalse(cloud.hasNode(newNode)); }
public boolean delete() { Node node = ForumManager.getCloud().getNode(id); if (node != null) { node.delete(true); } parent.deleteSignature(this); return true; }
@Test(expected = org.neo4j.graphdb.NotFoundException.class) public void testDeleteNode() { final Transaction tx = restAPI.beginTx(); Node n1 = restAPI.createNode(map("name", "node1")); n1.delete(); Node n2 = restAPI.createNode(map("name", "node2")); tx.success(); tx.finish(); loadRealNode(n1); }
@Test(expected = RestResultException.class) public void testFailingDoubleDelete() throws Exception { final Transaction tx = restAPI.beginTx(); Node n1 = restAPI.createNode(map()); n1.delete(); n1.delete(); tx.success(); tx.finish(); }
private void assertCanCreateAndFind( GraphDatabaseService db, Label label, String propertyKey, Object value) { Node created = createNode(db, map(propertyKey, value), label); try (Transaction tx = db.beginTx()) { Node found = db.findNode(label, propertyKey, value); assertThat(found, equalTo(created)); found.delete(); tx.success(); } }
@Override public void delete() { Transaction tx = node.getGraphDatabase().beginTx(); try { getRelationTo().delete(); node.delete(); tx.success(); } finally { tx.finish(); } }
@Test public void deletedNodeShouldShowUpWithinTransaction() throws Exception { // GIVEN GraphDatabaseService beansAPI = dbRule.getGraphDatabaseService(); createIndex(beansAPI, LABEL1, "name"); Node firstNode = createNode(beansAPI, map("name", "Mattias"), LABEL1); // WHEN Transaction tx = beansAPI.beginTx(); long sizeBeforeDelete = count(beansAPI.findNodes(LABEL1, "name", "Mattias")); firstNode.delete(); long sizeAfterDelete = count(beansAPI.findNodes(LABEL1, "name", "Mattias")); tx.close(); // THEN assertThat(sizeBeforeDelete, equalTo(1l)); assertThat(sizeAfterDelete, equalTo(0l)); }
public void testDeleteNodeOutsideTransaction() { Cloud cloud = getCloud(); Transaction t = cloud.getTransaction("bar11"); Node nodeInTransaction = t.getNode(newNode2); nodeInTransaction.setStringValue("title", "foo2"); { // now delete the node Node nodeOutTransaction = cloud.getNode(newNode2); nodeOutTransaction.delete(); assertFalse(cloud.hasNode(newNode2)); } try { t.commit(); } catch (Exception e) { // should not give exception. MMB-1680 log.error(e.getMessage(), e); fail(e.getMessage()); } assertTrue(cloud.hasNode(newNode2)); }
// MMB-1860 (2) public void testCreateRelateAndDelete() { // Create new node. Make a relation to it. Delete the node again. Commit the transaction. // The new node must not exist, but the relation shouldn't have caused errors Cloud cloud = getCloud(); int urlCount = Queries.count(cloud.getNodeManager("urls").createQuery()); Transaction t = cloud.getTransaction("testcreateandelete"); Node news = t.getNode(newNode); Node url = t.getNodeManager("urls").createNode(); RelationManager rm = t.getRelationManager("urls", "news", "posrel"); Relation r = url.createRelation(news, rm); url.delete(true); t.commit(); int urlCountAfter = Queries.count(cloud.getNodeManager("urls").createQuery()); assertEquals(urlCount, urlCountAfter); }
/** Must be called when object is no longer referenced. */ void delete() { acquireExclusive(); try { // Prevent new allocations. mMaxSize = 0; Node node = mLeastRecentlyUsed; mLeastRecentlyUsed = null; mMostRecentlyUsed = null; while (node != null) { Node next = node.mMoreUsed; node.mLessUsed = null; node.mMoreUsed = null; // Free memory and make node appear to be evicted. node.delete(mDatabase); node = next; } } finally { releaseExclusive(); } }
@Override public void remove(Node node) { removeFromIndexes(node); node.delete(); }
private void deleteNode(Node node) { try (Transaction tx = dbRule.getGraphDatabaseService().beginTx()) { node.delete(); tx.success(); } }
/** Delete a node from the index */ void delete(Session session, Node x) throws HsqlException { if (x == null) { return; } for (IndexRowIterator it = updatableIterators.next; it != updatableIterators; it = it.next) { it.updateForDelete(x); } Node n; if (x.getLeft() == null) { n = x.getRight(); } else if (x.getRight() == null) { n = x.getLeft(); } else { Node d = x; x = x.getLeft(); /* // todo: this can be improved while (x.getRight() != null) { if (Trace.STOP) { Trace.stop(); } x = x.getRight(); } */ for (Node temp = x; (temp = temp.getRight()) != null; ) { x = temp; } // x will be replaced with n later n = x.getLeft(); // swap d and x int b = x.getBalance(); x.setBalance(d.getBalance()); d.setBalance(b); // set x.parent Node xp = x.getParent(); Node dp = d.getParent(); if (d == getRoot(session)) { setRoot(session, x); } x.setParent(dp); if (dp != null) { if (dp.getRight().equals(d)) { dp.setRight(x); } else { dp.setLeft(x); } } // for in-memory tables we could use: d.rData=x.rData; // but not for cached tables // relink d.parent, x.left, x.right if (xp == d) { d.setParent(x); if (d.getLeft().equals(x)) { x.setLeft(d); x.setRight(d.getRight()); } else { x.setRight(d); x.setLeft(d.getLeft()); } } else { d.setParent(xp); xp.setRight(d); x.setRight(d.getRight()); x.setLeft(d.getLeft()); } x.getRight().setParent(x); x.getLeft().setParent(x); // set d.left, d.right d.setLeft(n); if (n != null) { n.setParent(d); } d.setRight(null); x = d; } boolean isleft = x.isFromLeft(); replace(session, x, n); n = x.getParent(); x.delete(); while (n != null) { x = n; int sign = isleft ? 1 : -1; switch (x.getBalance() * sign) { case -1: x.setBalance(0); break; case 0: x.setBalance(sign); return; case 1: Node r = child(x, !isleft); int b = r.getBalance(); if (b * sign >= 0) { replace(session, x, r); set(x, !isleft, child(r, isleft)); set(r, isleft, x); if (b == 0) { x.setBalance(sign); r.setBalance(-sign); return; } x.setBalance(0); r.setBalance(0); x = r; } else { Node l = child(r, isleft); replace(session, x, l); b = l.getBalance(); set(r, isleft, child(l, !isleft)); set(l, !isleft, r); set(x, !isleft, child(l, isleft)); set(l, isleft, x); x.setBalance((b == sign) ? -sign : 0); r.setBalance((b == -sign) ? sign : 0); l.setBalance(0); x = l; } } isleft = x.isFromLeft(); n = x.getParent(); } }