com.hp.hpl.jena.query.QueryExecution Java Examples

public List<? super ContextResource> getContextsOfContext(String contextURI) {
	List<ContextResource> contextResourceList = new ArrayList<ContextResource>();

	StringBuilder queryString = new StringBuilder().append(PREFIX_MDR)
			.append(PREFIX_RDFS).append("SELECT ?ctx FROM <")
			.append(MDRDatabase.BASE_URI).append("> WHERE {")
			.append("?ctx rdfs:subClassOf mdr:Context .")
			.append("?ctx mdr:having ?aic .")
			.append("?aic mdr:administeredItemContextContext <")
			.append(contextURI).append("> .").append("FILTER (?ctx != <")
			.append(contextURI).append("> )  }");
	QueryExecution qexec = this.createQueryExecution(
			queryString.toString(), this.mdrDatabase.getOntModel());
	try {
		ResultSet rs = qexec.execSelect();
		while (rs.hasNext()) {
			QuerySolution qs = rs.next();
			ContextResource ctx = new ContextImpl(qs.getResource("ctx"),
					this.mdrDatabase);
			contextResourceList.add(ctx);
		}
	} finally {
		qexec.close();
	}
	return contextResourceList;
}
 

/**
 * @return all of the {@link Datatype}s
 */
public List<? super DatatypeResource> getDatatypes() {
	StringBuilder queryString = new StringBuilder(PREFIX_MDR)
			.append(PREFIX_RDFS).append(PREFIX_XSD)
			.append("SELECT ?datatype FROM <").append(MDRDatabase.BASE_URI)
			.append("> WHERE {")
			.append("?datatype rdfs:subClassOf mdr:Datatype }");

	List<DatatypeResource> datatypeList = new ArrayList<DatatypeResource>();
	QueryExecution qexec = this.createQueryExecution(
			queryString.toString(), this.mdrDatabase.getOntModel());
	try {
		ResultSet rs = qexec.execSelect();
		while (rs.hasNext()) {
			QuerySolution qs = rs.next();
			Resource res = qs.getResource("datatype");
			datatypeList.add(new DatatypeImpl(res, mdrDatabase));
		}
	} finally {
		qexec.close();
	}
	return datatypeList;
}
 

private static String extractEventPayloads(EventDeclaration ed, Dataset dataset) {
	String queryStr = queryPrefix + " select ?x ?y ?z where {<" + ed.getnodeId()
			+ "> ssn:observes ?x. ?x rdf:type ?y. ?x ssn:isPropertyOf ?z }";
	QueryExecution qe = QueryExecutionFactory.create(queryStr, dataset);
	ResultSet results = qe.execSelect();
	List<String> payloads = new ArrayList<String>();
	String foiId = "";
	while (results.hasNext()) {
		QuerySolution result = results.next();
		RDFNode propertyName = result.get("x");
		RDFNode propertyType = result.get("y");
		RDFNode foi = result.get("z");
		if (propertyType.toString().equals("http://www.w3.org/2000/01/rdf-schema#Resource"))
			continue;
		// System.out.println("type: " + property + " foi: " + foi);
		payloads.add(propertyType.toString() + "|" + foi.toString() + "|" + propertyName.toString());
		foiId = foi.toString();
		// System.out.println("payload: " + propertyType.toString() + "|" + foi.toString() + "|"
		// + propertyName.toString());
	}
	ed.setPayloads(payloads);
	return foiId;
}
 

public static EventPattern extractQueryFromDataset(String serviceRequest) {
	Model queryBase = FileManager.get().loadModel(datasetDirectory + serviceRequest);
	dataset.getDefaultModel().add(ModelFactory.createOntologyModel(ontoSpec, queryBase));

	String describeStr = queryPrefix + " select ?x  where{?x rdf:type ces:EventRequest}";
	// Query query = QueryFactory.create(describeStr);
	// query.setPrefixMapping(pmap);
	QueryExecution qe = QueryExecutionFactory.create(describeStr, dataset);
	ResultSet results = qe.execSelect();
	// ResultSetFormatter.out(System.out, results, query);
	Map<String, EventDeclaration> edMap = new HashMap<String, EventDeclaration>();
	EventPattern ep = new EventPattern();
	ep.setQuery(true);
	while (results.hasNext()) {
		// System.out.println("results!");
		QuerySolution row = results.next();
		RDFNode edID = row.get("x");
		// System.out.println("has id: " + edID.toString());
		ep = extractEDByServiceID(edID, dataset, edMap).getEp();
	}
	return ep;
}
 

