Java ResourceIterable类代码示例

import org.neo4j.graphdb.ResourceIterable; //导入依赖的package包/类
@Override
public void run() {
  logger.info("Starting anonymous nodes tagger...");
  int taggedNodes = 0;
  Transaction tx = graphDb.beginTx();

  ResourceIterable<Node> allNodes = graphDb.getAllNodes();
  for (Node n : allNodes) {
    if (n.hasProperty(anonymousProperty)) {
      n.addLabel(OwlLabels.OWL_ANONYMOUS);
      taggedNodes++;
    }
    if (taggedNodes % batchCommitSize == 0) {
      tx.success();
      tx.close();
      tx = graphDb.beginTx();
    }
  }

  logger.info(taggedNodes + " nodes tagged.");
  tx.success();
  tx.close();
}
 

import org.neo4j.graphdb.ResourceIterable; //导入依赖的package包/类
@Override
public void run() {
  logger.info("Starting all nodes labeling...");
  int processedNodes = 0;

  Transaction tx = graphDb.beginTx();

  ResourceIterable<Node> allNodes = graphDb.getAllNodes();
  for (Node n : allNodes) {
    n.addLabel(label);
    if (processedNodes % batchCommitSize == 0) {
      tx.success();
      tx.close();
      tx = graphDb.beginTx();
    }
    processedNodes++;
  }

  logger.info(processedNodes + " nodes labeled.");
  tx.success();
  tx.close();
}
 

import org.neo4j.graphdb.ResourceIterable; //导入依赖的package包/类
public static List<String> getAllNodes(final GraphDatabaseService graphDb,
                                       final String labelName) {

    List<String> nodeIds = new ArrayList<>();
    Label label = DynamicLabel.label(labelName);
    ResourceIterable<Node> nodes;

    try (Transaction tx = graphDb.beginTx()) {
        nodes = GlobalGraphOperations.at(graphDb).getAllNodesWithLabel(label);

        for (Node node : nodes) {
            try {
                nodeIds.add(node.getProperty("node_id").toString());
            } catch (Exception e) {
                LOGGER.warn("Can't find a given node... skipping");
            }
        }

        tx.success();
    }

    return nodeIds;

}
 

import org.neo4j.graphdb.ResourceIterable; //导入依赖的package包/类
@Override
public Set<Integer> getNodesFromCommunity(int community)
{
    Set<Integer> nodes = new HashSet<Integer>();
    try (final Transaction tx = beginUnforcedTransaction())
    {
        try
        {
            ResourceIterable<Node> iter = neo4jGraph.findNodesByLabelAndProperty(NODE_LABEL, COMMUNITY, community);
            for (Node n : iter)
            {
                String nodeIdString = (String) (n.getProperty(NODE_ID));
                nodes.add(Integer.valueOf(nodeIdString));
            }
            tx.success();
        }
        catch (Exception e)
        {
            tx.failure();
            throw new BenchmarkingException("unable to get nodes from community", e);
        }
    }
    return nodes;
}
 

import org.neo4j.graphdb.ResourceIterable; //导入依赖的package包/类
@Override
public void moveNode(int nodeCommunity, int toCommunity)
{
    try (final Transaction tx = beginUnforcedTransaction())
    {
        try
        {
            ResourceIterable<Node> fromIter = neo4jGraph.findNodesByLabelAndProperty(NODE_LABEL, NODE_COMMUNITY,
                nodeCommunity);
            for (Node node : fromIter)
            {
                node.setProperty(COMMUNITY, toCommunity);
            }
            tx.success();
        }
        catch (Exception e)
        {
            tx.failure();
            throw new BenchmarkingException("unable to move node", e);
        }
    }
}
 

import org.neo4j.graphdb.ResourceIterable; //导入依赖的package包/类
@Override
public int getCommunitySize(int community)
{
    Set<Integer> nodeCommunities = new HashSet<Integer>();

    try (final Transaction tx = beginUnforcedTransaction())
    {
        try
        {
            ResourceIterable<Node> nodes = neo4jGraph.findNodesByLabelAndProperty(NODE_LABEL, COMMUNITY, community);
            for (Node n : nodes)
            {
                Integer nodeCommunity = (Integer) (n.getProperty(COMMUNITY));
                nodeCommunities.add(nodeCommunity);
            }
            tx.success();
        }
        catch (Exception e)
        {
            tx.failure();
            throw new BenchmarkingException("unable to get community size", e);
        }
    }

    return nodeCommunities.size();
}
 

import org.neo4j.graphdb.ResourceIterable; //导入依赖的package包/类
@Override
public boolean nodeExists(int nodeId)
{
    try (final Transaction tx = beginUnforcedTransaction())
    {
        try
        {
            ResourceIterable<Node> nodesIter = neo4jGraph.findNodesByLabelAndProperty(NODE_LABEL, NODE_ID, nodeId);
            if (nodesIter.iterator().hasNext())
            {
                tx.success();
                return true;
            }
            tx.success();
        }
        catch (Exception e)
        {
            tx.failure();
            throw new BenchmarkingException("unable to determine if node exists", e);
        }
    }
    return false;
}
 

