/// <summary> /// Makes a SPARQL Query against the underlying 4store Instance processing the results with the appropriate handler from those provided /// </summary> /// <param name="rdfHandler">RDF Handler</param> /// <param name="resultsHandler">Results Handler</param> /// <param name="sparqlQuery">SPARQL Query</param> public void Query(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler, String sparqlQuery) { try { // Ensure Proxy Settings have been taken from the class _endpoint.Proxy = Proxy; _endpoint.UseCredentialsForProxy = false; HttpWebResponse response = _endpoint.QueryRaw(sparqlQuery); StreamReader data = new StreamReader(response.GetResponseStream()); try { // Is the Content Type referring to a Sparql Result Set format? ISparqlResultsReader resreader = MimeTypesHelper.GetSparqlParser(response.ContentType); resreader.Load(resultsHandler, data); response.Close(); } catch (RdfParserSelectionException) { // If we get a Parser Selection exception then the Content Type isn't valid for a Sparql Result Set // Is the Content Type referring to a RDF format? IRdfReader rdfreader = MimeTypesHelper.GetParser(response.ContentType); rdfreader.Load(rdfHandler, data); response.Close(); } } catch (WebException webEx) { throw StorageHelper.HandleHttpQueryError(webEx); } }
/// <summary> /// Makes a SPARQL Query against the Knowledge Base /// </summary> /// <param name="sparqlQuery">SPARQL Query</param> /// <returns></returns> public Object Query(String sparqlQuery) { SparqlRemoteEndpoint endpoint = new SparqlRemoteEndpoint(UriFactory.Create(this._sparqlUri)); using (HttpWebResponse response = endpoint.QueryRaw(sparqlQuery)) { try { ISparqlResultsReader sparqlParser = MimeTypesHelper.GetSparqlParser(response.ContentType); SparqlResultSet results = new SparqlResultSet(); sparqlParser.Load(results, new StreamReader(response.GetResponseStream())); response.Close(); return(results); } catch (RdfParserSelectionException) { IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType); Graph g = new Graph(); parser.Load(g, new StreamReader(response.GetResponseStream())); response.Close(); return(g); } } }
/// <summary> /// Makes a SPARQL Query against the Knowledge Base /// </summary> /// <param name="sparqlQuery">SPARQL Query</param> /// <returns></returns> public Object Query(String sparqlQuery) { SparqlRemoteEndpoint endpoint = new SparqlRemoteEndpoint(new Uri(this._sparqlUri)); using (HttpWebResponse response = endpoint.QueryRaw(sparqlQuery)) { try { ISparqlResultsReader sparqlParser = MimeTypesHelper.GetSparqlParser(response.ContentType); SparqlResultSet results = new SparqlResultSet(); sparqlParser.Load(results, new StreamReader(response.GetResponseStream())); response.Close(); return results; } catch (RdfParserSelectionException) { IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType); Graph g = new Graph(); parser.Load(g, new StreamReader(response.GetResponseStream())); response.Close(); return g; } } }
/// <summary> /// Makes a Query against the SPARQL Endpoint processing the results with an appropriate handler from those provided. /// </summary> /// <param name="rdfHandler">RDF Handler.</param> /// <param name="resultsHandler">Results Handler.</param> /// <param name="sparqlQuery">SPARQL Query.</param> /// <returns></returns> public void Query(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler, String sparqlQuery) { if (!_skipLocalParsing) { // Parse the query locally to validate it and so we can decide what to do // when we receive the Response more easily as we'll know the query type // This also saves us wasting a HttpWebRequest on a malformed query SparqlQueryParser qparser = new SparqlQueryParser(); SparqlQuery q = qparser.ParseFromString(sparqlQuery); switch (q.QueryType) { case SparqlQueryType.Ask: case SparqlQueryType.Select: case SparqlQueryType.SelectAll: case SparqlQueryType.SelectAllDistinct: case SparqlQueryType.SelectAllReduced: case SparqlQueryType.SelectDistinct: case SparqlQueryType.SelectReduced: // Some kind of Sparql Result Set _endpoint.QueryWithResultSet(resultsHandler, sparqlQuery); break; case SparqlQueryType.Construct: case SparqlQueryType.Describe: case SparqlQueryType.DescribeAll: // Some kind of Graph _endpoint.QueryWithResultGraph(rdfHandler, sparqlQuery); break; case SparqlQueryType.Unknown: default: // Error throw new RdfQueryException("Unknown Query Type was used, unable to determine how to process the response"); } } else { // If we're skipping local parsing then we'll need to just make a raw query and process the response using (HttpWebResponse response = _endpoint.QueryRaw(sparqlQuery)) { try { // Is the Content Type referring to a Sparql Result Set format? ISparqlResultsReader sparqlParser = MimeTypesHelper.GetSparqlParser(response.ContentType); sparqlParser.Load(resultsHandler, new StreamReader(response.GetResponseStream())); response.Close(); } catch (RdfParserSelectionException) { // If we get a Parser Selection exception then the Content Type isn't valid for a Sparql Result Set // Is the Content Type referring to a RDF format? IRdfReader rdfParser = MimeTypesHelper.GetParser(response.ContentType); rdfParser.Load(rdfHandler, new StreamReader(response.GetResponseStream())); response.Close(); } } } }
public string QueryTripleStoreRaw(SparqlParameterizedString queryString) { if (queryString == null) { return(string.Empty); } queryString.AddAllColidNamespaces(); using var dataStream = _queryEndpoint.QueryRaw(queryString.ToString()).GetResponseStream(); using var reader = new StreamReader(dataStream); return(reader.ReadToEnd()); }
private bool SetupSparqlEndpointData() { try { SparqlRemoteEndpoint sparqlRemoteEndpoint = new SparqlRemoteEndpoint(new Uri("http://localhost:8890/sparql/"), new Uri("http://localhost:8890/test")); var response1 = sparqlRemoteEndpoint.QueryRaw("delete {?s ?p ?o} where {?s ?p ?o}"); var response2 = sparqlRemoteEndpoint.QueryRaw(insertQuery); if (response1.StatusCode == HttpStatusCode.OK && response2.StatusCode == HttpStatusCode.OK) { return(true); } return(false); } catch (Exception) { return(false); } }
/// <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> public void Query(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler, String sparqlQuery) { SparqlRemoteEndpoint endpoint = new SparqlRemoteEndpoint(UriFactory.Create(this._sparqlUri)); using (HttpWebResponse response = endpoint.QueryRaw(sparqlQuery)) { try { ISparqlResultsReader sparqlParser = MimeTypesHelper.GetSparqlParser(response.ContentType); sparqlParser.Load(resultsHandler, new StreamReader(response.GetResponseStream())); } catch (RdfParserSelectionException) { IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType); parser.Load(rdfHandler, new StreamReader(response.GetResponseStream())); } response.Close(); } }
public async Task <bool> ExecuteUpdateSparqlQueryAsync(string endpointName, string?graphName, string query) { if (!_endpoints.TryGetValue(endpointName, out var endpoint)) { return(false); } if (!endpoint.SupportedMethods.Sparql11.Equals("yes")) { return(false); } SparqlRemoteEndpoint sparqlEndpoint; if (graphName != null && endpoint.NamedGraphs == null) { return(false); } if (graphName != null && !endpoint.NamedGraphs.Exists(x => x.GraphName.Equals(graphName))) { return(false); } try { sparqlEndpoint = new SparqlRemoteEndpoint(new Uri(endpoint.EndpointUrl)); sparqlEndpoint.Timeout = DefaultSparqlEndpointConnectionTimeout; sparqlEndpoint.HttpMode = "POST"; var httpWebResponse = await Task.Run(() => sparqlEndpoint.QueryRaw(query)); if (httpWebResponse.StatusCode == HttpStatusCode.OK) { return(true); } } catch (RdfException) { return(false); } return(false); }