Java QuerySolution.get方法代码示例

import org.apache.jena.query.QuerySolution; //导入方法依赖的package包/类
private static List<Pair<String, String>> getProperties(String uri) {
    List<Pair<String, String>> results = new ArrayList<>();
    String sparqlQuery = "select ?r ?y where {<" + uri + "> ?r ?y}";
    //System.out.println(sparqlQuery);
    QueryExecution e = QueryExecutionFactory.sparqlService(ENDPOINT, sparqlQuery);
    ResultSet rs = e.execSelect();
    while (rs.hasNext()) {
        QuerySolution nextSolution = rs.nextSolution();
        RDFNode ynode = nextSolution.get("y");
        if (ynode.isResource()) {
            results.add(Pair.of(nextSolution.getResource("r").getURI(), nextSolution.getResource("y").getURI()));
        } else {
            results.add(Pair.of(nextSolution.getResource("r").getURI(), nextSolution.getLiteral("y").getString().replaceAll("\\n+", " ")));
        }
    }
    e.close();
    return results;
}
 

import org.apache.jena.query.QuerySolution; //导入方法依赖的package包/类
static List<String> getResultSetAsStringList(ResultSet resultSet, String variableName, boolean literalRequired) {
    List<String> resultStrings = new ArrayList<>();
    RDFNode node;
    if (resultSet != null) {
        while (resultSet.hasNext()) {
            QuerySolution result = resultSet.next();
            if (result != null) {
                node = result.get(variableName);
                if (literalRequired) {
                    String literal = getStringLiteral(node);
                    if (literal != null) {
                        resultStrings.add(literal);
                    }
                } else {
                    if (node != null) {
                        resultStrings.add(node.toString());
                    }
                }
            }
        }
    }
    return resultStrings;
}
 

import org.apache.jena.query.QuerySolution; //导入方法依赖的package包/类
public static List<String> queryData(String query){
	Dataset db = TDBFactory.createDataset("temp/dataset");
	db.begin(ReadWrite.READ);
    Model model = db.getDefaultModel();
    Query q = QueryFactory.create(query);
    QueryExecution qexec = QueryExecutionFactory.create(query, model);
    ResultSet results = qexec.execSelect();
    List<String> answer = new ArrayList<String>();
    while(results.hasNext()){
    	QuerySolution t = results.nextSolution();
    	RDFNode x  = t.get("x");
    	String s = x.toString();
	System.out.println(s);
    	answer.add(s.substring(7));
    }
    qexec.close();
    db.close();
    return answer;
}
 

import org.apache.jena.query.QuerySolution; //导入方法依赖的package包/类
/**
     * Constructs a new binding from a query solution.
     *
     * @param binding -
     */
    public BindingHashMapOverwrite(final QuerySolution binding) {
        var = null;
        node = null;
        if (binding == null) {
            parent = null;
        } else {
            final BindingHashMap p = new BindingHashMap();
            for (Iterator<String> it = binding.varNames(); it.hasNext();) {
                final String varName = it.next();
                if (binding.get(varName) != null) {
                    p.add(Var.alloc(varName), binding.get(varName).asNode());
                }
            }
            parent = p;
        }
//        LOG.trace("New binding #" + System.identityHashCode(this) + " copies " + binding);
    }
 

import org.apache.jena.query.QuerySolution; //导入方法依赖的package包/类
/**
 * Turns a QuerySolution into a Binding. 
 * @param map  the input QuerySolution
 * @return a Binding or null if the input is null
 */
public static Binding asBinding(final QuerySolution map) {
	if(map != null) {
		BindingHashMap result = new BindingHashMap();
		Iterator<String> varNames = map.varNames();
		while(varNames.hasNext()) {
			String varName = varNames.next();
			RDFNode node = map.get(varName);
			if(node != null) {
				result.add(Var.alloc(varName), node.asNode());
			}
		}
		return result;
	}
	else {
		return null;
	}
}
 

import org.apache.jena.query.QuerySolution; //导入方法依赖的package包/类
/**
 * Calls a SPARQL expression and returns the result, using some initial bindings.
 *
 * @param expression     the expression to execute (must contain absolute URIs)
 * @param initialBinding the initial bindings for the unbound variables
 * @param dataset        the query Dataset or null for default
 * @return the result or null
 */
