import org.apache.jena.query.ResultSet; //导入依赖的package包/类
public static Set<String> listVocabularies() {
	Set<String> tds = new HashSet<>();
	Dataset dataset = ThingDirectory.get().dataset;
	dataset.begin(ReadWrite.READ);

	try {
		String q = "SELECT DISTINCT ?g WHERE { GRAPH ?g { ?o a <http://www.w3.org/2002/07/owl#Ontology> } }";
		QueryExecution qexec = QueryExecutionFactory.create(q, dataset);
		ResultSet result = qexec.execSelect();
		while (result.hasNext()) {
			tds.add(result.next().get("g").asResource().getURI());
		}
	} catch (Exception e) {
		throw e;
	} finally {
		dataset.end();
	}

	return tds;
}
 

import org.apache.jena.query.ResultSet; //导入依赖的package包/类
/**
 * Return the label for this object in the selected language
 * @param language - the language for which the label is requested
 * @return - the label in the requested language.
 * @throws ModelException - thrown if there are multiple labels present for this object in this language
 */
public Label getLabel(Language language) throws ModelException {
	String sparql = "SELECT ?label WHERE { ?objectURI rdfs:label ?label . FILTER(LANG(?label) = STR(?labelLanguage)) }";
	ParameterizedSparqlString parameterizedSparql = new ParameterizedSparqlString(model);
	parameterizedSparql.setCommandText(sparql);
	parameterizedSparql.setParam("objectURI", resource);
	parameterizedSparql.setParam("labelLanguage", model.createLiteral(language.getCode(), ""));
	
	Query query = QueryFactory.create(parameterizedSparql.asQuery());

	QueryExecution qexec = QueryExecutionFactory.create(query, model);
	ResultSet resultSet = qexec.execSelect();
	
	if (!resultSet.hasNext()) return null;
	
	QuerySolution querySolution = resultSet.next();
	Label label = new Label(querySolution.getLiteral("label"));
	
	if (!resultSet.hasNext()) return label;
	
	throw new ModelException("%s has more than one label in language '%s'", resource.getURI(), language.getCode());
}
 

import org.apache.jena.query.ResultSet; //导入依赖的package包/类
@Override
public RESTResource get(URI uri, Map<String, String> parameters) throws RESTException {
	RESTResource resource = new RESTResource(uri.toString(),this);

	Dataset dataset = ThingDirectory.get().dataset;
	dataset.begin(ReadWrite.READ);

	try {
		String q = "SELECT ?str WHERE { <" + uri + "> <" + DC.source + "> ?str }";
		QueryExecution qexec = QueryExecutionFactory.create(q, dataset);
		ResultSet result = qexec.execSelect();

		if (result.hasNext()) {
			resource.contentType = "application/ld+json";
			resource.content = result.next().get("str").asLiteral().getLexicalForm();
		} else {
			throw new RESTException();
		}
	} finally {
		dataset.end();
	}
	
	return resource;
}
 

import org.apache.jena.query.ResultSet; //导入依赖的package包/类
public static List<String> listThingDescriptions(String query) {
List<String> tds = new ArrayList<>();
Dataset dataset = ThingDirectory.get().dataset;
dataset.begin(ReadWrite.READ);

try {
  String q = "SELECT DISTINCT ?g WHERE { GRAPH ?g { " + query + " FILTER NOT EXISTS { ?ontology a <http://www.w3.org/2002/07/owl#Ontology> } } }";
  try (QueryExecution qexec = QueryExecutionFactory.create(q, dataset)) {
	ResultSet result = qexec.execSelect();
	while (result.hasNext()) {
	  tds.add(result.next().get("g").asResource().getURI());
	}
  }
catch (Exception e) {
  throw e;
}
} finally {
  dataset.end();
}

return tds;
 }
 