import org.neo4j.graphdb.ResourceIterable; //导入依赖的package包/类
public List<Root> getAll() {
    List<Root> roots = new ArrayList<>();
    ResourceIterable<Node> nodes = GlobalGraphOperations.at(database).getAllNodesWithLabel(NodeLabels.ROOT);

    for (Node node : nodes) {
        Root root = session.get(Root.class,node);
        roots.add(root);
    }
    return roots;
}
 

import org.neo4j.graphdb.ResourceIterable; //导入依赖的package包/类
public Iterable<Token> getAll() {
    List<Token> tokens = new ArrayList<>();
    ResourceIterable<Node> nodes = GlobalGraphOperations.at(database).getAllNodesWithLabel(NodeLabels.TOKEN);

    for (Node node : nodes) {
        Token root = session.get(Token.class,node);
        tokens.add(root);
    }
    return tokens;
}
 

import org.neo4j.graphdb.ResourceIterable; //导入依赖的package包/类
public static ResourceIterable<Path> create(final List<Node> roots, final TraversalDescription td) {
  return new ResourceIterable<Path>() {
    @Override
    public ResourceIterator<Path> iterator() {
      return new MultiRootPathIterator(roots, td);
    }
  };
}
 

import org.neo4j.graphdb.ResourceIterable; //导入依赖的package包/类
public static ResourceIterable<Node> create(final List<Node> roots, final TraversalDescription td) {
  return new ResourceIterable<Node>() {
    @Override
    public ResourceIterator<Node> iterator() {
      return new MultiRootNodeIterator(roots, td);
    }
  };
}
 

import org.neo4j.graphdb.ResourceIterable; //导入依赖的package包/类
@Override
public Set<Integer> getCommunitiesConnectedToNodeCommunities(int nodeCommunities)
{
    Set<Integer> communities = new HashSet<Integer>();
    try (final Transaction tx = beginUnforcedTransaction())
    {
        try
        {
            ResourceIterable<Node> nodes = neo4jGraph.findNodesByLabelAndProperty(Neo4jGraphDatabase.NODE_LABEL,
                NODE_COMMUNITY, nodeCommunities);
            for (Node n : nodes)
            {
                for (Relationship r : n.getRelationships(RelTypes.SIMILAR, Direction.OUTGOING))
                {
                    Node neighbour = r.getOtherNode(n);
                    Integer community = (Integer) (neighbour.getProperty(COMMUNITY));
                    communities.add(community);
                }
            }
            tx.success();
        }
        catch (Exception e)
        {
            tx.failure();
            throw new BenchmarkingException("unable to get communities connected to node communities", e);
        }
    }

    return communities;
}
 

import org.neo4j.graphdb.ResourceIterable; //导入依赖的package包/类
@Override
public Set<Integer> getNodesFromNodeCommunity(int nodeCommunity)
{
    Set<Integer> nodes = new HashSet<Integer>();

    try (final Transaction tx = beginUnforcedTransaction())
    {
        try
        {
            ResourceIterable<Node> iter = neo4jGraph.findNodesByLabelAndProperty(NODE_LABEL, NODE_COMMUNITY,
                nodeCommunity);
            for (Node n : iter)
            {
                String nodeIdString = (String) (n.getProperty(NODE_ID));
                nodes.add(Integer.valueOf(nodeIdString));
            }
            tx.success();
        }
        catch (Exception e)
        {
            tx.failure();
            throw new BenchmarkingException("unable to get nodes from node community", e);
        }
    }

    return nodes;
}
 

import org.neo4j.graphdb.ResourceIterable; //导入依赖的package包/类
@Override
public double getEdgesInsideCommunity(int nodeCommunity, int communityNodes)
{
    double edges = 0;
    try (final Transaction tx = beginUnforcedTransaction())
    {
        try
        {
            ResourceIterable<Node> nodes = neo4jGraph.findNodesByLabelAndProperty(NODE_LABEL, NODE_COMMUNITY,
                nodeCommunity);
            ResourceIterable<Node> comNodes = neo4jGraph.findNodesByLabelAndProperty(NODE_LABEL, COMMUNITY,
                communityNodes);
            for (Node node : nodes)
            {
                Iterable<Relationship> relationships = node.getRelationships(RelTypes.SIMILAR, Direction.OUTGOING);
                for (Relationship r : relationships)
                {
                    Node neighbor = r.getOtherNode(node);
                    if (Iterables.contains(comNodes, neighbor))
                    {
                        edges++;
                    }
                }
            }
            tx.success();
        }
        catch (Exception e)
        {
            tx.failure();
            throw new BenchmarkingException("unable to get edges inside community", e);
        }
    }

    return edges;
}
 

import org.neo4j.graphdb.ResourceIterable; //导入依赖的package包/类
@Override
public double getCommunityWeight(int community)
{
    double communityWeight = 0;
    try (final Transaction tx = beginUnforcedTransaction())
    {
        try
        {
            ResourceIterable<Node> iter = neo4jGraph.findNodesByLabelAndProperty(NODE_LABEL, COMMUNITY, community);
            if (Iterables.size(iter) > 1)
            {
                for (Node n : iter)
                {
                    communityWeight += getNodeOutDegree(n);
                }
            }
            tx.success();
        }
        catch (Exception e)
        {
            tx.failure();
            throw new BenchmarkingException("unable to get community weight", e);
        }
    }

    return communityWeight;
}