public static ArrayList<String> readEventIdsFromKs(String sparqlQuery)throws Exception {
    ArrayList<String> eventIds = new ArrayList<String>();
    //System.out.println("serviceEndpoint = " + serviceEndpoint);
    //System.out.println("sparqlQuery = " + sparqlQuery);
    //System.out.println("user = " + user);
    //System.out.println("pass = " + pass);
    HttpAuthenticator authenticator = new SimpleAuthenticator(user, pass.toCharArray());

    QueryExecution x = QueryExecutionFactory.sparqlService(serviceEndpoint, sparqlQuery, authenticator);
    ResultSet resultset = x.execSelect();
    while (resultset.hasNext()) {
        QuerySolution solution = resultset.nextSolution();
        //System.out.println("solution.toString() = " + solution.toString());
        //( ?event = <http://www.newsreader-project.eu/data/Dasym-Pilot/425819_relink_dominant.naf#ev24> )
        String currentEvent = solution.get("event").toString();
        //System.out.println("currentEvent = " + currentEvent);
        //http://www.newsreader-project.eu/data/Dasym-Pilot/425819_relink_dominant.naf#ev24
        if (!eventIds.contains(currentEvent)) {
            eventIds.add(currentEvent);
        }
    }
    return eventIds;
}
 

private static void extractEventPattern(EventDeclaration ed, Dataset dataset, Map<String, EventDeclaration> edMap)
		throws CloneNotSupportedException {
	String desribeStr = queryPrefix + " describe  ?z where {<" + ed.getnodeId()
			+ "> owls:presents ?y. ?y ces:hasPattern ?z.}";
	QueryExecution qe1 = QueryExecutionFactory.create(desribeStr, dataset);
	Model patternModel = qe1.execDescribe();
	// RDFDataMgr.write(System.out, patternModel, Lang.TURTLE);
	EventPattern ep = new EventPattern();
	ep.setID("EP-" + ed.getnodeId());

	// ep.setFilters(new HashMap<String, List<Filter>>());
	String queryRoot = queryPrefix + " select  ?z where {<" + ed.getnodeId()
			+ "> owls:presents ?y. ?y ces:hasPattern ?z.}";
	QueryExecution qe2 = QueryExecutionFactory.create(queryRoot, dataset);
	ResultSet results = qe2.execSelect();
	if (results.hasNext()) {
		ed.setEp(ep);
		RDFNode root = results.next().get("z");
		traverseToExtract(0, root, patternModel, ep, dataset, edMap);
		extractSelectionMap(root, patternModel, ep, dataset, edMap);
		// System.out.println("EP extracted: " + ep.toString());
	}
	// traverse
	// RDFDataMgr.write(System.out, results, Lang.TURTLE);

}
 

public int getNumberOfObjectClasses(String contextURI) {
	StringBuilder queryString = new StringBuilder(PREFIX_MDR)
			.append(PREFIX_RDFS)
			.append("SELECT (COUNT (DISTINCT ?objectClass) as ?count) FROM <")
			.append(MDRDatabase.BASE_URI).append("> WHERE {")
			.append("?objectClassClass rdfs:subClassOf mdr:ObjectClass .")
			.append("?objectClass rdfs:subClassOf ?objectClassClass .")
			.append("?objectClass mdr:having ?aic .")
			.append("?aic mdr:administeredItemContextContext <")
			.append(contextURI).append("> .").append("}");
	QueryExecution qexec = this.createQueryExecution(
			queryString.toString(), this.mdrDatabase.getOntModel());
	int size = 0;
	try {
		ResultSet rs = qexec.execSelect();
		while (rs.hasNext()) {
			QuerySolution qs = rs.next();
			size = qs.getLiteral("count").getInt();
		}
	} finally {
		qexec.close();
	}

	return size;
}
 