import org.apache.jena.query.ResultSet; //导入依赖的package包/类
/**
  * Returns the ID of a thing description stored in the database given its URI.
  * @param uri URI of the thing description we want to return.
  * @return the ID of the thing description.
  */
 public static String getThingDescriptionIdFromUri(String uri) {

String query = "?td <http://iot.linkeddata.es/def/wot#baseURI> <" + uri + ">";
String id = "NOT FOUND";
  
Dataset dataset = ThingDirectory.get().dataset;
dataset.begin(ReadWrite.READ);

try {
  String q = "SELECT ?g_id WHERE { GRAPH ?g_id { " + query + " }}";
  QueryExecution qexec = QueryExecutionFactory.create(q, dataset);
  ResultSet result = qexec.execSelect();
  while (result.hasNext()) { 
    id = result.next().get("g_id").toString();
  }
} catch (Exception e) {
  e.printStackTrace();
  throw e;
} finally {
  dataset.end();
}

return id;
 }
 

import org.apache.jena.query.ResultSet; //导入依赖的package包/类
/**
  * Returns a list of the thing descriptions URIs.
  * @return a list of URIs stored in the database.
  */
 public static List<String> listThingDescriptionsUri() {

List<String> tds = new ArrayList<>();
String query = "?td <http://iot.linkeddata.es/def/wot#baseURI> ?uri";
  
Dataset dataset = ThingDirectory.get().dataset;
dataset.begin(ReadWrite.READ);

try {
  String q = "SELECT ?uri WHERE { GRAPH ?g_id { " + query + " }}";
  try (QueryExecution qexec = QueryExecutionFactory.create(q, dataset)) {
	ResultSet result = qexec.execSelect();
	while (result.hasNext()) { 
	tds.add(result.next().get("uri").toString());
	}
  }
catch (Exception e) {
  throw e;
}
} finally {
  dataset.end();
}

return tds;
 }
 

import org.apache.jena.query.ResultSet; //导入依赖的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.ResultSet; //导入依赖的package包/类
public void setPersonTypes(Set<String> personTypes){
	this.personTypes = personTypes;
	
	//get the inferred sub types as well
	if(useInference){
		Set<String> inferredTypes = new HashSet<>();
		String queryTemplate = "select ?sub where{?sub <http://www.w3.org/2000/01/rdf-schema#subClassOf>* <%s>.}";
		for (String type : personTypes) {
			String query = String.format(queryTemplate, type);
			try(QueryExecution qe = qef.createQueryExecution(query)) {
				ResultSet rs = qe.execSelect();
				while(rs.hasNext()){
					inferredTypes.add(rs.next().getResource("sub").getURI());
				}
			}
		}
		personTypes.addAll(inferredTypes);
	}
}
 

import org.apache.jena.query.ResultSet; //导入依赖的package包/类
private boolean isPerson(String uri){
	if(personTypes.isEmpty()){
		return true;
	} else {
		//g et types of URI
		Set<String> types = new HashSet<>();
		try {
			String query = "SELECT ?type WHERE {<" + uri + "> a ?type.}";
			try(QueryExecution qe = qef.createQueryExecution(query)) {
				ResultSet rs = qe.execSelect();
				while(rs.hasNext()){
					types.add(rs.next().getResource("type").getURI());
				}
			}
		} catch (Exception e) {
			int code = ((QueryExceptionHTTP)e.getCause()).getResponseCode();
			logger.warn("SPARQL query execution failed: " + code + " - " + HttpSC.getCode(code).getMessage());
		}
		// check for overlap between types of entity and person types
		return !Sets.intersection(personTypes, types).isEmpty();
	}
}
 

import org.apache.jena.query.ResultSet; //导入依赖的package包/类
static ResultSet runSelectQuery(String queryString, String service, String... defaultGraphs) throws Exception {
    QueryEngineHTTP qExec = (QueryEngineHTTP) QueryExecutionFactory.sparqlService(service, queryString);
    qExec.addDefaultGraph(Constants.DBPEDIA_URL);
    if (defaultGraphs != null) {
        for (String defaultGraph : defaultGraphs) {
            qExec.addDefaultGraph(defaultGraph);
        }
    }
    qExec.addParam("timeout", Constants.TIMEOUT_VALUE); //100 sec
    ResultSet set = null;
    try {
        set = qExec.execSelect();
        set = ResultSetFactory.copyResults(set);
    } catch (Exception e) {
        QGenLogger.severe("Exception in SELECT\n" + queryString + "\n" + e.getMessage());
    } finally {
        qExec.close();
    }
    return set;
}
 