public static Node invokeExpression(String expression, QuerySolution initialBinding, Dataset dataset) {
    if (dataset == null) {
        dataset = ARQFactory.get().getDataset(ModelFactory.createDefaultModel());
    }
    Query query = ARQFactory.get().createExpressionQuery(expression);
    try(QueryExecution qexec = ARQFactory.get().createQueryExecution(query, dataset, initialBinding)) {
        ResultSet rs = qexec.execSelect();
        Node result = null;
        if (rs.hasNext()) {
            QuerySolution qs = rs.next();
            String firstVarName = rs.getResultVars().get(0);
            RDFNode rdfNode = qs.get(firstVarName);
            if (rdfNode != null) {
                result = rdfNode.asNode();
            }
        }
        return result;
    }
}
 

import org.apache.jena.query.QuerySolution; //导入方法依赖的package包/类
@Override
   public NodeValue executeBody(Dataset dataset, Model defaultModel, QuerySolution bindings) {
    try( QueryExecution qexec = createQueryExecution(dataset, defaultModel, bindings) ) {
        if(arqQuery.isAskType()) {
            boolean result = qexec.execAsk();
            return NodeValue.makeBoolean(result);
        }
        else {
            ResultSet rs = qexec.execSelect();
            if(rs.hasNext()) {
                QuerySolution s = rs.nextSolution();
                List<String> resultVars = rs.getResultVars();
                String varName = resultVars.get(0);
                RDFNode resultNode = s.get(varName);
                if(resultNode != null) {
                    return NodeValue.makeNode(resultNode.asNode());
                }
            }
            throw new ExprEvalException("Empty result set for SHACL function");
        }
    }
}
 

import org.apache.jena.query.QuerySolution; //导入方法依赖的package包/类
@Override
public Object invokeFunction(String functionName, QuerySolution bindings) throws javax.script.ScriptException, java.lang.NoSuchMethodException {
	List<String> functionParams = getFunctionParameters(functionName);
	Object[] params = new Object[functionParams.size()];
	Iterator<String> varNames = bindings.varNames();
	while(varNames.hasNext()) {
		String varName = varNames.next();
		int index = functionParams.indexOf(varName);
		if(index < 0) {
			index = functionParams.indexOf("$" + varName);
		}
		if(index >= 0) {
			RDFNode value = bindings.get(varName);
			if(value != null) {
				params[index] = JSFactory.asJSTerm(value.asNode());
			}
		}
	}
	return invokeFunctionOrdered(functionName, params);
}
 

import org.apache.jena.query.QuerySolution; //导入方法依赖的package包/类
@Override
public Quad next() {
    QuerySolution solution = results.next();
    Node s = solution.get("s").asNode();
    Node p = solution.get("p").asNode();
    Node o = solution.get("o").asNode();
    Node g = null;
    if (solution.get("g") != null) {
        g = solution.get("g").asNode();
    } else {
        if (graphName != null) {
            g = NodeFactory.createURI(graphName);
        }
    }
    Quad quad = new Quad(g, s, p, o);
    return quad;
}
 

import org.apache.jena.query.QuerySolution; //导入方法依赖的package包/类
private void execSelect(QueryExecution exec) {
	ResultSet res = exec.execSelect();
	header = res.getResultVars();
	results = new LinkedList<List<String>>();
	while (res.hasNext()) {
		List<String> row = new LinkedList<String>();
		QuerySolution solution = res.next();
		for (String var : header) {
			RDFNode node = solution.get(var);
			if(node.isResource()) {
				row.add("<"+node.toString()+">");
			}
			else {
				row.add(node.asNode().toString(true));
			}
		}
		results.add(row);
	}
	isCD=false;
	isSelect = true;
}
 

