org.neo4j.graphdb.ResourceIterator Java Examples

private Node getNode(Label label, String key, Object value) {
	Node node = null;
	try (Transaction tx = graphDb.beginTx()) {
		ResourceIterator<Node> nodes = null;
		if (label != null){
			nodes = graphDb.findNodesByLabelAndProperty(
				label, key, value).iterator();
		}
		else {
			String validValue = StringEscapeUtils.escapeJavaScript((String) value);
			ExecutionEngine engine = new ExecutionEngine(graphDb);
			nodes = engine.execute(
					"START n=node(*)"
					+ " WHERE n." + key + "=\"" + validValue + "\""
					+ " RETURN n").columnAs("n");
			
		}
		if (nodes.hasNext()) {
			node = nodes.next();
		}
		nodes.close();
	}
	return node;
}
 

@Override
protected <T> ResultIterable<T> find(EmbeddedLabel label, PropertyMetadata datastoreMetadata, Object datastoreValue) {
    String propertyName = datastoreMetadata.getName();
    ResourceIterator<Node> iterator = graphDatabaseService.findNodes(label.getDelegate(), propertyName, datastoreValue);
    return xoSession.toResult(new ResultIterator<EmbeddedNode>() {

        @Override
        public boolean hasNext() {
            return iterator.hasNext();
        }

        @Override
        public EmbeddedNode next() {
            return new EmbeddedNode(iterator.next());
        }

        @Override
        public void close() {
            iterator.close();
        }
    });
}
 

@Test
public void bootstrap() throws URISyntaxException {
    GraphDatabaseService graphDatabaseService = new TestGraphDatabaseFactory().newImpermanentDatabase();
    Properties properties = new Properties();
    properties.put(GraphDatabaseService.class.getName(), graphDatabaseService);
    XOUnit xoUnit = XOUnit.builder().uri(new URI("graphDb:///")).provider(EmbeddedNeo4jXOProvider.class).types(singletonList(A.class))
            .properties(properties).build();
    XOManagerFactory xoManagerFactory = XO.createXOManagerFactory(xoUnit);
    XOManager xoManager = xoManagerFactory.createXOManager();
    xoManager.currentTransaction().begin();
    A a = xoManager.create(A.class);
    a.setName("Test");
    xoManager.currentTransaction().commit();
    xoManager.close();
    xoManagerFactory.close();
    try (Transaction transaction = graphDatabaseService.beginTx()) {
        ResourceIterator<Node> iterator = graphDatabaseService.findNodes(label("A"), "name", "Test");
        assertThat(iterator.hasNext(), equalTo(true));
        Node node = iterator.next();
        assertThat(node.hasLabel(label("A")), equalTo(true));
        assertThat(node.getProperty("name"), equalTo((Object) "Test"));
        transaction.success();
    }
}
 

public Node getOrCreate(String nodeId)
{
    Node result = null;

    try(final Transaction tx = ((GraphDatabaseAPI) neo4jGraph).tx().unforced().begin())
    {
        try
        {
            String queryString = "MERGE (n:Node {nodeId: {nodeId}}) RETURN n";
            Map<String, Object> parameters = new HashMap<String, Object>();
            parameters.put("nodeId", nodeId);
            ResourceIterator<Node> resultIterator = engine.execute(queryString, parameters).columnAs("n");
            result = resultIterator.next();
            tx.success();
        }
        catch (Exception e)
        {
            tx.failure();
            throw new BenchmarkingException("unable to get or create node " + nodeId, e);
        }
    }

    return result;
}
 

/***
 * Manage a reachability index object on a graph
 * 
 * @param graphDb
 *          The graph on which to build the reachability index
 */
@Inject
public ReachabilityIndex(GraphDatabaseService graphDb) {
  this.graphDb = graphDb;
  try (Transaction tx = graphDb.beginTx()) {
    ResourceIterator<Node> nodes = graphDb.findNodes(REACHABILITY_METADATA);
    metaDataNode = getOnlyElement(nodes, graphDb.createNode(REACHABILITY_METADATA));
    tx.success();
  }
}
 

@Test
public void canBeTransformedToTinkerGraph() {
  TinkerGraphUtil tgu = new TinkerGraphUtil(curieUtil);
  ResourceIterator<Node> nodes = graphDb.getAllNodes().iterator();
  while (nodes.hasNext()) {
    tgu.addElement(nodes.next());
  }
  ResourceIterator<Relationship> relationships = graphDb.getAllRelationships().iterator();
  while (relationships.hasNext()) {
    tgu.addElement(relationships.next());
  }
}
 

public CodeIndexes(GraphDatabaseService db) {
    try (Transaction tx = db.beginTx()) {
        ResourceIterator<Node> nodes = db.getAllNodes().iterator();
        Set<Node> codeNodes = new HashSet<>();
        while (nodes.hasNext()) {
            Node node = nodes.next();
            if (node.hasLabel(Label.label(JavaCodeExtractor.CLASS)) || node.hasLabel(Label.label(JavaCodeExtractor.INTERFACE)) || node.hasLabel(Label.label(JavaCodeExtractor.METHOD))) {
                codeNodes.add(node);
            }
        }

        for (Node codeNode : codeNodes) {
            String name = "";
            boolean type = true;
            if (codeNode.hasLabel(Label.label(JavaCodeExtractor.CLASS)))
                name = (String) codeNode.getProperty(JavaCodeExtractor.CLASS_FULLNAME);
            if (codeNode.hasLabel(Label.label(JavaCodeExtractor.INTERFACE)))
                name = (String) codeNode.getProperty(JavaCodeExtractor.INTERFACE_FULLNAME);
            if (codeNode.hasLabel(Label.label(JavaCodeExtractor.METHOD))) {
                name = codeNode.getProperty(JavaCodeExtractor.METHOD_BELONGTO) + "." + codeNode.getProperty(JavaCodeExtractor.METHOD_NAME);
                type = false;
            }
            if (name.contains("$"))
                continue;
            if (type) {
                typeMap.put(name, codeNode.getId());
                idToTypeNameMap.put(codeNode.getId(), name);
                String shortName = name;
                int p = shortName.lastIndexOf('.');
                if (p > 0)
                    shortName = shortName.substring(p + 1, shortName.length());
                if (!typeShortNameMap.containsKey(shortName))
                    typeShortNameMap.put(shortName, new HashSet<>());
                typeShortNameMap.get(shortName).add(codeNode.getId());
            } else {
                if (!methodMap.containsKey(name))
                    methodMap.put(name, new HashSet<>());
                methodMap.get(name).add(codeNode.getId());
                idToMethodNameMap.put(codeNode.getId(), name);
                int p1 = name.lastIndexOf('.');
                int p2 = name.lastIndexOf('.', p1 - 1);
                String midName, shortName;
                if (p2 > 0) {
                    midName = name.substring(p2 + 1);
                    shortName = name.substring(p1 + 1);
                } else {
                    midName = name;
                    shortName = name.substring(p1 + 1);
                }
                if (!methodMidNameMap.containsKey(midName))
                    methodMidNameMap.put(midName, new HashSet<>());
                methodMidNameMap.get(midName).add(codeNode.getId());
                if (!methodShortNameMap.containsKey(shortName))
                    methodShortNameMap.put(shortName, new HashSet<>());
                methodShortNameMap.get(shortName).add(codeNode.getId());
            }
        }

        tx.success();
    }
}