Java GlobalGraphOperations类代码示例

import org.neo4j.tooling.GlobalGraphOperations; //导入依赖的package包/类
private GraphStructure executeForestFireModel(GraphStructure graph, ForestFireModelParameters parameters,
		boolean directed) {
	GraphDatabaseService database = ValidationGraphLoader.loadValidationGraphToDatabase(graph);
	new ForestFireModelComputation(database, parameters, directed).run();

	Map<Long, Set<Long>> edgeLists = new HashMap<>();
	try (Transaction ignored = database.beginTx()) {
		for (Node node : GlobalGraphOperations.at(database).getAllNodes()) {
			edgeLists.put((long)node.getProperty(ID_PROPERTY), new HashSet<Long>());
		}
		for (Relationship relationship : GlobalGraphOperations.at(database).getAllRelationships()) {
			if (relationship.isType(EDGE)) {
				edgeLists.get(relationship.getStartNode().getProperty(ID_PROPERTY))
						.add((long)relationship.getEndNode().getProperty(ID_PROPERTY));
			}
		}
	}
	database.shutdown();
	return new GraphStructure(edgeLists);
}
 

import org.neo4j.tooling.GlobalGraphOperations; //导入依赖的package包/类
private BreadthFirstSearchOutput executeBreadthFirstSearch(GraphStructure graph,
		BreadthFirstSearchParameters parameters, boolean directed) {
	GraphDatabaseService database = ValidationGraphLoader.loadValidationGraphToDatabase(graph);
	new BreadthFirstSearchComputation(database, parameters.getSourceVertex(), directed).run();

	Map<Long, Long> output = new HashMap<>();
	try (Transaction ignored = database.beginTx()) {
		for (Node node : GlobalGraphOperations.at(database).getAllNodes()) {
			if (node.hasProperty(DISTANCE)) {
				output.put((long)node.getProperty(ID_PROPERTY), (long)node.getProperty(DISTANCE));
			} else {
				output.put((long)node.getProperty(ID_PROPERTY), Long.MAX_VALUE);
			}
		}
	}
	database.shutdown();
	return new BreadthFirstSearchOutput(output);
}
 

import org.neo4j.tooling.GlobalGraphOperations; //导入依赖的package包/类
@Override
public IGraphIterable<IGraphNode> allNodes(String label) {

	if (graph != null) {

		GlobalGraphOperations g = GlobalGraphOperations.at(graph);

		return (label == null) ? (new Neo4JIterable<IGraphNode>(
				g.getAllNodes(), this)) : (new Neo4JIterable<IGraphNode>(
				g.getAllNodesWithLabel(Neo4JBatchUtil.createLabel(label)),
				this));

	} else {
		LOGGER.warn("allNodes called in a batch isert mode, please exit batch insert first, returning null");
		return null;
	}
}
 

import org.neo4j.tooling.GlobalGraphOperations; //导入依赖的package包/类
@GET
@Path("/warmup")
public Response warmUp(@Context GraphDatabaseService db) throws IOException {
    try ( Transaction tx = db.beginTx() )
    {

        for (Node node : GlobalGraphOperations.at(db).getAllNodes()) {
            node.getPropertyKeys();
        }

        for ( Relationship relationship : GlobalGraphOperations.at(db).getAllRelationships()){
            relationship.getPropertyKeys();
            relationship.getNodes();
        }
    }

    Map<String, String> results = new HashMap<String,String>(){{
        put("response","Warmed up and ready to go!");
    }};

    return Response.ok().entity(objectMapper.writeValueAsString(results)).build();
}
 

import org.neo4j.tooling.GlobalGraphOperations; //导入依赖的package包/类
public void analyzePartitions() {
    // Query the nodes by label, which each set becomes a partition for analysis
    Transaction tx = graphDatabaseService.beginTx();

    Iterator<Node> partitions = GlobalGraphOperations.at(graphDatabaseService)
            .getAllNodesWithLabel(DynamicLabel.label(label))
            .iterator();

    // For each partition, query the target relationships between the partition
    partitions.forEachRemaining(partition -> {
        PartitionDescription partitionDescription = new PartitionDescription(partition.getId(), label);
        partitionDescription.setGroupRelationship(groupRelationship);
        partitionDescription.setTargetRelationship(targetRelationship);
        try {
            Path pt = Writer.exportPartitionToHDFSParallel(graphDatabaseService, partition, partitionDescription);
            if(pt != null)
                Writer.dispatchPartitionedJob(graphDatabaseService, type, partitionDescription, pt);
        } catch (IOException | URISyntaxException e) {
            e.printStackTrace();
        }
    });

    tx.success();
    tx.close();
}
 

import org.neo4j.tooling.GlobalGraphOperations; //导入依赖的package包/类
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()
            .filter(a -> getFeatureMatchDistribution(db, a.getId()) > CONFIDENCE_INTERVAL)
            .map(a -> ((Long)a.getId()).intValue()).collect(Collectors.toList());

    tx.success();
    tx.close();

    return patternIds;
}
 

import org.neo4j.tooling.GlobalGraphOperations; //导入依赖的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.tooling.GlobalGraphOperations; //导入依赖的package包/类
private String ExportDot(Iterable<Node> nodes)
{
	OutputStream out = new ByteArrayOutputStream();

	GraphvizWriter writer = new GraphvizWriter();

	Iterable<RelationshipType> types = GlobalGraphOperations.at(graph_db).getAllRelationshipTypes();

	try
	{
		writer.emit(out, Walker.crosscut(nodes
			, Iterables.toArray(types, RelationshipType.class)));
	}
	catch(IOException e)
	{
		throw new ExceptionModelFail
			("Traverse during export to .dot file failed: "
				+ e.getMessage());
	}

	return out.toString();
}
 