import org.apache.jena.query.QuerySolution; //导入方法依赖的package包/类
public MultiSetScorer(ComponentProperty property, Function<RDFNode,Set<String>> f)
{
	super(property);
	ResultSet rs = queryValues();
	while(rs.hasNext())
	{
		QuerySolution qs = rs.next();
		RDFNode node = qs.get("value");
		f.apply(node).forEach(s->
		{
			//				valueToNode.put(s, node);
			values.add(s, qs.get("cnt").asLiteral().getInt());
		});
	}

	Optional<Integer> max = values.elementSet().stream().map(s->values.count(s)).max(Integer::compare);
	if(!max.isPresent())
	{
		log.warn("no values for property "+property+": "+values);
		maxCount=0;
	}
	else
	{
		maxCount = max.get();
	}
}
 

import org.apache.jena.query.QuerySolution; //导入方法依赖的package包/类
public static List<String> getClasses(Model m){
	List<String> classNames = new ArrayList<String>();
	String sparqlQueryString= "select distinct ?class where {?s a ?class}";
	QueryExecution qexec = QueryExecutionFactory.create(sparqlQueryString, m);
	ResultSet results = qexec.execSelect();
	
	while (results.hasNext()) {
	    QuerySolution row = results.next();
	    RDFNode className = row.get("class");
	    if(!nameSpace.equals("")){
	    	if(!className.toString().startsWith(nameSpace)) continue;
	    }
	    classNames.add(className.toString());
	}
	return classNames;
}
 

import org.apache.jena.query.QuerySolution; //导入方法依赖的package包/类
static float getVRankOfResource(String uri) {
    uri = "<" + uri + ">";
    String var = "v";
    String queryString = Constants.PREFIX_VRANK +
            "SELECT ?" + var + "\n" +
            "FROM <http://dbpedia.org> \n" +
            "FROM <http://people.aifb.kit.edu/ath/#DBpedia_PageRank> \n" +
            "WHERE {\n" +
            uri + " vrank:hasRank/vrank:rankValue ?" + var + ".\n" +
            "}\n";

    try {
        ResultSet results = SPARQLClient.runSelectQuery(queryString, Constants.DBPEDIA_SPARQL_SERVICE);
        if (results != null) {
            while (results.hasNext()) {
                QuerySolution result = results.next();
                RDFNode vRank = result.get(var);
                if (vRank != null && vRank.isLiteral()) {
                    Literal literal = (Literal) vRank;
                    return (literal.getFloat());
                }
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return 0;
}
 

import org.apache.jena.query.QuerySolution; //导入方法依赖的package包/类
static List<LinkSUMResultRow> getResultSetAsObjectList(ResultSet resultSet) {
    List<LinkSUMResultRow> rows = new ArrayList<>();
    String subject = "subject";
    String predicate = "pred";
    String object = "object";
    String subLabel = "sublabel";
    String predLabel = "predlabel";
    String obLabel = "oblabel";
    String vRank = "v";

    if (resultSet != null) {
        while (resultSet.hasNext()) {
            QuerySolution result = resultSet.next();
            LinkSUMResultRow.LinkSUMResultRowBuilder builder = LinkSUMResultRow.builder();
            if (result != null) {
                RDFNode subjectNode = result.get(subject);
                RDFNode predicateNode = result.get(predicate);
                RDFNode objectNode = result.get(object);
                builder
                        .subject(subjectNode != null ? subjectNode.toString() : null)
                        .predicate(predicateNode != null ? predicateNode.toString() : null)
                        .object(objectNode != null ? objectNode.toString() : null)
                        .subjectLabel(getStringLiteral(result.get(subLabel)))
                        .predicateLabel(getStringLiteral(result.get(predLabel)))
                        .objectLabel(getStringLiteral(result.get(obLabel)));
                RDFNode vRankNode = result.get(vRank);
                if (vRankNode != null && vRankNode.isLiteral()) {
                    Literal literal = (Literal) vRankNode;
                    builder.vRank(literal.getFloat());
                }
                rows.add(builder.build());
            }
        }
    }
    return rows;
}
 

import org.apache.jena.query.QuerySolution; //导入方法依赖的package包/类
static void addResultsToList(ResultSet results, List<String> resources, String var) {
    if (results != null) {
        while (results.hasNext()) {
            QuerySolution result = results.next();
            if (result != null) {
                RDFNode n = result.get(var);
                String nameLiteral;
                if (n.isLiteral()) {
                    nameLiteral = ((Literal) n).getLexicalForm();
                    resources.add(nameLiteral);
                }
            }
        }
    }
}