private static String extractFoIById(Dataset dataset, String foiId) {
	String queryStr = queryPrefix + " select  ?a ?b ?c ?d where { <" + foiId + "> ct:hasStartLatitude ?a. <"
			+ foiId + "> ct:hasStartLongitude ?b. <" + foiId + "> ct:hasEndLatitude ?c. <" + foiId
			+ "> ct:hasEndLongitude ?d.}";
	QueryExecution qe = QueryExecutionFactory.create(queryStr, dataset);
	ResultSet results = qe.execSelect();
	if (results.hasNext()) {
		// RDFNode foi = results.next().get("y");
		QuerySolution qs = results.next();
		Double startLat = qs.getLiteral("a").getDouble();
		Double startLon = qs.getLiteral("b").getDouble();
		Double endLat = qs.getLiteral("c").getDouble();
		Double endLon = qs.getLiteral("d").getDouble();
		return startLat + "," + startLon + "-" + endLat + "," + endLon;
		// ed.setFoi(startLat + "," + startLon + "-" + endLat + "," + endLon);
		// }
	}
	return null;

}
 

private static Map<String, EventDeclaration> extractEDsFromDataset(Dataset dataset) {
	// List<EventDeclaration> eds = new ArrayList<EventDeclaration>();
	String describeStr = queryPrefix
			+ " select ?x"
			+ " where{?x rdf:type ?y graph <http://www.insight-centre.org/ces#> { ?y rdfs:subClassOf ces:EventService}}";
	// Query query = QueryFactory.create(describeStr);
	// query.setPrefixMapping(pmap);
	QueryExecution qe = QueryExecutionFactory.create(describeStr, dataset);
	ResultSet results = qe.execSelect();
	// ResultSetFormatter.out(System.out, results, query);
	Map<String, EventDeclaration> edMap = new HashMap<String, EventDeclaration>();
	while (results.hasNext()) {
		QuerySolution row = results.next();
		RDFNode edID = row.get("x");
		// System.out.println("has id: " + edID.toString());
		extractEDByServiceID(edID, dataset, edMap);
	}
	// RDFDataMgr.write(System.out, results, Lang.TURTLE);
	return edMap;
}
 

public String testEndpoint(ConfigurationBean conf) {
	System.out.println("testing connection on " + conf.getEndPointUrl());
	QueryExecution qe = QueryExecutionFactory.sparqlService(conf.getEndPointUrl(), "select ?s {?s ?p ?o} LIMIT 1");
	String msg = "";
	try {
		ResultSet rs = qe.execSelect();
		if (rs.hasNext()) {
			System.out.println("is online");
			msg = "online";
		} else {
			System.out.println("is offline");
			msg = "offline";
		}
	} catch (Exception e) {
		System.out.println("is offline " + e.getMessage());
		msg = "offline " + e.getMessage();
	} finally {
		qe.close();
	}
	return msg;
}
 

public static ArrayList<Statement> readTriplesFromKs(String subjectUri, String sparqlQuery){

        ArrayList<Statement> triples = new ArrayList<Statement>();
        HttpAuthenticator authenticator = new SimpleAuthenticator(user, pass.toCharArray());
        try {
            qCount++;
            QueryExecution x = QueryExecutionFactory.sparqlService(serviceEndpoint, sparqlQuery, authenticator);
            ResultSet resultset = x.execSelect();
            while (resultset.hasNext()) {
                QuerySolution solution = resultset.nextSolution();
                String relString = solution.get("predicate").toString();
                RDFNode obj = solution.get("object");
                Model model = ModelFactory.createDefaultModel();
                Resource subj = model.createResource(subjectUri);
                Statement s = createStatement(subj, ResourceFactory.createProperty(relString), obj);
                triples.add(s);
            }
        } catch (Exception e) {
            //e.printStackTrace();
        }
        return triples;
    }
 

private Object getSameResource(Model model, String typePrefix,
        Element item, Document dataDoc) throws XPathExpressionException {
    QueryExecution qExec = null;
    try {
        String query = getEqualsQuery(model, typePrefix, item, dataDoc);
        LogUtils.debug(this.getClass(), query);
        qExec = QueryExecutionFactory.create(query, model);
        ResultSet rs = qExec.execSelect();
        while (rs.hasNext()) {
            QuerySolution solution = rs.next();
            return solution.get("?x0");
        }
    } catch (Exception e) {
        if (debug) {
            e.printStackTrace();
        }
    } finally {
        if (qExec != null) {
            qExec.close();
        }
    }
    return null;
}
 

/**
 * It executes a SELECT SPARQL query on the SPARQL endpoint.
 *
 * @param sparqlEndpointURI		the SPARQL endpoint URI.  
 * @param user					the user name for the SPARQl endpoint.
 * @param password				the password for the SPARQl endpoint.
 * @param query					the query to use to look for the resources.
 * @return the {@link com.hp.hpl.jena.query.ResultSet} of the SELECT SPARQL query.
 * @since 2.0
 */
