public string QueryTripleStoreRaw(SparqlParameterizedString queryString) { var sparqlParser = new SparqlQueryParser(); AddAllColidNamespaces(queryString); var query = sparqlParser.ParseFromString(queryString); //Object results = _store.ExecuteQuery(query); Object results = _processor.ProcessQuery(query); if (results is IGraph) { IGraph g = (IGraph)results; return(ConvertGraphToString(g)); } throw new System.Exception("Execute failed"); }
public void SparqlServiceWithNonExistentService() { String query = "SELECT * WHERE { SERVICE <http://www.dotnetrdf.org/noSuchService> { ?s a ?type } } LIMIT 10"; SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery q = parser.ParseFromString(query); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(new TripleStore()); try { Object results = processor.ProcessQuery(q); Assert.True(false, "Should have errored"); } catch (RdfQueryException queryEx) { Console.WriteLine("Errored as expected"); TestTools.ReportError("Query Error", queryEx); } }
public void TestAsyncQueryWithQueryCallback() { var store = new TripleStore(); var g = new Graph(); g.LoadFromEmbeddedResource("VDS.RDF.Configuration.configuration.ttl"); store.Add(g); var dataset = new InMemoryDataset(store, g.BaseUri); var processor = new LeviathanQueryProcessor(dataset); var wait = new AutoResetEvent(false); var parser = new SparqlQueryParser(); var query = parser.ParseFromString( "SELECT * WHERE { ?instance a ?class }"); var callbackInvoked = false; var syncResultSet = processor.ProcessQuery(query) as SparqlResultSet; Assert.NotNull(syncResultSet); var syncResultCount = syncResultSet.Count; var resultSet = new SparqlResultSet(); var resultHandler = new ResultSetHandler(resultSet); processor.ProcessQuery(null, resultHandler, query, (rdfHandler, rsetHandler, state) => { try { Assert.IsNotType <AsyncError>(state); Assert.Equal("some state", state); } finally { callbackInvoked = true; wait.Set(); } }, "some state"); wait.WaitOne(); var resultCount = resultSet.Count; Assert.True(callbackInvoked); Assert.True(resultCount > 0); Assert.Equal(syncResultCount, resultCount); }
public static SparqlResultSet PerformQuery(string q, Graph g) { SparqlParameterizedString queryString = new SparqlParameterizedString(); queryString.Namespaces.AddNamespace("ldp", new Uri("http://www.w3.org/ns/ldp#")); queryString.Namespaces.AddNamespace("dct", new Uri("http://purl.org/dc/terms/")); queryString.CommandText = q; SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery query = parser.ParseFromString(queryString); TripleStore store = new TripleStore(); store.Add(g); ISparqlQueryProcessor processor = new LeviathanQueryProcessor(store); SparqlResultSet results = processor.ProcessQuery(query) as SparqlResultSet; return(results); }
public static AmrTerm GetAmrTerm(IGraph g, AmrNode node) { AmrTerm result = new AmrTerm(); SparqlQueryParser qparser = new SparqlQueryParser(); var str = "SELECT ?p WHERE { <" + node.uriid + "> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ?p }"; SparqlQuery q = qparser.ParseFromString(str); var rset = (SparqlResultSet)g.ExecuteQuery(q); var SB = new StringBuilder(); if (rset.Result && rset.Results.Count > 0) { foreach (var set in rset.Results) { foreach (var r in set) { result.uriid = r.Value.ToString(); } } } qparser = new SparqlQueryParser(); str = "SELECT ?p WHERE { <" + result.uriid + "> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> ?p }"; q = qparser.ParseFromString(str); rset = (SparqlResultSet)g.ExecuteQuery(q); if (rset.Result && rset.Results.Count > 0) { foreach (var set in rset.Results) { foreach (var r in set) { result.type = r.Value.ToString(); } } } //s http://amr.isi.edu/frames/ld/v1.2.2/dedicate-01 //x http://www.w3.org/1999/02/22-rdf-syntax-ns#type //p http://amr.isi.edu/rdf/core-amr#Frame return(result); }
public IGraph QueryTripleStoreGraphResult(SparqlParameterizedString queryString) { var sparqlParser = new SparqlQueryParser(); AddAllColidNamespaces(queryString); var query = sparqlParser.ParseFromString(queryString); Object results = _processor.ProcessQuery(query); if (results is IGraph) { //Print out the Results IGraph rset = (VDS.RDF.Graph)results; rset.BaseUri = new Uri("https://pid.bayer.com/fake-base-uri"); return(rset); } return(null); }
public void SparqlGroupByRefactor7() { String query = "SELECT ?s WHERE { ?s ?p ?o } GROUP BY (?s)"; SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery q = parser.ParseFromString(query); String queryStr = q.ToString(); Console.WriteLine("Raw ToString()"); Console.WriteLine(queryStr); Console.WriteLine(); Assert.Contains("GROUP BY ?s", queryStr); String queryStrFmt = new SparqlFormatter().Format(q); Console.WriteLine("Formatted String"); Console.WriteLine(queryStrFmt); Assert.Contains("GROUP BY ?s", queryStrFmt); }
public void SparqlServiceUsingDBPediaAndBindings() { Skip.IfNot(TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteParsing), "Test Config marks Remote Parsing as unavailable, test cannot be run"); String query = "SELECT * WHERE { SERVICE <http://dbpedia.org/sparql> { ?s a ?type } } VALUES ?s { <http://dbpedia.org/resource/Southampton> <http://dbpedia.org/resource/Ilkeston> }"; SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery q = parser.ParseFromString(query); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(new TripleStore()); Object results = processor.ProcessQuery(q); if (results is SparqlResultSet) { TestTools.ShowResults(results); } else { Assert.True(false, "Should have returned a SPARQL Result Set"); } }
public List <TriplesDM> GetTriples(string query) { List <TriplesDM> triples = new List <TriplesDM>(); SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery q = parser.ParseFromString(query); foreach (var item in q.RootGraphPattern.TriplePatterns) { triples.Add(new TriplesDM() { Subject = (item as TriplePattern).Subject.ToString(), Predicate = (item as TriplePattern).Predicate.ToString(), Obj = (item as TriplePattern).Object.ToString() }); var subject = (item as TriplePattern).Subject; var predicate = (item as TriplePattern).Predicate; var obj = (item as TriplePattern).Object; } return(triples); }
public static void ApplyInference(IGraph graph, IGraph schema) { string inverseOf = @" PREFIX owl: <http://www.w3.org/2002/07/owl#> CONSTRUCT { ?y ?q ?x } WHERE { ?p owl:inverseOf ?q . ?x ?p ?y . } "; var parser = new SparqlQueryParser(); var rules = new List <SparqlQuery>(); rules.Add(parser.ParseFromString(inverseOf)); var store = new TripleStore(); store.Add(graph, true); store.Add(schema, true); var queryProcessor = new LeviathanQueryProcessor(store); while (true) { int before = store.Triples.Count(); foreach (var rule in rules) { IGraph inferred = (IGraph)queryProcessor.ProcessQuery(rule); //store.Add(inferred); graph.Merge(inferred); } int after = store.Triples.Count(); if (after == before) { break; } } }
public void SparqlFormattingFilter2() { String query = "SELECT * WHERE { { ?s ?p ?o } FILTER(REGEX(?o, 'search', 'i')) }"; SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery q = parser.ParseFromString(query); Console.WriteLine("ToString() form:"); String toString = q.ToString(); Console.WriteLine(toString); Console.WriteLine(); Console.WriteLine("Format() form:"); String formatted = this._formatter.Format(q); Console.WriteLine(formatted); Assert.IsTrue(toString.Contains("FILTER"), "ToString() form should contain FILTER"); Assert.IsTrue(toString.Contains("i"), "ToString() form should contain i option"); Assert.IsTrue(formatted.Contains("FILTER"), "Format() form should contain FILTER"); Assert.IsTrue(toString.Contains("i"), "Format() form should contain i option"); }
public static String GetAmrNode(IGraph g, AMREduSentence sentence) { String result = string.Empty; SparqlQueryParser qparser = new SparqlQueryParser(); var str = "SELECT ?p WHERE { <" + sentence.urlid + "> <http://amr.isi.edu/rdf/core-amr#root> ?p }"; SparqlQuery q = qparser.ParseFromString(str); var rset = (SparqlResultSet)g.ExecuteQuery(q); var SB = new StringBuilder(); if (rset.Result && rset.Results.Count > 0) { foreach (var set in rset.Results) { foreach (var r in set) { result = r.Value.ToString(); } } } return(result); }
public void InsertValuesClause() { var g = new Graph(); g.LoadFromFile("resources\\rvesse.ttl"); var parser = new SparqlQueryParser(); SparqlQuery startingQuery = parser.ParseFromString("SELECT * WHERE { <http://www.dotnetrdf.org/people#rvesse> ?p ?o }"); var bindingVars = new List<string> {"p"}; var binding = new BindingsPattern(bindingVars); binding.AddTuple(new BindingTuple(bindingVars, new List<PatternItem> { new NodeMatchPattern(g.CreateUriNode(UriFactory.Create("http://xmlns.com/foaf/0.1/name"))) })); binding.AddTuple(new BindingTuple(bindingVars, new List<PatternItem> { new NodeMatchPattern(g.CreateUriNode(UriFactory.Create("http://xmlns.com/foaf/0.1/givenname"))) })); startingQuery.RootGraphPattern.AddInlineData(binding); g.ExecuteQuery(startingQuery).Should().BeAssignableTo<SparqlResultSet>().Which.Count.Should().Be(2); }
public IEnumerable <IDataObject> BindRdfDataObjects(IGraph g, IList <OrderingDirection> orderingDirections) { var p = new LeviathanQueryProcessor(new InMemoryDataset(g)); var queryString = MakeOrderedResourceQuery(orderingDirections); var sparqlParser = new SparqlQueryParser(); var query = sparqlParser.ParseFromString(queryString); var queryResultSet = p.ProcessQuery(query) as SparqlResultSet; if (queryResultSet != null) { foreach (var row in queryResultSet.Results) { INode uriNode; if (row.TryGetBoundValue("x", out uriNode) && uriNode is IUriNode) { yield return(BindRdfDataObject((IUriNode)uriNode, g)); } } } }
public SparqlResultSet RunQueryDataTable(String queryString) { queryString = "PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> \n " + "PREFIX owl: <http://www.w3.org/2002/07/owl#> \n " + "PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> \n " + "PREFIX xsd: <http://www.w3.org/2001/XMLSchema#> \n " + queryString; SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery query = parser.ParseFromString(queryString); Object resultsSet = Ontology.ExecuteQuery(query); if (resultsSet is SparqlResultSet) { return((SparqlResultSet)resultsSet); } else { return(null); } }
public void SparqlBindToExistingVariableLazy() { String query = "PREFIX fn: <" + XPathFunctionFactory.XPathFunctionsNamespace + "> SELECT * WHERE { ?s ?p ?o . BIND(?s AS ?p) } LIMIT 1"; TripleStore store = new TripleStore(); Graph g = new Graph(); FileLoader.Load(g, "InferenceTest.ttl"); store.Add(g); SparqlQueryParser parser = new SparqlQueryParser(); try { SparqlQuery q = parser.ParseFromString(query); Console.WriteLine(q.ToAlgebra().ToString()); Assert.IsTrue(q.ToAlgebra().ToString().Contains("LazyBgp"), "Should have been optimised to use a Lazy BGP"); Console.WriteLine(); store.ExecuteQuery(q); Assert.Fail("Expected a RdfParseException/RdfQueryException to be thrown"); } catch (RdfParseException parseEx) { Console.WriteLine("Parsing Error thrown as expected"); TestTools.ReportError("Parser Error", parseEx); } catch (RdfQueryException queryEx) { Console.WriteLine("Query Error thrown as expected"); TestTools.ReportError("Query Error", queryEx); } catch (Exception ex) { TestTools.ReportError("Unexpected Error", ex); Assert.Fail("Did not get a RdfParseException/RdfQueryException as expected"); } }
public SparqlResultSet QueryTripleStoreResultSet(SparqlParameterizedString parameterizedString) { var processor = new LeviathanQueryProcessor(_dataset); var sparqlParser = new SparqlQueryParser(); AddAllPidNamespaces(parameterizedString); var query = sparqlParser.ParseFromString(parameterizedString); Object results = processor.ProcessQuery(query); //Object results = _store.ExecuteQuery(query); if (results is SparqlResultSet rset) { //Print out the Results return(rset); } return(null); }
private void ProcessPartialResult( SparqlParameterizedString parametrizedCommandText, SparqlQueryVariables queryVariables, SparqlQueryParser parser, List <SparqlResult> result, SparqlResult row, ParallelLoopState state) { if (state.IsStopped) { return; } SparqlQuery query; lock (parametrizedCommandText) { parametrizedCommandText.SetUri("graph", ((IUriNode)row[queryVariables.MetaGraph]).Uri); query = parser.ParseFromString(parametrizedCommandText); } query.Timeout = Timeout; try { var graphResult = ((SparqlResultSet)_processor.ProcessQuery(query)).Results; lock (result) { result.AddRange(graphResult); } } catch (RdfQueryTimeoutException) { state.Stop(); lock (result) { result.Clear(); } } }
public override org.openrdf.query.Query prepareQuery(org.openrdf.query.QueryLanguage ql, string str) { if (!this.SupportsQueryLanguage(ql)) { throw UnsupportedQueryLanguage(ql); } try { SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery q = parser.ParseFromString(str); switch (q.QueryType) { case SparqlQueryType.Ask: return(new InMemoryBooleanQuery(str, this._store)); case SparqlQueryType.Construct: case SparqlQueryType.Describe: case SparqlQueryType.DescribeAll: return(new InMemoryGraphQuery(str, this._store)); case SparqlQueryType.Select: case SparqlQueryType.SelectAll: case SparqlQueryType.SelectAllDistinct: case SparqlQueryType.SelectAllReduced: case SparqlQueryType.SelectDistinct: case SparqlQueryType.SelectReduced: return(new InMemoryTupleQuery(str, this._store)); case SparqlQueryType.Unknown: default: throw new dotSesameQuery.MalformedQueryException("Unable to parse the given Query into a valid SPARQL Query as the Query Type is unknown"); } } catch (RdfParseException parseEx) { throw new dotSesameQuery.MalformedQueryException("Unable to parse the given Query into a valid SPARQL Query due to the following error: " + parseEx.Message); } }
public void LoadRoot(IGraph graph) { SparqlQueryParser qparser = new SparqlQueryParser(); StringBuilder querystr = new StringBuilder(); querystr.AppendLine("PREFIX amr-core: <http://amr.isi.edu/rdf/core-amr#>"); querystr.AppendLine("PREFIX amr-data: <http://amr.isi.edu/amr_data#>"); querystr.AppendLine("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>"); querystr.AppendLine("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>"); querystr.AppendLine("PREFIX amr-terms: <http://amr.isi.edu/rdf/amr-terms#>"); querystr.Append("SELECT ?root "); querystr.Append("WHERE {"); querystr.Append("@sentenceuri amr-core:root ?root "); querystr.Append("}"); SparqlParameterizedString command = new SparqlParameterizedString(); command.CommandText = querystr.ToString(); command.SetUri("sentenceuri", this.urlid); SparqlQuery q = qparser.ParseFromString(command); var rset = (SparqlResultSet)graph.ExecuteQuery(q); var SB = new StringBuilder(); if (rset.Result && rset.Results.Count > 0) { foreach (var result in rset.Results) { this.Root = new AMRNode(); this.Root.Id = ((UriNode)result.ElementAt(0).Value).Uri; LoadData(graph, this.Root); LoadChildren(graph, this.Root, new List <AMRNode>() { this.Root }); } } }
public void SparqlBindScope6() { String query = @"PREFIX : <http://example.org> SELECT * WHERE { { GRAPH ?g { :s :p ?o } BIND (?g AS ?in) } UNION { :s :p ?o . BIND('default' AS ?in) } }"; SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery q = parser.ParseFromString(query); Console.WriteLine(q.ToString()); ISparqlAlgebra algebra = q.ToAlgebra(); Console.WriteLine(algebra.ToString()); Assert.IsInstanceOfType(algebra, typeof(Select)); algebra = ((IUnaryOperator)algebra).InnerAlgebra; Assert.IsInstanceOfType(algebra, typeof(Union)); IUnion union = (Union)algebra; ISparqlAlgebra lhs = union.Lhs; Assert.IsInstanceOfType(lhs, typeof(Extend)); ISparqlAlgebra rhs = union.Rhs; Assert.IsInstanceOfType(rhs, typeof(Join)); }
public void SparqlEvaluationGraphNonExistentUri() { String query = "SELECT * WHERE { GRAPH <http://example.org/noSuchGraph> { ?s ?p ?o } }"; TripleStore store = new TripleStore(); var processor = new LeviathanQueryProcessor(store); var parser = new SparqlQueryParser(); var q = parser.ParseFromString(query); Object results = processor.ProcessQuery(q); if (results is SparqlResultSet) { TestTools.ShowResults(results); SparqlResultSet rset = (SparqlResultSet)results; Assert.True(rset.IsEmpty, "Result Set should be empty"); Assert.Equal(3, rset.Variables.Count()); } else { Assert.True(false, "Query should have returned a SPARQL Result Set"); } }
public void SparqlResultSetToDataTable6() { String query = "ASK WHERE {?s <http://example.org/noSuchPredicate> ?o}"; SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery q = parser.ParseFromString(query); Graph g = new Graph(); FileLoader.Load(g, "InferenceTest.ttl"); Object results = g.ExecuteQuery(q); if (results is SparqlResultSet) { SparqlResultSet rset = (SparqlResultSet)results; DataTable table = (DataTable)rset; Assert.IsTrue(rset.ResultsType == SparqlResultsType.Boolean); Assert.AreEqual(table.Columns.Count, 1, "Should only be one Column"); Assert.AreEqual(table.Rows.Count, 1, "Should only be one Row"); Assert.IsFalse((bool)table.Rows[0]["ASK"], "Should be false"); foreach (DataRow row in table.Rows) { foreach (DataColumn col in table.Columns) { Object temp = row[col]; Console.Write(col.ColumnName + " = " + ((temp != null) ? temp.ToString() : String.Empty) + " , "); } Console.WriteLine(); } } else { Assert.Fail("Query should have returned a Result Set"); } }
public static List <SparqlResult> RunQuery(string url, string queryString) { TripleStore store = new TripleStore(); //Assume that we fill our Store with data from somewhere //Create a dataset for our queries to operate over //We need to explicitly state our default graph or the unnamed graph is used //Alternatively you can set the second parameter to true to use the union of all graphs //as the default graph InMemoryDataset ds = new InMemoryDataset(store, new Uri(url)); //Get the Query processor ISparqlQueryProcessor processor = new LeviathanQueryProcessor(ds); //Use the SparqlQueryParser to give us a SparqlQuery object //Should get a Graph back from a CONSTRUCT query SparqlQueryParser sparqlparser = new SparqlQueryParser(); SparqlQuery query = sparqlparser.ParseFromString(queryString); var result = processor.ProcessQuery(query); if (result is SparqlResultSet) { var results = (SparqlResultSet)result; return(results.ToList()); } //if (result is IGraph) //{ // //Print out the Results // IGraph g = (IGraph)result; // NTriplesFormatter formatter = new NTriplesFormatter(); // return g.Triples.ToList(); //} return(null); }
public void SparqlResultSetToDataTable5() { String query = "ASK WHERE {?s ?p ?o}"; SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery q = parser.ParseFromString(query); Graph g = new Graph(); FileLoader.Load(g, "resources\\InferenceTest.ttl"); Object results = g.ExecuteQuery(q); if (results is SparqlResultSet) { SparqlResultSet rset = (SparqlResultSet)results; DataTable table = rset.ToDataTable(); Assert.True(rset.ResultsType == SparqlResultsType.Boolean); Assert.Equal(table.Columns.Count, 1); Assert.Equal(table.Rows.Count, 1); Assert.True((bool)table.Rows[0]["ASK"], "Should be true"); foreach (DataRow row in table.Rows) { foreach (DataColumn col in table.Columns) { Object temp = row[col]; Console.Write(col.ColumnName + " = " + ((temp != null) ? temp.ToString() : String.Empty) + " , "); } Console.WriteLine(); } } else { Assert.True(false, "Query should have returned a Result Set"); } }
public void SparqlServiceUsingDBPedia() { if (!TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteParsing)) { throw new SkipTestException("Test Config marks Remote Parsing as unavailable, test cannot be run"); } String query = "SELECT * WHERE { SERVICE <http://dbpedia.org/sparql> { ?s a ?type } } LIMIT 10"; SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery q = parser.ParseFromString(query); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(new TripleStore()); Object results = processor.ProcessQuery(q); if (results is SparqlResultSet) { TestTools.ShowResults(results); } else { Assert.True(false, "Should have returned a SPARQL Result Set"); } }
public IGraph QueryTripleStoreGraphResult(SparqlParameterizedString queryString) { var processor = new LeviathanQueryProcessor(_dataset); var sparqlParser = new SparqlQueryParser(); AddAllPidNamespaces(queryString); var query = sparqlParser.ParseFromString(queryString); Object results = processor.ProcessQuery(query); //Object results = _store.ExecuteQuery(query); if (results is IGraph) { //Print out the Results IGraph rset = (VDS.RDF.Graph)results; return(rset); } return(null); }
public LastBlockInfo GetLastBlockInfo() { _logger.LogDebug("Getting last block info..."); string queryName = "get_last_block_info"; _logger.LogTrace("Invoking the '{0}' SPARQL query...", queryName); string query = String.Format(_queryTemplatesService.GetQueryTemplate(queryName), _chainGraphIri); var parser = new SparqlQueryParser(); SparqlQuery tupleQuery = parser.ParseFromString(query); var processor = new LeviathanQueryProcessor(_repository); var resultSet = processor.ProcessQuery(tupleQuery) as SparqlResultSet; if (resultSet.IsEmpty) { return(null); } var bindingSet = resultSet.Results[0]; string lastBlockIri = bindingSet.Value("lastBlockIRI").ToString(); string lastBlockHash = (bindingSet.Value("lastBlockHash") as ILiteralNode).Value; string lastBlockIndex = (bindingSet.Value("lastBlockIndex") as ILiteralNode).Value; return(new LastBlockInfo(lastBlockIri, lastBlockHash, lastBlockIndex)); }
public void SparqlBindScope5() { String query = @"PREFIX : <http://example.org> SELECT * WHERE { GRAPH ?g { :s :p ?o } BIND (?g AS ?in) }"; SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery q = parser.ParseFromString(query); Console.WriteLine(q.ToString()); ISparqlAlgebra algebra = q.ToAlgebra(); Console.WriteLine(algebra.ToString()); Assert.IsInstanceOfType(algebra, typeof(Select)); algebra = ((IUnaryOperator)algebra).InnerAlgebra; Assert.IsInstanceOfType(algebra, typeof(Extend)); }
/// <summary> /// Processes a SPARQL Query against the Knowledge Base passing the results to the RDF or Results handler as appropriate /// </summary> /// <param name="rdfHandler">RDF Handler</param> /// <param name="resultsHandler">Results Handler</param> /// <param name="sparqlQuery">SPARQL Query</param> /// <param name="callback">Callback to invoke once handling of results has completed</param> /// <param name="state">State to pass to the callback</param> public void Query(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler, String sparqlQuery, QueryCallback callback, Object state) { SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery q = parser.ParseFromString(sparqlQuery); SparqlRemoteEndpoint endpoint = new SparqlRemoteEndpoint(UriFactory.Create(this._sparqlUri)); switch (q.QueryType) { case SparqlQueryType.Ask: case SparqlQueryType.Select: case SparqlQueryType.SelectAll: case SparqlQueryType.SelectAllDistinct: case SparqlQueryType.SelectAllReduced: case SparqlQueryType.SelectDistinct: case SparqlQueryType.SelectReduced: endpoint.QueryWithResultSet(sparqlQuery, (rs, _) => { resultsHandler.Apply(rs); callback(rdfHandler, resultsHandler, state); }, state); break; case SparqlQueryType.Construct: case SparqlQueryType.Describe: case SparqlQueryType.DescribeAll: endpoint.QueryWithResultGraph(sparqlQuery, (g, _) => { rdfHandler.Apply(g); callback(rdfHandler, resultsHandler, state); }, state); break; default: throw new RdfQueryException("Cannot execute unknown query types against Pellet Server"); } }