Java Result.columnAs方法代码示例

import org.neo4j.graphdb.Result; //导入方法依赖的package包/类
@Override
public Vertex createVertex(long id, int weight) {
    Vertex v = null;
    try {
        beginTransaction();
        Result result = graphDb.execute("MERGE (a:NODE{INDEX:" + id + "}) RETURN a");
        Iterator<Node> n_column = result.columnAs("a");
        Node node = null;
        for (Node n : IteratorUtil.asIterable(n_column)) {
            node = n;
        }
        node.setProperty(NetworkNeo4jProperties.WEIGHT, weight);
        node.setProperty(NetworkNeo4jProperties.LEVEL, (int) 0);
        v = new Vertex(id, weight);
    } finally {
        endTransaction();
    }

    return v;
}
 

import org.neo4j.graphdb.Result; //导入方法依赖的package包/类
@Override
public int getWeightEdges(long id) {

    Iterator<Integer> list;
    int weight = 0;

    try {
        beginTransaction();
        Result result = graphDb.execute("MATCH  (a:NODE{INDEX:" + id + "})-[r:LINK]-(b) "
                + "RETURN SUM(r.WEIGHT) AS total");
        list = result.columnAs("total");
        if (list.hasNext()) {
            int value = list.next();
            weight = (int) value;
        }
    } finally {
        endTransaction();
    }

    return weight;
}
 

import org.neo4j.graphdb.Result; //导入方法依赖的package包/类
@Override
public boolean edgeExist(long id1, long id2) {
    boolean res = false;
    try {
        beginTransaction();
        Result result = graphDb.execute("MATCH (a:NODE{INDEX:" + String.valueOf(id1) + "})-[r:LINK]-(b:NODE{INDEX:" + String.valueOf(id2) + "}) RETURN r LIMIT 1");
        Relationship rel_result = null;
        Iterator<Relationship> n_column = result.columnAs("r");
        for (Relationship rel : IteratorUtil.asIterable(n_column)) {
            rel_result = rel;
        }
        if (rel_result != null) {
            res = false;
        }
    } finally {
        endTransaction();
    }

    return res;
}
 

import org.neo4j.graphdb.Result; //导入方法依赖的package包/类
@Override
public int getNumVertexWithoutPartition() {

    int num = 0;
    try {
        beginTransaction();
        Result result = graphDb.execute("MATCH (n:NODE) WHERE n.PARTITION IS NULL RETURN n");
        Iterator<Integer> list = result.columnAs("n");
        num = IteratorUtil.count(list);
    } finally {
        endTransaction();
    }

    return num;//IteratorUtil.count(list);

}
 

import org.neo4j.graphdb.Result; //导入方法依赖的package包/类
@Override
public int getVertexFrontierWeight(long id, int partition) {

    Iterator<Integer> list;
    int frontierWeight = 0;
    try {
        beginTransaction();
        Result result = graphDb.execute("MATCH (a:NODE{INDEX:" + id + "})-[r:LINK]-(b:NODE{PARTITION:" + partition + "}) "
                + "RETURN SUM(r.WEIGHT) AS total");
        list = result.columnAs("total");
        if (list.hasNext()) {
            int value = list.next();
            frontierWeight = (int) value;
        }
    } finally {
        endTransaction();
    }

    return frontierWeight;
}
 

import org.neo4j.graphdb.Result; //导入方法依赖的package包/类
@Override
public int getCutWeight() {

    Iterator<Integer> list;
    int cutWeight = 0;
    try {
        beginTransaction();
        Result result = graphDb.execute("MATCH  (a:NODE), (b:NODE), (a)-[r:LINK]->(b) "
                + "WHERE a.PARTITION <> b.PARTITION "
                + "RETURN SUM(r.WEIGHT) AS total");
        list = result.columnAs("total");
        if (list.hasNext()) {
            int value = list.next();
            cutWeight = (int) value;
        }
    } finally {
        endTransaction();
    }

    return cutWeight;
}
 

import org.neo4j.graphdb.Result; //导入方法依赖的package包/类
@Override
public int gainOfVertex(Vertex v) {

    Iterator<Long> list;
    int gain = 0;
    try {
        beginTransaction();
        Result result = graphDb.execute("MATCH  (a:NODE{INDEX:1}), (a)-[r:LINK]-(b) "
                + "RETURN SUM( "
                + "CASE a.PARTITION "
                + "WHEN b.PARTITION "
                + "THEN 1 "
                + "ELSE -1 "
                + "END) AS gain");
        list = result.columnAs("gain");
        if (list.hasNext()) {
            long value = list.next();
            gain = (int) value;
        }
    } finally {
        endTransaction();
    }

    return gain;
}
 