public ResultSet executeSelect(final String sparqlEndpointURI, final String user, final String password, final String query) {
	ResultSet results = null;
 	try {
        // Execute the query and obtain results
        final QueryExecution qexec = QueryExecutionFactory.sparqlService(
        		sparqlEndpointURI, 
        		QueryFactory.create(query), 
				auth(sparqlEndpointURI, user, password));
        qexec.setTimeout(2000, 5000);
           results = qexec.execSelect() ;
        qexec.close() ;
      } catch (Exception exception) {
		LOGGER.error(MessageCatalog._00035_SPARQL_FAILED, exception, query);
	}
 	return results;
}
 

public static EventPattern extractQueryFromModel(Model serviceRequest) {
	// Model queryBase = FileManager.get().loadModel(datasetDirectory + serviceRequest);
	dataset.getDefaultModel().add(ModelFactory.createOntologyModel(ontoSpec, serviceRequest));

	String describeStr = queryPrefix + " select ?x  where{?x rdf:type ces:EventRequest}";
	// Query query = QueryFactory.create(describeStr);
	// query.setPrefixMapping(pmap);
	QueryExecution qe = QueryExecutionFactory.create(describeStr, dataset);
	ResultSet results = qe.execSelect();
	// ResultSetFormatter.out(System.out, results, query);
	Map<String, EventDeclaration> edMap = new HashMap<String, EventDeclaration>();
	EventPattern ep = new EventPattern();

	while (results.hasNext()) {
		// System.out.println("results!");
		QuerySolution row = results.next();
		RDFNode edID = row.get("x");
		// System.out.println("has id: " + edID.toString());
		ep = extractEDByServiceID(edID, dataset, edMap).getEp();
	}
	return ep;
}
 

public String crm2AliadaClass(final String crmClass) {
	final Query query = QueryFactory.create(CRM_TO_ALIADA_CLASS_P1 + crmClass + CRM_TO_ALIADA_CLASS_P2);
	ARQ.getContext().setTrue(ARQ.useSAX);
       
	QueryExecution execution = null;
	try {
		execution = QueryExecutionFactory.sparqlService("http://172.25.5.15:8890/sparql", query);
		execution.setTimeout(2000, 5000);
		final ResultSet results = execution.execSelect();
		//Iterating over the SPARQL Query results
		while (results.hasNext()) {
			QuerySolution soln = results.nextSolution();
			//Printing DBpedia entries' abstract.
			System.out.println(soln.get("?abstract"));   
			return soln.get("?abstract").asResource().getURI();
		}
		return "NULL";
       } finally {
       	try {
       		execution.close();
		} catch (Exception exception) {
			// TODO: handle exception
		}
       }

}
 

public int getNumberOfDEC(String objectClassURI) {
	StringBuilder queryString = new StringBuilder(PREFIX_MDR)
			.append(PREFIX_RDFS)
			.append("SELECT (COUNT (DISTINCT ?dec) as ?count) FROM <")
			.append(MDRDatabase.BASE_URI).append("> WHERE {")
			.append("?dec rdfs:subClassOf mdr:DataElementConcept .")
			.append("?dec mdr:dataElementConceptObjectClass <")
			.append(objectClassURI).append("> .").append("}");
	QueryExecution qexec = this.createQueryExecution(
			queryString.toString(), this.mdrDatabase.getOntModel());
	int size = 0;
	try {
		ResultSet rs = qexec.execSelect();
		while (rs.hasNext()) {
			QuerySolution qs = rs.next();
			size = qs.getLiteral("count").getInt();
		}
	} finally {
		qexec.close();
	}

	return size;
}
 

@Override
public ClosableIterable<Statement> sparqlDescribe(String query)
		throws ModelRuntimeException {
	Query jenaQuery = QueryFactory.create(query);
	QueryExecution qexec = QueryExecutionFactory.create(jenaQuery,
			this.dataset);

	if (jenaQuery.isDescribeType()) {
		com.hp.hpl.jena.rdf.model.Model m = qexec.execDescribe();
		Model resultModel = new ModelImplJena(null, m, Reasoning.none);
		resultModel.open();
		return resultModel;
	} else {
		throw new RuntimeException(
				"Cannot handle this type of query! Please use DESCRIBE.");
	}
}
 

