private Node setLabels(Node node, Collection<String> labels) { if (labels==null || labels.isEmpty()) return node; for (String label : labels) { node.addLabel(DynamicLabel.label(label)); } return node; }
public class FriendOfAFriendDepth4 { public static final Label USER = DynamicLabel.label("User"); private final TraversalDescription traversalDescription; private final GraphDatabaseService db; public FriendOfAFriendDepth4(GraphDatabaseService db) { this.db = db; traversalDescription = traversalDescription(db); } private TraversalDescription traversalDescription(GraphDatabaseService db) { return db.traversalDescription() .breadthFirst() .uniqueness(NODE_GLOBAL) .relationships(withName("FRIEND")) .evaluator( new Evaluator() { @Override public Evaluation evaluate(Path path) { if (path.length() == 4) { return Evaluation.INCLUDE_AND_PRUNE; } return Evaluation.EXCLUDE_AND_CONTINUE; } }); } public Iterable<Node> getFriends(String name) { ResourceIterable<Node> users = db.findNodesByLabelAndProperty(USER, "name", name); Node startNode = IteratorUtil.single(users); return traversalDescription.traverse(startNode).nodes(); } }
private static List<Double> getWeightVectorForClass( Map<String, List<LinkedHashMap<String, Object>>> documents, String key, List<Integer> featureIndexList, GraphDatabaseService db) { List<Double> weightVector; Transaction tx = db.beginTx(); // Get class id Long classId = db.findNodesByLabelAndProperty(DynamicLabel.label("Class"), "name", key) .iterator() .next() .getId(); // Get weight vector for class List<Long> longs = documents .get(key) .stream() .map(a -> ((Integer) a.get("feature")).longValue()) .collect(Collectors.toList()); weightVector = featureIndexList .stream() .map(i -> longs.contains(i.longValue()) ? tfidf(db, i.longValue(), classId) : 0.0) .collect(Collectors.toList()); tx.success(); tx.close(); return weightVector; }
@Test public void deletedNewLabelShouldNotInfluenceEquality() { // bug test try (Transaction tx = database.beginTx()) { database.createNode(DynamicLabel.label("Accident")); database.createNode(DynamicLabel.label("RealLabel")); tx.success(); } try (Transaction tx = database.beginTx()) { database.getNodeById(0).delete(); tx.success(); } String cypher = "CREATE (n:RealLabel)"; assertSameGraph(database, cypher); }
@Override protected ConstraintDefinition obtainEntityInTransaction( GraphDatabaseService graphDatabaseService) { return graphDatabaseService .schema() .constraintFor(DynamicLabel.label("Label")) .assertPropertyIsUnique("property") .create(); }
private Label[] toLabels(Collection<String> labels) { if (labels==null || labels.isEmpty()) return NO_LABELS; Label[] labelArray = new Label[labels.size()]; int i=0; for (String label : labels) { labelArray[i++]= DynamicLabel.label(label); } return labelArray; }
@Test public void listing3_10_node_labels() { usersAndMovies.addLabelToMovies(); try (Transaction tx = graphDb.beginTx()) { ResourceIterable<Node> movies = GlobalGraphOperations.at(graphDb).getAllNodesWithLabel(DynamicLabel.label("MOVIES")); assertEquals(3, IteratorUtil.count(movies)); tx.success(); } }
private static List<Node> getAllClasses(GraphDatabaseService db) { Transaction tx = db.beginTx(); // Get classes using Java API final List<Node> finalClasses = new ArrayList<>(); GlobalGraphOperations.at(db) .getAllNodesWithLabel(DynamicLabel.label("Class")) .forEach(a -> finalClasses.add(a)); tx.success(); tx.close(); return finalClasses.stream().map(a -> a).collect(Collectors.toList()); }
public static int getDocumentSize(GraphDatabaseService db) { int documentSize; String cacheKey = "GLOBAL_DOCUMENT_SIZE"; if (vectorSpaceModelCache.getIfPresent(cacheKey) == null) { documentSize = IteratorUtil.count( GlobalGraphOperations.at(db).getAllNodesWithLabel(DynamicLabel.label("Class"))); vectorSpaceModelCache.put(cacheKey, documentSize); } else { documentSize = (Integer) vectorSpaceModelCache.getIfPresent(cacheKey); } return documentSize; }
@Test public void listing3_11_node_labels_and_property() { try { usersAndMovies.addLabelToMovies(); } catch (Exception e) { // ignore if index already exist } try (Transaction tx = graphDb.beginTx()) { ResourceIterable<Node> movies = graphDb.findNodesByLabelAndProperty(DynamicLabel.label("MOVIES"), "name", "Fargo"); assertEquals(1, IteratorUtil.count(movies)); tx.success(); } }
private static List<Integer> getFeatureIndexList(GraphDatabaseService db) { Transaction tx = db.beginTx(); // Get classes using Java API final List<Node> patterns = new ArrayList<>(); GlobalGraphOperations.at(db) .getAllNodesWithLabel(DynamicLabel.label("Pattern")) .forEach(a -> patterns.add(a)); Collections.sort( patterns, (a, b) -> ((Integer) b.getProperty("threshold")) .compareTo(((Integer) a.getProperty("threshold")))); List<Integer> patternIds = patterns.stream().map(a -> ((Long) a.getId()).intValue()).collect(Collectors.toList()); tx.success(); tx.close(); return patternIds; }
@Override public boolean include(Node node) { return !(node.hasLabel(DynamicLabel.label("ChangeSet"))); }
@Override public boolean include(Node node) { return node.hasLabel(DynamicLabel.label("Blue")); }
public class IndexingAcceptanceTest { /* This test is a bit interesting. It tests a case where we've got a property that sits in one * property block and the value is of a long type. So given that plus that there's an index for that * label/property, do an update that changes the long value into a value that requires two property blocks. * This is interesting because the transaction logic compares before/after views per property record and * not per node as a whole. * * In this case this change will be converted into one "add" and one "remove" property updates instead of * a single "change" property update. At the very basic level it's nice to test for this corner-case so * that the externally observed behavior is correct, even if this test doesn't assert anything about * the underlying add/remove vs. change internal details. */ @Test public void shouldInterpretPropertyAsChangedEvenIfPropertyMovesFromOneRecordToAnother() throws Exception { // GIVEN GraphDatabaseService beansAPI = dbRule.getGraphDatabaseAPI(); long smallValue = 10L, bigValue = 1L << 62; Node myNode; { try (Transaction tx = beansAPI.beginTx()) { myNode = beansAPI.createNode(LABEL1); myNode.setProperty("pad0", true); myNode.setProperty("pad1", true); myNode.setProperty("pad2", true); // Use a small long here which will only occupy one property block myNode.setProperty("key", smallValue); tx.success(); } } { IndexDefinition indexDefinition; try (Transaction tx = beansAPI.beginTx()) { indexDefinition = beansAPI.schema().indexFor(LABEL1).on("key").create(); tx.success(); } waitForIndex(beansAPI, indexDefinition); } // WHEN try (Transaction tx = beansAPI.beginTx()) { // A big long value which will occupy two property blocks myNode.setProperty("key", bigValue); tx.success(); } // THEN assertThat( findNodesByLabelAndProperty(LABEL1, "key", bigValue, beansAPI), containsOnly(myNode)); assertThat(findNodesByLabelAndProperty(LABEL1, "key", smallValue, beansAPI), isEmpty()); } @Test public void shouldUseDynamicPropertiesToIndexANodeWhenAddedAlongsideExistingPropertiesInASeparateTransaction() throws Exception { // Given GraphDatabaseService beansAPI = dbRule.getGraphDatabaseAPI(); // When long id; { try (Transaction tx = beansAPI.beginTx()) { Node myNode = beansAPI.createNode(); id = myNode.getId(); myNode.setProperty("key0", true); myNode.setProperty("key1", true); tx.success(); } } { IndexDefinition indexDefinition; try (Transaction tx = beansAPI.beginTx()) { indexDefinition = beansAPI.schema().indexFor(LABEL1).on("key2").create(); tx.success(); } waitForIndex(beansAPI, indexDefinition); } Node myNode; { try (Transaction tx = beansAPI.beginTx()) { myNode = beansAPI.getNodeById(id); myNode.addLabel(LABEL1); myNode.setProperty("key2", LONG_STRING); myNode.setProperty("key3", LONG_STRING); tx.success(); } } // Then assertThat(myNode, inTx(beansAPI, hasProperty("key2").withValue(LONG_STRING))); assertThat(myNode, inTx(beansAPI, hasProperty("key3").withValue(LONG_STRING))); assertThat( findNodesByLabelAndProperty(LABEL1, "key2", LONG_STRING, beansAPI), containsOnly(myNode)); } @Test public void searchingForNodeByPropertyShouldWorkWithoutIndex() throws Exception { // Given GraphDatabaseService beansAPI = dbRule.getGraphDatabaseService(); Node myNode = createNode(beansAPI, map("name", "Hawking"), LABEL1); // When assertThat( findNodesByLabelAndProperty(LABEL1, "name", "Hawking", beansAPI), containsOnly(myNode)); } @Test public void searchingUsesIndexWhenItExists() throws Exception { // Given GraphDatabaseService beansAPI = dbRule.getGraphDatabaseService(); Node myNode = createNode(beansAPI, map("name", "Hawking"), LABEL1); createIndex(beansAPI, LABEL1, "name"); // When assertThat( findNodesByLabelAndProperty(LABEL1, "name", "Hawking", beansAPI), containsOnly(myNode)); } @Test public void shouldCorrectlyUpdateIndexesWhenChangingLabelsAndPropertyAtTheSameTime() throws Exception { // Given GraphDatabaseService beansAPI = dbRule.getGraphDatabaseService(); Node myNode = createNode(beansAPI, map("name", "Hawking"), LABEL1, LABEL2); createIndex(beansAPI, LABEL1, "name"); createIndex(beansAPI, LABEL2, "name"); createIndex(beansAPI, LABEL3, "name"); // When try (Transaction tx = beansAPI.beginTx()) { myNode.removeLabel(LABEL1); myNode.addLabel(LABEL3); myNode.setProperty("name", "Einstein"); tx.success(); } // Then assertThat(myNode, inTx(beansAPI, hasProperty("name").withValue("Einstein"))); assertThat(labels(myNode), containsOnly(LABEL2, LABEL3)); assertThat(findNodesByLabelAndProperty(LABEL1, "name", "Hawking", beansAPI), isEmpty()); assertThat(findNodesByLabelAndProperty(LABEL1, "name", "Einstein", beansAPI), isEmpty()); assertThat(findNodesByLabelAndProperty(LABEL2, "name", "Hawking", beansAPI), isEmpty()); assertThat( findNodesByLabelAndProperty(LABEL2, "name", "Einstein", beansAPI), containsOnly(myNode)); assertThat(findNodesByLabelAndProperty(LABEL3, "name", "Hawking", beansAPI), isEmpty()); assertThat( findNodesByLabelAndProperty(LABEL3, "name", "Einstein", beansAPI), containsOnly(myNode)); } @Test public void shouldCorrectlyUpdateIndexesWhenChangingLabelsAndPropertyMultipleTimesAllAtOnce() throws Exception { // Given GraphDatabaseService beansAPI = dbRule.getGraphDatabaseService(); Node myNode = createNode(beansAPI, map("name", "Hawking"), LABEL1, LABEL2); createIndex(beansAPI, LABEL1, "name"); createIndex(beansAPI, LABEL2, "name"); createIndex(beansAPI, LABEL3, "name"); // When try (Transaction tx = beansAPI.beginTx()) { myNode.addLabel(LABEL3); myNode.setProperty("name", "Einstein"); myNode.removeLabel(LABEL1); myNode.setProperty("name", "Feynman"); tx.success(); } // Then assertThat(myNode, inTx(beansAPI, hasProperty("name").withValue("Feynman"))); assertThat(labels(myNode), containsOnly(LABEL2, LABEL3)); assertThat(findNodesByLabelAndProperty(LABEL1, "name", "Hawking", beansAPI), isEmpty()); assertThat(findNodesByLabelAndProperty(LABEL1, "name", "Einstein", beansAPI), isEmpty()); assertThat(findNodesByLabelAndProperty(LABEL1, "name", "Feynman", beansAPI), isEmpty()); assertThat(findNodesByLabelAndProperty(LABEL2, "name", "Hawking", beansAPI), isEmpty()); assertThat(findNodesByLabelAndProperty(LABEL1, "name", "Einstein", beansAPI), isEmpty()); assertThat( findNodesByLabelAndProperty(LABEL2, "name", "Feynman", beansAPI), containsOnly(myNode)); assertThat(findNodesByLabelAndProperty(LABEL3, "name", "Hawking", beansAPI), isEmpty()); assertThat(findNodesByLabelAndProperty(LABEL1, "name", "Einstein", beansAPI), isEmpty()); assertThat( findNodesByLabelAndProperty(LABEL3, "name", "Feynman", beansAPI), containsOnly(myNode)); } @Test public void searchingByLabelAndPropertyReturnsEmptyWhenMissingLabelOrProperty() throws Exception { // Given GraphDatabaseService beansAPI = dbRule.getGraphDatabaseService(); // When/Then assertThat(findNodesByLabelAndProperty(LABEL1, "name", "Hawking", beansAPI), isEmpty()); } @Test public void shouldSeeIndexUpdatesWhenQueryingOutsideTransaction() throws Exception { // GIVEN GraphDatabaseService beansAPI = dbRule.getGraphDatabaseService(); createIndex(beansAPI, LABEL1, "name"); Node firstNode = createNode(beansAPI, map("name", "Mattias"), LABEL1); // WHEN THEN assertThat( findNodesByLabelAndProperty(LABEL1, "name", "Mattias", beansAPI), containsOnly(firstNode)); Node secondNode = createNode(beansAPI, map("name", "Taylor"), LABEL1); assertThat( findNodesByLabelAndProperty(LABEL1, "name", "Taylor", beansAPI), containsOnly(secondNode)); } @Test public void createdNodeShouldShowUpWithinTransaction() throws Exception { // GIVEN GraphDatabaseService beansAPI = dbRule.getGraphDatabaseService(); createIndex(beansAPI, LABEL1, "name"); // WHEN Transaction tx = beansAPI.beginTx(); Node firstNode = createNode(beansAPI, map("name", "Mattias"), LABEL1); 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)); } @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)); } @Test public void createdNodeShouldShowUpInIndexQuery() throws Exception { // GIVEN GraphDatabaseService beansAPI = dbRule.getGraphDatabaseService(); createIndex(beansAPI, LABEL1, "name"); createNode(beansAPI, map("name", "Mattias"), LABEL1); // WHEN Transaction tx = beansAPI.beginTx(); long sizeBeforeDelete = count(beansAPI.findNodes(LABEL1, "name", "Mattias")); createNode(beansAPI, map("name", "Mattias"), LABEL1); long sizeAfterDelete = count(beansAPI.findNodes(LABEL1, "name", "Mattias")); tx.close(); // THEN assertThat(sizeBeforeDelete, equalTo(1l)); assertThat(sizeAfterDelete, equalTo(2l)); } @Test public void shouldBeAbleToQuerySupportedPropertyTypes() throws Exception { // GIVEN String property = "name"; GraphDatabaseService db = dbRule.getGraphDatabaseService(); createIndex(db, LABEL1, property); // WHEN & THEN assertCanCreateAndFind(db, LABEL1, property, "A String"); assertCanCreateAndFind(db, LABEL1, property, true); assertCanCreateAndFind(db, LABEL1, property, false); assertCanCreateAndFind(db, LABEL1, property, (byte) 56); assertCanCreateAndFind(db, LABEL1, property, 'z'); assertCanCreateAndFind(db, LABEL1, property, (short) 12); assertCanCreateAndFind(db, LABEL1, property, 12); assertCanCreateAndFind(db, LABEL1, property, 12l); assertCanCreateAndFind(db, LABEL1, property, (float) 12.); assertCanCreateAndFind(db, LABEL1, property, 12.); assertCanCreateAndFind(db, LABEL1, property, new String[] {"A String"}); assertCanCreateAndFind(db, LABEL1, property, new boolean[] {true}); assertCanCreateAndFind(db, LABEL1, property, new Boolean[] {false}); assertCanCreateAndFind(db, LABEL1, property, new byte[] {56}); assertCanCreateAndFind(db, LABEL1, property, new Byte[] {57}); assertCanCreateAndFind(db, LABEL1, property, new char[] {'a'}); assertCanCreateAndFind(db, LABEL1, property, new Character[] {'b'}); assertCanCreateAndFind(db, LABEL1, property, new short[] {12}); assertCanCreateAndFind(db, LABEL1, property, new Short[] {13}); assertCanCreateAndFind(db, LABEL1, property, new int[] {14}); assertCanCreateAndFind(db, LABEL1, property, new Integer[] {15}); assertCanCreateAndFind(db, LABEL1, property, new long[] {16l}); assertCanCreateAndFind(db, LABEL1, property, new Long[] {17l}); assertCanCreateAndFind(db, LABEL1, property, new float[] {(float) 18.}); assertCanCreateAndFind(db, LABEL1, property, new Float[] {(float) 19.}); assertCanCreateAndFind(db, LABEL1, property, new double[] {20.}); assertCanCreateAndFind(db, LABEL1, property, new Double[] {21.}); } @Test public void shouldRetrieveMultipleNodesWithSameValueFromIndex() throws Exception { // this test was included here for now as a precondition for the following test // given GraphDatabaseService graph = dbRule.getGraphDatabaseService(); createIndex(graph, LABEL1, "name"); Node node1, node2; try (Transaction tx = graph.beginTx()) { node1 = graph.createNode(LABEL1); node1.setProperty("name", "Stefan"); node2 = graph.createNode(LABEL1); node2.setProperty("name", "Stefan"); tx.success(); } try (Transaction tx = graph.beginTx()) { ResourceIterator<Node> result = graph.findNodes(LABEL1, "name", "Stefan"); assertEquals(asSet(node1, node2), asSet(result)); tx.success(); } } @Test(expected = MultipleFoundException.class) public void shouldThrowWhenMulitpleResultsForSingleNode() throws Exception { // given GraphDatabaseService graph = dbRule.getGraphDatabaseService(); createIndex(graph, LABEL1, "name"); Node node1, node2; try (Transaction tx = graph.beginTx()) { node1 = graph.createNode(LABEL1); node1.setProperty("name", "Stefan"); node2 = graph.createNode(LABEL1); node2.setProperty("name", "Stefan"); tx.success(); } try (Transaction tx = graph.beginTx()) { graph.findNode(LABEL1, "name", "Stefan"); } } 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(); } } public static final String LONG_STRING = "a long string that has to be stored in dynamic records"; public @Rule ImpermanentDatabaseRule dbRule = new ImpermanentDatabaseRule(); private Label LABEL1 = DynamicLabel.label("LABEL1"); private Label LABEL2 = DynamicLabel.label("LABEL2"); private Label LABEL3 = DynamicLabel.label("LABEL3"); private Node createNode( GraphDatabaseService beansAPI, Map<String, Object> properties, Label... labels) { try (Transaction tx = beansAPI.beginTx()) { Node node = beansAPI.createNode(labels); for (Map.Entry<String, Object> property : properties.entrySet()) node.setProperty(property.getKey(), property.getValue()); tx.success(); return node; } } private Neo4jMatchers.Deferred<Label> labels(final Node myNode) { return new Neo4jMatchers.Deferred<Label>(dbRule.getGraphDatabaseService()) { @Override protected Iterable<Label> manifest() { return myNode.getLabels(); } }; } }
@Override public void call(GlobalGraphOperations self) { self.getAllNodesWithLabel(DynamicLabel.label("Label")); }