import org.neo4j.tooling.GlobalGraphOperations; //导入依赖的package包/类
protected void primeRegistryByGraph(GraphDatabaseService graph){
	LayoutDataRegistry registry = LayoutDataRegistry.getInstance();

	for(Node n : GlobalGraphOperations.at(graph).getAllNodes()){
		ForceAtlas2LayoutData nLayout = registry.setLayoutData(n, new ForceAtlas2LayoutData());

		nLayout.old_dx = (Double)n.getProperty(PREFIX_odx, 0.0); 
		nLayout.old_dy = (Double)n.getProperty(PREFIX_ody, 0.0);
		nLayout.dx = (Double)n.getProperty(PREFIX_dx, 0.0);
		nLayout.dy = (Double)n.getProperty(PREFIX_dy, 0.0);
		nLayout.mass = (Double)n.getProperty(PREFIX_mass, 1+n.getDegree());
		nLayout.size = (Double)n.getProperty(PREFIX_size, 0.0);

		nLayout.x = (Double)n.getProperty(PREFIX_X, 0.0);
		nLayout.y = (Double)n.getProperty(PREFIX_Y, 0.0);
	}
}
 

import org.neo4j.tooling.GlobalGraphOperations; //导入依赖的package包/类
@Override
public int getNodeCount()
{
    int nodeCount = 0;
    try (final Transaction tx = beginUnforcedTransaction())
    {
        try
        {
            nodeCount = IteratorUtil.count(GlobalGraphOperations.at(neo4jGraph).getAllNodes());
            tx.success();
        }
        catch (Exception e)
        {
            tx.failure();
            throw new BenchmarkingException("unable to get node count", e);
        }
    }

    return nodeCount;
}
 

import org.neo4j.tooling.GlobalGraphOperations; //导入依赖的package包/类
@Override
public void initCommunityProperty()
{
    int communityCounter = 0;

    // maybe commit changes every 1000 transactions?
    try (final Transaction tx = beginUnforcedTransaction())
    {
        try
        {
            for (Node n : GlobalGraphOperations.at(neo4jGraph).getAllNodes())
            {
                n.setProperty(NODE_COMMUNITY, communityCounter);
                n.setProperty(COMMUNITY, communityCounter);
                communityCounter++;
            }
            tx.success();
        }
        catch (Exception e)
        {
            tx.failure();
            throw new BenchmarkingException("unable to initialize community property", e);
        }
    }
}
 

import org.neo4j.tooling.GlobalGraphOperations; //导入依赖的package包/类
@Override
public double getGraphWeightSum()
{
    int edgeCount = 0;

    try (final Transaction tx = beginUnforcedTransaction())
    {
        try
        {
            edgeCount = IteratorUtil.count(GlobalGraphOperations.at(neo4jGraph).getAllRelationships());
            tx.success();
        }
        catch (Exception e)
        {
            tx.failure();
            throw new BenchmarkingException("unable to get graph weight sum", e);
        }
    }

    return (double) edgeCount;
}
 

import org.neo4j.tooling.GlobalGraphOperations; //导入依赖的package包/类
public static Graph<Node,Relationship> getGraph(GlobalGraphOperations o) {
    Iterator<Node> nit = o.getAllNodes().iterator();
    Iterator<Relationship> rit = o.getAllRelationships().iterator();

    // make a graph
    Graph<Node,Relationship> graph = new DirectedSparseGraph<Node, Relationship>();
    
    while(nit.hasNext()){
        Node n = nit.next();
        graph.addVertex(n);
    }
    
    while(rit.hasNext()){
        Relationship r = rit.next();
        graph.addEdge(r, r.getStartNode(), r.getEndNode());
    }
    return graph;
}
 

import org.neo4j.tooling.GlobalGraphOperations; //导入依赖的package包/类
@Override
public InternalIdentifier getStartIdentifier() {
	log.trace("Fetching (random) root Identifier from the database");
	InternalIdentifier result = null;
	try (Transaction tx = beginTx()) {
		Iterator<Node> allNodes = GlobalGraphOperations.at(mConnection.getConnection()).getAllNodesWithLabel(Neo4JTypeLabels.IDENTIFIER).iterator();
		if(allNodes.hasNext()) {
			result =  new Neo4JIdentifier(allNodes.next(), this);
		}
		else {
			log.warn("Seems there is no Identifier in the database that could be used as a root");
			result =  null;
		}
		tx.success();
	}
	return result;
}
 

import org.neo4j.tooling.GlobalGraphOperations; //导入依赖的package包/类
public void incrementCounter(long timestamp) {
	try (Transaction tx = mConnection.getConnection().beginTx()) {
		Node changeNode = null;
		Iterator<Node> change = GlobalGraphOperations.at(mConnection.getConnection()).getAllNodesWithLabel(Neo4JTypeLabels.CHANGE).iterator();
		if (!change.hasNext()) {
			changeNode = mConnection.getConnection().createNode();
			changeNode.addLabel(Neo4JTypeLabels.CHANGE);
		} else {
			changeNode = change.next();
		}
		if (!changeNode.hasProperty(timestamp + "")) {
			changeNode.setProperty(timestamp + "",
					(long) 1);
		} else {
			long count = (long) changeNode.getProperty(timestamp+"");
			count++;
			changeNode.setProperty(timestamp+"", count);

		}
		tx.success();
	}
}