@SuppressWarnings("unchecked") private void expand() { Iterable<Relationship> expand = expander.expand(this, BranchState.NO_STATE); for (Relationship rel : expand) { lastMetadata.rels++; Node node = rel.getOtherNode(lastNode); Visit visit = visitData.get(node.getId()); if (visit != null && visit.visited) { continue; } Visit lastVisit = visitData.get(lastNode.getId()); double tentativeGScore = lastVisit.wayLength + lengthEvaluator.getCost(rel, Direction.OUTGOING); double estimate = estimateEvaluator.getCost(node, end); if (visit == null || !visit.next || tentativeGScore < visit.wayLength) { if (visit == null) { visit = new Visit(rel.getId(), tentativeGScore, estimate); visitData.put(node.getId(), visit); } else { visit.update(rel.getId(), tentativeGScore, estimate); } addNext(node, estimate + tentativeGScore, visit); } } }
@Test public void shouldNotBeAbleToCommitIfFailedTransactionContext() throws Exception { Transaction tx = db.beginTx(); Statement statement = statementContextProvider.instance(); // WHEN Node node = null; int labelId = -1; try { node = db.createNode(); labelId = statement.dataWriteOperations().labelGetOrCreateForName("labello"); statement.dataWriteOperations().nodeAddLabel(node.getId(), labelId); statement.close(); tx.failure(); tx.success(); tx.finish(); fail("Should have failed"); } catch (TransactionFailureException e) { // Expected } // THEN tx = db.beginTx(); statement = statementContextProvider.instance(); try { statement.readOperations().nodeHasLabel(node.getId(), labelId); fail("should have thrown exception"); } catch (EntityNotFoundException e) { // Yay! } tx.finish(); }
@Test public void transactionStateShouldReflectRemovingLabelImmediately() throws Exception { // GIVEN Transaction tx = db.beginTx(); Statement statement = statementContextProvider.instance(); Node node = db.createNode(); int labelId1 = statement.dataWriteOperations().labelGetOrCreateForName("labello1"); int labelId2 = statement.dataWriteOperations().labelGetOrCreateForName("labello2"); statement.dataWriteOperations().nodeAddLabel(node.getId(), labelId1); statement.dataWriteOperations().nodeAddLabel(node.getId(), labelId2); statement.close(); tx.success(); tx.finish(); tx = db.beginTx(); statement = statementContextProvider.instance(); // WHEN statement.dataWriteOperations().nodeRemoveLabel(node.getId(), labelId2); // THEN PrimitiveIntIterator labelsIterator = statement.readOperations().nodeGetLabels(node.getId()); Set<Integer> labels = asSet(labelsIterator); assertFalse(statement.readOperations().nodeHasLabel(node.getId(), labelId2)); assertEquals(asSet(labelId1), labels); statement.close(); tx.success(); tx.finish(); }
@Test public void shouldRecoverTransactionWhereNodeIsDeletedInTheFuture() throws Exception { // GIVEN Node node; try (Transaction tx = db.beginTx()) { node = db.createNode(label); node.setProperty("key", "value"); tx.success(); } rotateLog(); try (Transaction tx = db.beginTx()) { node.setProperty("other-key", 1); tx.success(); } try (Transaction tx = db.beginTx()) { node.delete(); tx.success(); } flushAll(); // WHEN FileSystemAbstraction uncleanFs = fsRule.snapshot(shutdownDb(db)); db = (GraphDatabaseAPI) new TestGraphDatabaseFactory().setFileSystem(uncleanFs).newImpermanentDatabase(); // THEN // -- really the problem was that recovery threw exception, so mostly assert that. try (Transaction tx = db.beginTx()) { node = db.getNodeById(node.getId()); fail("Should not exist"); } catch (NotFoundException e) { assertEquals("Node " + node.getId() + " not found", e.getMessage()); } }
@Test public void labelShouldBeRemovedAfterCommit() throws Exception { // GIVEN Transaction tx = db.beginTx(); Statement statement = statementContextProvider.instance(); Node node = db.createNode(); int labelId1 = statement.dataWriteOperations().labelGetOrCreateForName("labello1"); statement.dataWriteOperations().nodeAddLabel(node.getId(), labelId1); statement.close(); tx.success(); tx.finish(); // WHEN tx = db.beginTx(); statement = statementContextProvider.instance(); statement.dataWriteOperations().nodeRemoveLabel(node.getId(), labelId1); statement.close(); tx.success(); tx.finish(); // THEN tx = db.beginTx(); statement = statementContextProvider.instance(); PrimitiveIntIterator labels = statement.readOperations().nodeGetLabels(node.getId()); statement.close(); tx.success(); tx.finish(); assertThat(asSet(labels), equalTo(Collections.<Integer>emptySet())); }
@Test public void deletingNodeWithLabelsShouldHaveThoseLabelRemovalsReflectedInTransaction() throws Exception { // GIVEN Transaction tx = db.beginTx(); Label label = label("labello"); Node node = db.createNode(label); tx.success(); tx.finish(); tx = db.beginTx(); Statement statement = statementContextProvider.instance(); // WHEN statement.dataWriteOperations().nodeDelete(node.getId()); // Then int labelId = statement.readOperations().labelGetForName(label.name()); Set<Integer> labels = asSet(statement.readOperations().nodeGetLabels(node.getId())); boolean labelIsSet = statement.readOperations().nodeHasLabel(node.getId(), labelId); Set<Long> nodes = asSet(statement.readOperations().nodesGetForLabel(labelId)); statement.close(); tx.success(); tx.finish(); assertEquals(emptySetOf(Long.class), nodes); assertEquals(emptySetOf(Integer.class), labels); assertFalse("Label should not be set on node here", labelIsSet); }
@Before public void createTestingGraph() { Node node1 = getGraphDb().createNode(); Node node2 = getGraphDb().createNode(); Relationship rel = node1.createRelationshipTo(node2, MyRelTypes.TEST); node1Id = (int) node1.getId(); node2Id = (int) node2.getId(); node1.setProperty(key1, int1); node1.setProperty(key2, string1); node2.setProperty(key1, int2); node2.setProperty(key2, string2); rel.setProperty(key1, int1); rel.setProperty(key2, string1); node1.setProperty(arrayKey, array); node2.setProperty(arrayKey, array); rel.setProperty(arrayKey, array); Transaction tx = getTransaction(); tx.success(); tx.finish(); NodeManager nodeManager = ((EmbeddedGraphDatabase) getGraphDb()).getConfig().getGraphDbModule().getNodeManager(); nodeManager.clearCache(); tx = getGraphDb().beginTx(); setTransaction(tx); }
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; } }
@Override public WeightedPath findSinglePath(Node start, Node end) { lastMetadata = new Metadata(); AStarIterator iterator = new AStarIterator(start, end); while (iterator.hasNext()) { Node node = iterator.next(); GraphDatabaseService graphDb = node.getGraphDatabase(); if (node.equals(end)) { // Hit, return path double weight = iterator.visitData.get(node.getId()).wayLength; LinkedList<Relationship> rels = new LinkedList<Relationship>(); Relationship rel = graphDb.getRelationshipById(iterator.visitData.get(node.getId()).cameFromRelationship); while (rel != null) { rels.addFirst(rel); node = rel.getOtherNode(node); long nextRelId = iterator.visitData.get(node.getId()).cameFromRelationship; rel = nextRelId == -1 ? null : graphDb.getRelationshipById(nextRelId); } Path path = toPath(start, rels); lastMetadata.paths++; return new WeightedPathImpl(weight, path); } } return null; }
public Node getOtherNode(Node node) { if (startNodeId == (int) node.getId()) { return new NodeProxy(endNodeId, nodeManager); } if (endNodeId == (int) node.getId()) { return new NodeProxy(startNodeId, nodeManager); } throw new NotFoundException( "Node[" + node.getId() + "] not connected to this relationship[" + getId() + "]"); }
public Node getOtherNode(NodeManager nodeManager, Node node) { if (getStartNodeId() == node.getId()) { return new NodeProxy(getEndNodeId(), nodeManager); } if (getEndNodeId() == node.getId()) { return new NodeProxy(getStartNodeId(), nodeManager); } throw new NotFoundException( "Node[" + node.getId() + "] not connected to this relationship[" + getId() + "]"); }
public long setupCountryNode() { Transaction tx = graphDb.beginTx(); try { Node countryNode = graphDb.createNode(); countryNode.setProperty("name", "Countries"); template.findOne(countryNode.getId(), CountryEntity.class); tx.success(); return countryNode.getId(); } finally { tx.finish(); } }
static Vertex addNode(Graph graph, Node node) { Vertex vertex = graph.getVertex(node.getId()); if (null == vertex) { vertex = graph.addVertex(node.getId()); copyProperties(node, vertex); Set<String> labels = new HashSet<>(); for (Label label : node.getLabels()) { labels.add(label.name()); } vertex.setProperty("types", labels); } return vertex; }
/** * Default constructor * * @param relationship the relation */ public DotEdge(Relationship relationship) { Node startNode = relationship.getStartNode(); this.startId = ShapeIdPrefix.fromNode(startNode) + startNode.getId(); Node endNode = relationship.getEndNode(); this.endId = ShapeIdPrefix.fromNode(endNode) + endNode.getId(); if (NodeUtils.isScoperelation(relationship.getType())) { this.edgeStyle = EdgeStyle.dotted; } else { this.edgeStyle = EdgeStyle.solid; } this.label = relationship.getType().toString(); }
@Test public void testQueryEndpointMultipleResults() throws Exception { Node andres = createNode("name", "Andres"); Node peter = createNode("name", "Peter"); cypherRsPath.put(ClientResponse.class, "match n where id(n) in {ids} return n"); ClientResponse response = cypherRsPath .queryParam("ids", String.valueOf(andres.getId())) .queryParam("ids", String.valueOf(peter.getId())) .get(ClientResponse.class); String result = response.getEntity(String.class); assertEquals(result, 200, response.getStatus()); assertEquals("[{\"name\":\"Andres\"},{\"name\":\"Peter\"}]", result); }
@Test public void testQueryEndpointMultipleRowsMultipleColumns() throws Exception { Node andres = createNode("name", "Andres"); Node peter = createNode("name", "Peter"); cypherRsPath.put(ClientResponse.class, MULTI_COLUMN_QUERY); ClientResponse response = cypherRsPath .queryParam("ids", String.valueOf(andres.getId())) .queryParam("ids", String.valueOf(peter.getId())) .get(ClientResponse.class); String result = response.getEntity(String.class); assertEquals(result, 200, response.getStatus()); assertEquals("[{\"l\":6,\"name\":\"Andres\"},{\"l\":5,\"name\":\"Peter\"}]", result); }
/** {@inheritDoc} */ @Override public Set<Label> removedLabels(Node node) { initializeChanged(); if (!hasBeenChanged(node)) { LOG.warn(node + " has not been changed but the caller thinks it should have removed labels."); return Collections.emptySet(); } if (!removedLabels.containsKey(node.getId())) { return Collections.emptySet(); } return Collections.unmodifiableSet(removedLabels.get(node.getId())); }
/** {@inheritDoc} */ @Override public boolean hasLabelBeenRemoved(Node node, Label label) { initializeChanged(); if (!hasBeenChanged(node)) { LOG.warn(node + " has not been changed but the caller thinks it should have removed labels."); return false; } if (!removedLabels.containsKey(node.getId())) { return false; } return removedLabels.get(node.getId()).contains(label); }
/** * While we transition ownership from the Beans API to the Kernel API for core database * interactions, there will be a bit of a mess. Our first goal is an architecture like this: * * <p>Users / \ Beans API Cypher \ / Kernel API | Kernel Implementation * * <p>But our current intermediate architecture looks like this: * * <p>Users / \ Beans API <--- Cypher | \ / | Kernel API | | Kernel Implementation * * <p>Meaning Kernel API and Beans API both manipulate the underlying kernel, causing lots of * corner cases. Most notably, those corner cases are related to Transactions, and the interplay * between three transaction APIs: - The Beans API - The JTA Transaction Manager API - The Kernel * TransactionContext API * * <p>In the long term, the goal is for JTA compliant stuff to live outside of the kernel, as an * addon. The Kernel API will rule supreme over the land of transactions. We are a long way away * from there, however, so as a first intermediary step, the JTA transaction manager rules * supreme, and the Kernel API piggybacks on it. * * <p>This test shows us how to use both the Kernel API and the Beans API together in the same * transaction, during the transition phase. */ @Test public void mixingBeansApiWithKernelAPI() throws Exception { // 1: Start your transactions through the Beans API Transaction beansAPITx = db.beginTx(); // 2: Get a hold of a KernelAPI statement context for the *current* transaction this way: Statement statement = statementContextProvider.instance(); // 3: Now you can interact through both the statement context and the kernel API to manipulate // the // same transaction. Node node = db.createNode(); int labelId = statement.dataWriteOperations().labelGetOrCreateForName("labello"); statement.dataWriteOperations().nodeAddLabel(node.getId(), labelId); // 4: Close the StatementContext statement.close(); // 5: Commit through the beans API beansAPITx.success(); beansAPITx.finish(); // NOTE: Transactions are still thread-bound right now, because we use JTA to "own" // transactions, // meaning if you use // both the Kernel API to create transactions while a Beans API transaction is running in the // same // thread, the results are undefined. // When the Kernel API implementation is done, the Kernel API transaction implementation is not // meant // to be bound to threads. }
@Override public List<String> completionCandidates(String partOfLine, Session session) { String lastWord = TextUtil.lastWordOrQuoteOf(partOfLine, false); if (lastWord.startsWith("-")) { return super.completionCandidates(partOfLine, session); } try { TreeSet<String> result = new TreeSet<String>(); NodeOrRelationship current = getCurrent(session); if (current.isNode()) { // TODO Check if -r is supplied Node node = current.asNode(); for (Node otherNode : RelationshipToNodeIterable.wrap(node.getRelationships(), node)) { long otherNodeId = otherNode.getId(); String title = findTitle(getServer(), session, otherNode); if (title != null) { if (!result.contains(title)) { maybeAddCompletionCandidate(result, title + "," + otherNodeId, lastWord); } } maybeAddCompletionCandidate(result, "" + otherNodeId, lastWord); } } else { maybeAddCompletionCandidate(result, START_ALIAS, lastWord); maybeAddCompletionCandidate(result, END_ALIAS, lastWord); Relationship rel = current.asRelationship(); maybeAddCompletionCandidate(result, "" + rel.getStartNode().getId(), lastWord); maybeAddCompletionCandidate(result, "" + rel.getEndNode().getId(), lastWord); } return new ArrayList<String>(result); } catch (ShellException e) { e.printStackTrace(); return super.completionCandidates(partOfLine, session); } }
@Test @Graph(value = {"I know you"}) public void runSimpleQuery() throws Exception { Node i = data.get().get("I"); Representation result = testQuery("start n=node(" + i.getId() + ") return n"); assertTrue(json.assemble(result).contains("I")); }
private Node addNode(EmbeddedGraphDatabase graphDb) { Node referenceNode = graphDb.getReferenceNode(); Node node = graphDb.createNode(); node.setProperty("theId", node.getId()); referenceNode.createRelationshipTo(node, MyRels.TEST); return node; }
private Object toJsonCompatible(Object value) { if (value instanceof Node) { final Node node = (Node) value; final Map<String, Object> result = SubGraph.toMap(node); result.put("_id", node.getId()); return result; } if (value instanceof Relationship) { final Relationship relationship = (Relationship) value; final Map<String, Object> result = SubGraph.toMap(relationship); result.put("_id", relationship.getId()); result.put("_start", relationship.getStartNode().getId()); result.put("_end", relationship.getEndNode().getId()); result.put("_type", relationship.getType().name()); return result; } if (value instanceof Iterable) { final List<Object> result = new ArrayList<Object>(); for (Object inner : (Iterable) value) { result.add(toJsonCompatible(inner)); } return result; } return value; }
@Test public void shouldOverwriteExistingProperties() throws PropertyValueException, NodeNotFoundException { long nodeId; Transaction tx = database.getGraph().beginTx(); try { Node node = database.getGraph().createNode(); node.setProperty("remove me", "trash"); nodeId = node.getId(); tx.success(); } finally { tx.finish(); } Map<String, Object> properties = new HashMap<String, Object>(); properties.put("foo", "bar"); properties.put("baz", 17); actions.setAllNodeProperties(nodeId, properties); tx = database.getGraph().beginTx(); try { Node node = database.getGraph().getNodeById(nodeId); assertHasProperties(node, properties); assertNull(node.getProperty("remove me", null)); } finally { tx.finish(); } }
public Concept getNextConceptToUpdate() { synchronized (lock) { IndexHits<Node> hits = conceptsForUpdate.query( new QueryContext( NumericRangeQuery.newLongRange( NamespaceConstants.DATE_UPDATED, Long.MIN_VALUE, Long.MAX_VALUE, true, true)) .sort( new Sort( new SortField(NamespaceConstants.DATE_UPDATED, SortField.LONG, false)))); if (hits.hasNext()) { Node job = hits.next(); System.out.println(job.getId()); Concept concept = getByNode(job); removeFromCU(concept); return concept; } } return null; }
private long createDb() { GraphDatabaseService graphDb = new GraphDatabaseFactory().newEmbeddedDatabase(DB_PATH); long firstNodeId = -1; Transaction tx = graphDb.beginTx(); try { Node firstNode = graphDb.createNode(); firstNodeId = firstNode.getId(); firstNode.setProperty("message", "Hello, "); firstNode.setProperty( "someJson", "{\n \"is\" : \"vcard\",\n \"name\" : \"Jim Barritt\"\n}"); Node secondNode = graphDb.createNode(); secondNode.setProperty("message", "World!"); Relationship relationship = firstNode.createRelationshipTo(secondNode, KNOWS); relationship.setProperty("message", "brave Neo4j "); tx.success(); return firstNodeId; } finally { tx.finish(); graphDb.shutdown(); } }
/** {@inheritDoc} */ @Override public Set<Label> labelsOfDeletedNode(Node node) { initializeChanged(); if (!hasBeenDeleted(node)) { LOG.error(node + " has not been deleted but the caller thinks it has! This is a bug."); throw new IllegalStateException( node + " has not been deleted but the caller thinks it has! This is a bug."); } if (!deletedNodeLabels.containsKey(node.getId())) { return Collections.emptySet(); } return Collections.unmodifiableSet(deletedNodeLabels.get(node.getId())); }
@Test public void makeSureLazyLoadingRelationshipsWorksEvenIfOtherIteratorAlsoLoadsInTheSameIteration() { int numEdges = 100; /* create 256 nodes */ GraphDatabaseService graphDB = getGraphDb(); Node[] nodes = new Node[256]; for (int num_nodes = 0; num_nodes < nodes.length; num_nodes += 1) { nodes[num_nodes] = graphDB.createNode(); } newTransaction(); /* create random outgoing relationships from node 5 */ Node hub = nodes[4]; int nextID = 7; RelationshipType outtie = withName("outtie"); RelationshipType innie = withName("innie"); for (int k = 0; k < numEdges; k++) { Node neighbor = nodes[nextID]; nextID += 7; nextID &= 255; if (nextID == 0) { nextID = 1; } hub.createRelationshipTo(neighbor, outtie); } newTransaction(); /* create random incoming relationships to node 5 */ for (int k = 0; k < numEdges; k += 1) { Node neighbor = nodes[nextID]; nextID += 7; nextID &= 255; if (nextID == 0) { nextID = 1; } neighbor.createRelationshipTo(hub, innie); } commit(); clearCache(); newTransaction(); hub = graphDB.getNodeById(hub.getId()); int count = 0; for (@SuppressWarnings("unused") Relationship r1 : hub.getRelationships()) { count += count(hub.getRelationships()); } assertEquals(40000, count); count = 0; for (@SuppressWarnings("unused") Relationship r1 : hub.getRelationships()) { count += count(hub.getRelationships()); } assertEquals(40000, count); commit(); }
long createNode() { GraphDatabaseAPI graphdb = server().getDatabase().getGraph(); try (Transaction tx = graphdb.beginTx()) { Node node = graphdb.createNode(); tx.success(); return node.getId(); } }
AStarIterator(Node start, Node end) { this.start = start; this.end = end; Visit visit = new Visit(-1, 0, estimateEvaluator.getCost(start, end)); addNext(start, visit.getFscore(), visit); this.visitData.put(start.getId(), visit); }