import org.apache.jena.query.ResultSet; //导入依赖的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.ResultSet; //导入依赖的package包/类
static String getLabelOfType(String type) {
    type = "<" + type + ">";
    String queryString = Constants.PREFIX_RDFS + Constants.PREFIX_FOAF;
    String variable = "name";
    queryString += "SELECT ?" + variable + " FROM <http://dbpedia.org> WHERE {\n" +
            "{" + type + " rdfs:label ?name .}\n" +
            Constants.UNION +
            "{" + type + " foaf:name ?name .}\n" +
            " filter (langMatches(lang(?name), \"EN\")) ." +
            "}";
    ResultSet results = null;
    try {
        results = SPARQLClient.runSelectQuery(queryString, Constants.DBPEDIA_SPARQL_SERVICE);
    } catch (Exception e) {
        e.printStackTrace();
    }
    if (results != null) {
        if (results.hasNext()) {
            QuerySolution result = results.next();
            return getStringLiteral(result.get(variable));
        }
    }
    return null;
}
 

import org.apache.jena.query.ResultSet; //导入依赖的package包/类
static String getLabelOfSpotlightType(String type) {
    String nsAndType = getNsAndTypeForSpotlightType(type);
    String queryString = Constants.PREFIX_RDFS + PREFIX_DBRES;
    queryString += "SELECT ?name FROM <http://dbpedia.org> WHERE {\n" +
            nsAndType + " rdfs:label ?name .\n" +
            " filter (langMatches(lang(?name), \"EN\")) ." +
            "}";
    ResultSet results = null;
    try {
        results = SPARQLClient.runSelectQuery(queryString, Constants.DBPEDIA_SPARQL_SERVICE);
    } catch (Exception e) {
        e.printStackTrace();
    }
    List<String> resultList = new ArrayList<>();
    addResultsToList(results, resultList, "name");
    return resultList.get(0);
}
 