@Override
public ClosableIterable<Statement> sparqlConstruct(String query)
		throws ModelRuntimeException, MalformedQueryException {
	Query jenaQuery = QueryFactory.create(query);
	QueryExecution qexec = QueryExecutionFactory.create(jenaQuery,
			this.dataset);

	if (jenaQuery.isConstructType()) {
		com.hp.hpl.jena.rdf.model.Model m = qexec.execConstruct();
		Model resultModel = new ModelImplJena(null, m, Reasoning.none);
		resultModel.open();
		return resultModel;
	} else {
		throw new RuntimeException(
				"Cannot handle this type of query! Please use CONSTRUCT.");
	}

}
 

@Override
public ClosableIterable<Statement> queryConstruct(String query,
		String querylanguage) throws QueryLanguageNotSupportedException,
		MalformedQueryException, ModelRuntimeException {

	Query jenaQuery = QueryFactory.create(query);
	QueryExecution qexec = QueryExecutionFactory.create(jenaQuery,
			this.dataset);

	if (jenaQuery.isConstructType()) {
		com.hp.hpl.jena.rdf.model.Model m = qexec.execConstruct();
		Model resultModel = new ModelImplJena(null, m, Reasoning.none);
		resultModel.open();
		return resultModel;
	} else {
		throw new RuntimeException(
				"Cannot handle this type of query! Please use CONSTRUCT.");
	}
}
 

/**
 * It executes a SELECT SPARQL query on the SPARQL endpoint, 
 * to get the number of resources specified in the query argument.
 *
 * @param query					the query to execute to get the number of resources.  
 * @param sparqlEndpointURI		the SPARQL endpoint URI.  
 * @param user					the user name for the SPARQl endpoint.
 * @param password				the password for the SPARQl endpoint.
 * @return the number of resources.
 * @since 2.0
 */
public int getNumResources(final String query, final String sparqlEndpointURI, final String user, final String password) {
	int numRes = 0;
	try {
        // Execute the query and obtain results
        final QueryExecution qexec = QueryExecutionFactory.sparqlService(
        		sparqlEndpointURI, 
        		QueryFactory.create(query), 
				auth(sparqlEndpointURI, user, password));
        qexec.setTimeout(2000, 5000);
           final ResultSet results = qexec.execSelect() ;
           while (results.hasNext())
           {
           	final QuerySolution soln = results.nextSolution() ;
           	numRes = soln.getLiteral("count").getInt();
           }
        qexec.close() ;
      } catch (Exception exception) {
		LOGGER.error(MessageCatalog._00035_SPARQL_FAILED, exception, query);
	}
	return numRes;
}
 

/**
 * @return opened result Model
 */
@Override
public ClosableIterable<Statement> sparqlDescribe(String queryString)
        throws ModelRuntimeException {
	assertModel();
	Query query = QueryFactory.create(queryString);
	QueryExecution qexec = QueryExecutionFactory.create(query, this.jenaModel);
	
	if(query.isDescribeType()) {
		com.hp.hpl.jena.rdf.model.Model m = qexec.execDescribe();
		Model resultModel = new ModelImplJena(null, m, Reasoning.none);
		resultModel.open();
		return resultModel;
	} else {
		throw new RuntimeException("Cannot handle this type of queries! Please use DESCRIBE.");
	}
	
}
 

public int getNumberOfConceptualDomains(String contextURI) {
	StringBuilder queryString = new StringBuilder(PREFIX_MDR)
			.append(PREFIX_RDFS)
			.append("SELECT (COUNT (DISTINCT ?cd) as ?count) FROM <")
			.append(MDRDatabase.BASE_URI).append("> WHERE {")
			.append("?cdClass rdfs:subClassOf mdr:ConceptualDomain .")
			.append("?cd rdfs:subClassOf ?cdClass .")
			.append("?cd mdr:having ?aic .")
			.append("?aic mdr:administeredItemContextContext <")
			.append(contextURI).append("> .").append("}");
	QueryExecution qexec = this.createQueryExecution(
			queryString.toString(), this.mdrDatabase.getOntModel());
	int size = 0;
	try {
		ResultSet rs = qexec.execSelect();
		while (rs.hasNext()) {
			QuerySolution qs = rs.next();
			size = qs.getLiteral("count").getInt();
		}
	} finally {
		qexec.close();
	}

	return size;
}
 