import org.neo4j.graphdb.Result; //导入方法依赖的package包/类
@Override
public Graph execute(Map<String, List<String>> parameters, Integer limit)
{
    String vertexQuery = prepareGetVertexQuery(parameters, limit);
    Result result = (Result) currentStorage.executeQuery(vertexQuery);
    Iterator<Node> nodeSet = result.columnAs(VERTEX_ALIAS);
    Node node;
    if(nodeSet.hasNext())
    {
        // starting point can only be one vertex
        node = nodeSet.next();
    }
    else
        return null;
    Iterable<Relationship> relationships = node.getRelationships(Direction.INCOMING);
    Graph children = new Graph();
    for(Relationship relationship: relationships)
    {
        children.putVertex(convertNodeToVertex(relationship.getEndNode()));
    }


    return children;
}
 

import org.neo4j.graphdb.Result; //导入方法依赖的package包/类
protected Set<AbstractVertex> prepareVertexSetFromNeo4jResult(String query)
{
    Set<AbstractVertex> vertexSet = new HashSet<>();
    try
    {
        Result result = (Result) currentStorage.executeQuery(query);
        Iterator<Node> nodeSet = result.columnAs(VERTEX_ALIAS);
        AbstractVertex vertex;
        while(nodeSet.hasNext())
        {
            vertex = convertNodeToVertex(nodeSet.next());
            if(!vertex.isEmpty())
                vertexSet.add(vertex);
        }
    }
    catch (Exception ex)
    {
        Logger.getLogger(Neo4j.class.getName()).log(Level.SEVERE, "Vertex set querying unsuccessful!", ex);
    }

    return vertexSet;
}
 

import org.neo4j.graphdb.Result; //导入方法依赖的package包/类
protected Set<AbstractEdge> prepareEdgeSetFromNeo4jResult(String query)
{
    Set<AbstractEdge> edgeSet = new HashSet<>();
    try
    {
        Result result = (Result) currentStorage.executeQuery(query);
        Iterator<Relationship> relationshipSet = result.columnAs(EDGE_ALIAS);
        AbstractEdge edge;
        while(relationshipSet.hasNext())
        {
            edge = convertRelationshipToEdge(relationshipSet.next());
            if(!edge.isEmpty())
                edgeSet.add(edge);
        }
    }
    catch (Exception ex)
    {
        Logger.getLogger(Neo4j.class.getName()).log(Level.SEVERE, "Edge set querying unsuccessful!", ex);
    }

    return edgeSet;
}
 

import org.neo4j.graphdb.Result; //导入方法依赖的package包/类
@Override
public Graph execute(Map<String, List<String>> parameters, Integer limit)
{
    String vertexQuery = prepareGetVertexQuery(parameters, limit);
    Result result = (Result) currentStorage.executeQuery(vertexQuery);
    Iterator<Node> nodeSet = result.columnAs(VERTEX_ALIAS);
    Node node;
    if(nodeSet.hasNext())
    {
        // starting point can only be one vertex
        node = nodeSet.next();
    }
    else
        return null;
    Iterable<Relationship> relationships = node.getRelationships(Direction.OUTGOING);
    Graph parents = new Graph();
    for(Relationship relationship: relationships)
    {
        parents.putVertex(convertNodeToVertex(relationship.getEndNode()));
    }


    return parents;
}
 

import org.neo4j.graphdb.Result; //导入方法依赖的package包/类
private Node getInnerNode(long id) {
    Result result = graphDb.execute("MATCH (a:NODE{INDEX:" + String.valueOf(id) + "}) RETURN a LIMIT 1");
    Node node_result = null;
    Iterator<Node> n_column = result.columnAs("a");
    for (Node node : IteratorUtil.asIterable(n_column)) {
        node_result = node;
    }
    return node_result;
}
 

import org.neo4j.graphdb.Result; //导入方法依赖的package包/类
private Relationship getInnerRelationship(long id) {
    Result result = graphDb.execute("MATCH (a:NODE)-[r:LINK{INDEX:" + String.valueOf(id) + "}]-(b:NODE) RETURN r LIMIT 1");
    Relationship rel_result = null;
    Iterator<Relationship> n_column = result.columnAs("r");
    for (Relationship rel : IteratorUtil.asIterable(n_column)) {
        rel_result = rel;
    }
    return rel_result;
}
 

import org.neo4j.graphdb.Result; //导入方法依赖的package包/类
/**
 * Execute the query on the given database.
 * @param db the database to execute the query on.
 * @return the query result.
 */
public List<EnrichedSequenceNode> execute(GraphDatabaseService db) {
	sb.append("RETURN n");
	List<EnrichedSequenceNode> result;
	try (Transaction tx = db.beginTx()) {
		Result r = db.execute(sb.toString(), parameters);
		ResourceIterator<Node> it = r.columnAs("n");
		result = IteratorUtil.asCollection(it).stream()
			.map(e -> new Neo4jSequenceNode(db, e))
			.filter(p)
			.collect(Collectors.toList());
		tx.success();
	}
	return result;
}
 

import org.neo4j.graphdb.Result; //导入方法依赖的package包/类
/**
 * Retrieves a resource iterator over all roots.
 * The roots are all the nodes with no incoming edges.
 * @return	a resource iterator
 */
protected ResourceIterator<Node> rootIterator() {
	ResourceIterator<Node> roots;
	Result res = service.execute(GET_ROOT);
	roots = res.columnAs("s");
	return roots;
}