/// <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);
}
/// <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();
}
}