public List<? super PropertyResource> getPropertiesOfContext(
		String contextURI) {
	List<PropertyResource> propertyList = new ArrayList<PropertyResource>();
	StringBuilder queryString = new StringBuilder(PREFIX_MDR)
			.append(PREFIX_RDFS).append("SELECT ?property FROM <")
			.append(MDRDatabase.BASE_URI).append("> WHERE {")
			.append("?property rdfs:subClassOf mdr:Property .")
			.append("?property mdr:having ?aic .")
			.append("?aic mdr:administeredItemContextContext <")
			.append(contextURI).append("> .").append("}");
	QueryExecution qexec = this.createQueryExecution(
			queryString.toString(), this.mdrDatabase.getOntModel());
	try {
		ResultSet rs = qexec.execSelect();
		while (rs.hasNext()) {
			QuerySolution qs = rs.next();
			PropertyResource prop = new PropertyImpl(
					qs.getResource("property"), mdrDatabase);
			propertyList.add(prop);
		}
	} finally {
		qexec.close();
	}
	return propertyList;
}
 

public static EventPattern extractCompositionPlanFromDataset(String serviceRequest) {
	Model queryBase = FileManager.get().loadModel(datasetDirectory + serviceRequest);
	dataset.getDefaultModel().add(ModelFactory.createOntologyModel(ontoSpec, queryBase));

	String describeStr = queryPrefix + " select ?x  where{?x rdf:type ces:CompositionPlan}";
	// Query query = QueryFactory.create(describeStr);
	// query.setPrefixMapping(pmap);
	QueryExecution qe = QueryExecutionFactory.create(describeStr, dataset);
	ResultSet results = qe.execSelect();
	// ResultSetFormatter.out(System.out, results, query);
	Map<String, EventDeclaration> edMap = new HashMap<String, EventDeclaration>();
	EventPattern ep = new EventPattern();
	ep.setQuery(false);
	while (results.hasNext()) {
		// System.out.println("results!");
		QuerySolution row = results.next();
		RDFNode edID = row.get("x");
		// System.out.println("has id: " + edID.toString());
		ep = extractEDByServiceID(edID, dataset, edMap).getEp();
	}
	return ep;
}
 

/**
 * Builds a new {@link ResultSet} wrapping out the given data.
 * 
 * @param resultset the actual {@link ResultSet}.
 * @param execution the {@link QueryExecution} associated with the given {@link ResultSet}.
 */
public CloseableResultSet(
		final ResultSet resultset, 
		final QueryExecution execution) {
	this.resultset = resultset;
	this.execution = execution;
}
 

/**
 * It executes a SELECT SPARQL query on the SPARQL endpoint, 
 * to get the ambiguous discovered links of a source URI.
 *
 * @param ambiguousLink			a {@link eu.aliada.shared.rdfstore.AmbiguousLink} that contains the source URI.  
 * @param localRes				the source resource of the link.  
 * @param extResBegin			the beginning string of the target link.  
 * @param sparqlEndpointURI		the SPARQL endpoint URI.  
 * @param graphName 			the graphName, null in case of default graph.
 * @param user					the user name for the SPARQl endpoint.
 * @param password				the password for the SPARQl endpoint.
 * @param offset				causes the solutions generated to start after 
 *                              the specified number of solutions.
 * @param limit					upper bound on the number of solutions returned.
 * @since 2.0
 */
public void getSourceURIAmbiguousLinks(final AmbiguousLink ambiguousLink, final Resource localRes, final String extResBegin, final String sparqlEndpointURI, final String graphName, final String user, final String password) {
	final String query = "SELECT ?rel ?extRes FROM <" + graphName + "> " + 
			" WHERE {<" + ambiguousLink.getSourceURI() + "> ?rel ?extRes ." +
			" FILTER regex(?extRes, \"^" + extResBegin + "\", \"i\")" +
			" }";
	try {
		// Execute the query and obtain results
		final QueryExecution qexec = QueryExecutionFactory.sparqlService(
				sparqlEndpointURI, 
				QueryFactory.create(query), 
				auth(sparqlEndpointURI, user, password));
		qexec.setTimeout(2000, 5000);
		final ResultSet results = qexec.execSelect() ;
		while (results.hasNext())
		{
			final QuerySolution soln = results.nextSolution() ;
	    	final Resource extRes = soln.getResource("extRes");
           	final Resource relResType = soln.getResource("rel");
           	final Triple triple = new Triple(localRes.asNode(), relResType.asNode(), extRes.asNode());
	    	ambiguousLink.addLink(triple);
	    }
	    qexec.close() ;
	  } catch (Exception exception) {
		LOGGER.error(MessageCatalog._00035_SPARQL_FAILED, exception, query);
	}
}
 

