Пример #1
0
  // 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);
  }
Пример #2
0
  // 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
  }
Пример #3
0
  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);
  }
Пример #4
0
  // 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());
  }
Пример #5
0
 public void testCancelDelete() {
   Cloud cloud = getCloud();
   Transaction t = cloud.getTransaction("bar5");
   Node node = t.getNode(newNode);
   node.delete();
   t.cancel();
   assertTrue(cloud.hasNode(newNode));
 }
Пример #6
0
 public void testCommitDelete() {
   Cloud cloud = getCloud();
   Transaction t = cloud.getTransaction("bar6");
   Node node = t.getNode(newNode);
   node.delete();
   t.commit();
   assertFalse(cloud.hasNode(newNode));
 }
Пример #7
0
 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();
  }
Пример #10
0
  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();
    }
  }
Пример #12
0
  @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));
  }
Пример #13
0
  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));
  }
Пример #14
0
  // 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);
  }
Пример #15
0
  /** 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();
 }
Пример #17
0
 private void deleteNode(Node node) {
   try (Transaction tx = dbRule.getGraphDatabaseService().beginTx()) {
     node.delete();
     tx.success();
   }
 }
Пример #18
0
  /** 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();
    }
  }