import org.apache.jena.query.ResultSet; //导入依赖的package包/类
static int getTypeDepth(String type) {
    String queryString =
            Constants.PREFIX_RDF + Constants.PREFIX_FOAF + Constants.PREFIX_RDFS +
                    "SELECT DISTINCT ?path FROM <http://dbpedia.org> WHERE {\n" +
                    "<" + type + "> rdfs:subClassOf* ?path . }";

    ResultSet results;
    int count = 0;
    try {
        results = SPARQLClient.runSelectQuery(queryString, Constants.DBPEDIA_SPARQL_SERVICE);
        while (results.hasNext()) {
            results.next();
            count++;
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return count;
}
 

import org.apache.jena.query.ResultSet; //导入依赖的package包/类
public static int getCount(String q, Model m) {
    Query query = QueryFactory.create(q);
    QueryExecution queryExec = QueryExecutionFactory.create(query, m);
    ResultSet rs = queryExec.execSelect();
    String vName = "";
    for (String v: rs.getResultVars()) {
        if (v.contains("count")) {
            vName = v;
            break;
        }
    }
    
    while (rs.hasNext()) {
        QuerySolution s = rs.nextSolution();
        Literal c = s.getLiteral(vName);
        queryExec.close();
        return c.getInt();
    }   
    queryExec.close();
    return 0;
}
 

import org.apache.jena.query.ResultSet; //导入依赖的package包/类
/**
 * Writes a set of inputs from a workflow to the Writer
 * @param workflowUri The URI of the workflow in the model
 * @throws IOException Any errors in writing which may have occurred
 */
private void writeInputs(String workflowUri) throws IOException {

    // Start of subgraph with styling
    writeLine("  subgraph cluster_inputs {");
    writeLine("    rank = \"same\";");
    writeLine("    style = \"dashed\";");
    writeLine("    label = \"Workflow Inputs\";");

    // Write each of the inputs as a node
    ResultSet inputs = rdfService.getInputs(workflowUri);
    while (inputs.hasNext()) {
        QuerySolution input = inputs.nextSolution();
        writeInputOutput(input);
    }

    // End subgraph
    writeLine("  }");
}
 

import org.apache.jena.query.ResultSet; //导入依赖的package包/类
/**
 * Writes a set of outputs from a workflow to the Writer
 * @param workflowUri The URI of the workflow in the model
 * @throws IOException Any errors in writing which may have occurred
 */
private void writeOutputs(String workflowUri) throws IOException {
    // Start of subgraph with styling
    writeLine("  subgraph cluster_outputs {");
    writeLine("    rank = \"same\";");
    writeLine("    style = \"dashed\";");
    writeLine("    labelloc = \"b\";");
    writeLine("    label = \"Workflow Outputs\";");

    // Write each of the outputs as a node
    ResultSet outputs = rdfService.getOutputs(workflowUri);
    while (outputs.hasNext()) {
        QuerySolution output = outputs.nextSolution();
        writeInputOutput(output);
    }

    // End subgraph
    writeLine("  }");
}
 

import org.apache.jena.query.ResultSet; //导入依赖的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.ResultSet; //导入依赖的package包/类
/**
 * Gets all triples for resource r and property p. If outgoing is true it
 * returns all triples with <r,p,o>, else <s,p,r>
 *
 * @param r
 *            the resource
 * @param p
 *            the property
 * @param outgoing
 *            whether to get outgoing or ingoing triples
 * @return A set of triples
 */
public Set<Triple> getTriples(Resource r, Property p, boolean outgoing) {
	Set<Triple> result = new HashSet<Triple>();
	try {
		String q;
		if (outgoing) {
			q = "SELECT ?o where { <" + r.getURI() + "> <" + p.getURI() + "> ?o." + "?o rdfs:label []}";
		} else {
			q = "SELECT ?o where { ?o <" + p.getURI() + "> <" + r.getURI() + ">." + "?o rdfs:label []}";
		}
		q += " LIMIT " + maxShownValuesPerProperty + 1;
		QueryExecution qe = qef.createQueryExecution(q);
		ResultSet results = qe.execSelect();
		if (results.hasNext()) {
			while (results.hasNext()) {
				RDFNode n = results.next().get("o");
				result.add(Triple.create(r.asNode(), p.asNode(), n.asNode()));
			}
		}
		qe.close();
	} catch (Exception e) {
		e.printStackTrace();
	}
	return result;
}
 

import org.apache.jena.query.ResultSet; //导入依赖的package包/类
/**
 * Returns the most specific type of a given individual.
 * 
 * @param ind
 * @return
 */
private OWLClass getMostSpecificType(OWLIndividual ind) {
	logger.debug("Getting the most specific type of " + ind);
	String query = String.format("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> \n"
			+ "select distinct ?type where {" + " <%s> a ?type ." + "?type rdfs:label []."
			// + "?type a owl:Class ." // too strict, thus currently omitted
			+ "filter not exists {?subtype ^a <%s> ; rdfs:subClassOf ?type .filter(?subtype != ?type)}}",
			ind.toStringID(), ind.toStringID());
	SortedSet<OWLClass> types = new TreeSet<OWLClass>();

	QueryExecution qe = qef.createQueryExecution(query);
	ResultSet rs = qe.execSelect();
	while (rs.hasNext()) {
		QuerySolution qs = rs.next();
		if (qs.get("type").isURIResource()) {
			types.add(new OWLClassImpl(IRI.create(qs.getResource("type").getURI())));
		}
	}
	qe.close();

	// of more than one type exists, we have to choose one
	// TODO

	return types.first();
}