public List<? super ValueMeaningResource> listValueMeningsOfCD(
		String cdURI, int limit, int offset) {
	List<ValueMeaningResource> vmList = new ArrayList<ValueMeaningResource>();
	StringBuilder queryString = new StringBuilder(PREFIX_MDR)
			.append(PREFIX_RDFS).append("SELECT DISTINCT ?vm FROM <")
			.append(MDRDatabase.BASE_URI).append("> WHERE {")
			.append("?vm rdfs:subClassOf mdr:ValueMeaning .")
			.append("?vm mdr:valueMeaningIdentifier ?id . ")
			.append("?vm mdr:containedInValueMeaningSet <").append(cdURI)
			.append("> .").append("} ORDER BY ?id LIMIT ").append(limit)
			.append(" OFFSET ").append(offset);
	QueryExecution qexec = this.createQueryExecution(
			queryString.toString(), this.mdrDatabase.getOntModel());
	try {
		ResultSet rs = qexec.execSelect();
		while (rs.hasNext()) {
			QuerySolution qs = rs.next();
			// here conceptualDomain is checked whether its enumerated or
			// not, proper instantiation is done
			OntClass res = mdrDatabase.getOntModel().getOntClass(
					qs.getResource("vm").getURI());
			if (res.hasSuperClass(mdrDatabase.getVocabulary().EnumeratedValueDomain)) {
				vmList.add(new ValueMeaningImpl(res, mdrDatabase));
			} else {
				vmList.add(new ValueMeaningImpl(res, mdrDatabase));
			}

		}
	} finally {
		qexec.close();
	}

	return vmList;
}
 

/**
 * Executes a SPARQL SELECT.
 * 
 * @param query the SPARQL SELECT Query.
 * @return the {@link ResultSet} that includes matching bindings.
 * @throws UnableToExecuteQueryException in case of failure before, during or after the query execution.
 */
public CloseableResultSet select(final String selectQuery) throws UnableToExecuteQueryException {
	QueryExecution execution = null;
	try {
		execution = execution(selectQuery);
		return new CloseableResultSet(execution.execSelect(), execution);
	} catch (final Exception exception) {
		if (execution != null) { 
			execution.close();
		}
		throw new UnableToExecuteQueryException(exception);
	} 
}
 

/**
 * Method to execute full text search on the MDR to match given string with
 * the Datatype Names
 * 
 * @param datatypeName
 *            Name of the Datatype which is looked for
 * @param searchType
 *            Enumeration for types of Full Text Search
 * @return
 */
public List<? super DatatypeResource> searchDatatype(String datatypeName) {
	StringBuilder queryString = new StringBuilder(PREFIX_MDR)
			.append(PREFIX_RDFS).append(PREFIX_XSD)
			.append("SELECT ?datatype FROM <").append(MDRDatabase.BASE_URI)
			.append("> WHERE {")
			.append("?datatype rdfs:subClassOf mdr:Datatype. ")
			.append("?datatype mdr:datatypeName \"").append(datatypeName)
			.append("\"^^xsd:string }");

	List<DatatypeResource> datatypeList = new ArrayList<DatatypeResource>();
	QueryExecution qexec = this.createQueryExecution(
			queryString.toString(), this.mdrDatabase.getOntModel());
	try {
		ResultSet rs = qexec.execSelect();
		while (rs.hasNext()) {
			QuerySolution qs = rs.next();
			// here conceptualDomain is checked whether its enumerated or
			// not, proper instantiation is done
			Resource res = qs.getResource("datatype");
			datatypeList.add(new DatatypeImpl(res, mdrDatabase));

		}
	} finally {
		qexec.close();
	}
	return datatypeList;
}
 

/**
 * Executes a SPARQL ASK.
 * 
 * @param query the ASK SELECT Query.
 * @return the {@link ResultSet} that includes matching bindings.
 * @throws UnableToExecuteQueryException in case of failure before, during or after the query execution.
 */
public boolean ask(final String askQuery) throws UnableToExecuteQueryException {
	QueryExecution execution = null;
	try {
		return (execution = execution(askQuery)).execAsk();
	} catch (final Exception exception) {
		throw new UnableToExecuteQueryException(exception);
	} finally {
		execution.close();
	}
}