/// <summary>
/// Executes a SPARQL Query on the Fuseki store processing the results using 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>
/// <param name="callback">Callback</param>
/// <param name="state">State to pass to the callback</param>
/// <returns></returns>
public void Query(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler, String sparqlQuery, AsyncStorageCallback callback, Object state)
{
try
{
HttpWebRequest request;
// Create the Request, always use POST for async for simplicity
String queryUri = _queryUri;
request = (HttpWebRequest)WebRequest.Create(queryUri);
request.Method = "POST";
request.Accept = MimeTypesHelper.HttpRdfOrSparqlAcceptHeader;
request = ApplyRequestOptions(request);
// Build the Post Data and add to the Request Body
request.ContentType = MimeTypesHelper.Utf8WWWFormURLEncoded;
StringBuilder postData = new StringBuilder();
postData.Append("query=");
postData.Append(HttpUtility.UrlEncode(sparqlQuery));
request.BeginGetRequestStream(r =>
{
try
{
Stream stream = request.EndGetRequestStream(r);
using (StreamWriter writer = new StreamWriter(stream, new UTF8Encoding(Options.UseBomForUtf8)))
{
writer.Write(postData);
writer.Close();
}
Tools.HttpDebugRequest(request);
// Get the Response and process based on the Content Type
request.BeginGetResponse(r2 =>
{
try
{
HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(r2);
Tools.HttpDebugResponse(response);
StreamReader data = new StreamReader(response.GetResponseStream());
String ctype = response.ContentType;
try
{
// Is the Content Type referring to a Sparql Result Set format?
ISparqlResultsReader resreader = MimeTypesHelper.GetSparqlParser(ctype, true);
resreader.Load(resultsHandler, data);
response.Close();
}
catch (RdfParserSelectionException)
{
// If we get a Parse 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(ctype);
rdfreader.Load(rdfHandler, data);
response.Close();
}
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlQueryWithHandler, sparqlQuery, rdfHandler, resultsHandler), state);
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlQueryWithHandler, StorageHelper.HandleHttpQueryError(webEx)), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlQueryWithHandler, StorageHelper.HandleQueryError(ex)), state);
}
}, state);
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlQueryWithHandler, StorageHelper.HandleHttpQueryError(webEx)), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlQueryWithHandler, StorageHelper.HandleQueryError(ex)), state);
}
}, state);
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlQueryWithHandler, StorageHelper.HandleHttpQueryError(webEx)), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlQueryWithHandler, StorageHelper.HandleQueryError(ex)), state);
}
}
/// <summary>
/// Executes a SPARQL Query on the Fuseki store processing the results using 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)
{
try
{
HttpWebRequest request;
// Create the Request
String queryUri = _queryUri;
if (sparqlQuery.Length < 2048)
{
queryUri += "?query=" + Uri.EscapeDataString(sparqlQuery);
request = (HttpWebRequest)WebRequest.Create(queryUri);
request.Method = "GET";
request.Accept = MimeTypesHelper.HttpRdfOrSparqlAcceptHeader;
request = ApplyRequestOptions(request);
}
else
{
request = (HttpWebRequest)WebRequest.Create(queryUri);
request.Method = "POST";
request.Accept = MimeTypesHelper.HttpRdfOrSparqlAcceptHeader;
request = ApplyRequestOptions(request);
// Build the Post Data and add to the Request Body
request.ContentType = MimeTypesHelper.Utf8WWWFormURLEncoded;
StringBuilder postData = new StringBuilder();
postData.Append("query=");
postData.Append(HttpUtility.UrlEncode(sparqlQuery));
using (StreamWriter writer = new StreamWriter(request.GetRequestStream(), new UTF8Encoding(Options.UseBomForUtf8)))
{
writer.Write(postData);
writer.Close();
}
}
Tools.HttpDebugRequest(request);
// Get the Response and process based on the Content Type
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
Tools.HttpDebugResponse(response);
StreamReader data = new StreamReader(response.GetResponseStream());
String ctype = response.ContentType;
try
{
// Is the Content Type referring to a RDF format?
IRdfReader rdfreader = MimeTypesHelper.GetParser(ctype);
rdfreader.Load(rdfHandler, data);
response.Close();
}
catch (RdfParserSelectionException)
{
// If we get a Parser selection exception then the Content Type isn't valid for a RDF Graph
// Is the Content Type referring to a Sparql Result Set format?
ISparqlResultsReader resreader = MimeTypesHelper.GetSparqlParser(ctype, true);
resreader.Load(resultsHandler, data);
response.Close();
}
}
}
catch (WebException webEx)
{
throw StorageHelper.HandleHttpQueryError(webEx);
}
}
/// <summary>
/// Queries the store asynchronously
/// </summary>
/// <param name="sparqlQuery">SPARQL Query</param>
/// <param name="rdfHandler">RDF Handler</param>
/// <param name="resultsHandler">Results Handler</param>
/// <param name="callback">Callback</param>
/// <param name="state">State to pass to the callback</param>
public void Query(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler, string sparqlQuery, AsyncStorageCallback callback, object state)
{
try
{
//First off parse the Query to see what kind of query it is
SparqlQuery q;
try
{
q = this._parser.ParseFromString(sparqlQuery);
}
catch (RdfParseException parseEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlQueryWithHandler, parseEx), state);
return;
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlQueryWithHandler, new RdfStorageException("An unexpected error occurred while trying to parse the SPARQL Query prior to sending it to the Store, see inner exception for details", ex)), state);
return;
}
//Now select the Accept Header based on the query type
String accept = (SparqlSpecsHelper.IsSelectQuery(q.QueryType) || q.QueryType == SparqlQueryType.Ask) ? MimeTypesHelper.HttpSparqlAcceptHeader : MimeTypesHelper.HttpAcceptHeader;
//Create the Request, for simplicity async requests are always POST
HttpWebRequest request;
Dictionary <String, String> queryParams = new Dictionary <string, string>();
request = this.CreateRequest("/sparql", accept, "POST", queryParams);
request.ContentType = MimeTypesHelper.WWWFormURLEncoded;
Tools.HttpDebugRequest(request);
request.BeginGetRequestStream(r =>
{
try
{
Stream stream = request.EndGetRequestStream(r);
using (StreamWriter writer = new StreamWriter(stream))
{
writer.Write("query=");
writer.Write(HttpUtility.UrlEncode(sparqlQuery));
writer.Close();
}
request.BeginGetResponse(r2 =>
{
//Get the Response and process based on the Content Type
try
{
HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(r2);
Tools.HttpDebugResponse(response);
StreamReader data = new StreamReader(response.GetResponseStream());
String ctype = response.ContentType;
if (SparqlSpecsHelper.IsSelectQuery(q.QueryType) || q.QueryType == SparqlQueryType.Ask)
{
//ASK/SELECT should return SPARQL Results
ISparqlResultsReader resreader = MimeTypesHelper.GetSparqlParser(ctype, q.QueryType == SparqlQueryType.Ask);
resreader.Load(resultsHandler, data);
response.Close();
}
else
{
//CONSTRUCT/DESCRIBE should return a Graph
IRdfReader rdfreader = MimeTypesHelper.GetParser(ctype);
rdfreader.Load(rdfHandler, data);
response.Close();
}
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlQueryWithHandler, StorageHelper.HandleHttpQueryError(webEx)), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlQueryWithHandler, StorageHelper.HandleQueryError(ex)), state);
}
}, state);
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlQueryWithHandler, StorageHelper.HandleHttpQueryError(webEx)), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlQueryWithHandler, StorageHelper.HandleQueryError(ex)), state);
}
}, state);
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlQueryWithHandler, StorageHelper.HandleHttpQueryError(webEx)), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlQueryWithHandler, StorageHelper.HandleQueryError(ex)), state);
}
}
/// <summary>
/// Makes a Query asynchronously where the expected Result is a <see cref="SparqlResultSet">SparqlResultSet</see> i.e. SELECT and ASK Queries.
/// </summary>
/// <param name="query">SPARQL Query String.</param>
/// <param name="handler">Results Handler.</param>
/// <param name="callback">Callback to invoke when the query completes.</param>
/// <param name="state">State to pass to the callback.</param>
public void QueryWithResultSet(ISparqlResultsHandler handler, String query, QueryCallback callback, Object state)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Uri);
request.Method = "POST";
request.ContentType = MimeTypesHelper.Utf8WWWFormURLEncoded;
request.Accept = RdfAcceptHeader;
ApplyRequestOptions(request);
Tools.HttpDebugRequest(request);
try
{
request.BeginGetRequestStream(result =>
{
try
{
Stream stream = request.EndGetRequestStream(result);
using (StreamWriter writer = new StreamWriter(stream, new UTF8Encoding(Options.UseBomForUtf8)))
{
writer.Write("query=");
writer.Write(HttpUtility.UrlEncode(query));
foreach (String u in DefaultGraphs)
{
writer.Write("&default-graph-uri=");
writer.Write(HttpUtility.UrlEncode(u));
}
foreach (String u in NamedGraphs)
{
writer.Write("&named-graph-uri=");
writer.Write(HttpUtility.UrlEncode(u));
}
writer.Close();
}
request.BeginGetResponse(innerResult =>
{
try
{
using (HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(innerResult))
{
Tools.HttpDebugResponse(response);
ISparqlResultsReader parser = MimeTypesHelper.GetSparqlParser(response.ContentType, false);
parser.Load(handler, new StreamReader(response.GetResponseStream()));
response.Close();
callback(null, handler, state);
}
}
catch (SecurityException secEx)
{
callback(null, handler, new AsyncError(new RdfQueryException("Calling code does not have permission to access the specified remote endpoint, see inner exception for details", secEx), state));
}
catch (WebException webEx)
{
if (webEx.Response != null)
{
Tools.HttpDebugResponse((HttpWebResponse)webEx.Response);
}
callback(null, handler, new AsyncError(new RdfQueryException("A HTTP error occurred while making an asynchronous query, see inner exception for details", webEx), state));
}
catch (Exception ex)
{
callback(null, handler, new AsyncError(new RdfQueryException("Unexpected error while making an asynchronous query, see inner exception for details", ex), state));
}
}, null);
}
catch (WebException webEx)
{
if (webEx.Response != null)
{
Tools.HttpDebugResponse((HttpWebResponse)webEx.Response);
}
callback(null, handler, new AsyncError(new RdfQueryException("A HTTP error occurred while making an asynchronous query, see inner exception for details", webEx), state));
}
catch (Exception ex)
{
callback(null, handler, new AsyncError(new RdfQueryException("Unexpected error while making an asynchronous query, see inner exception for details", ex), state));
}
}, null);
}
catch (Exception ex)
{
callback(null, handler, new AsyncError(new RdfQueryException("Unexpected error while making an asynchronous query, see inner exception for details", ex), state));
}
}
/// <summary>
/// Performs a SPARQL Query against the underlying Store
/// </summary>
/// <param name="rdfHandler">RDF Handler</param>
/// <param name="resultsHandler">SPARQL Results Handler</param>
/// <param name="sparqlQuery">SPARQL Query</param>
/// <returns></returns>
public void Query(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler, string sparqlQuery)
{
try
{
//First off parse the Query to see what kind of query it is
SparqlQuery q;
try
{
q = this._parser.ParseFromString(sparqlQuery);
}
catch (RdfParseException)
{
throw;
}
catch (Exception ex)
{
throw new RdfStorageException("An unexpected error occurred while trying to parse the SPARQL Query prior to sending it to the Store, see inner exception for details", ex);
}
//Now select the Accept Header based on the query type
String accept = (SparqlSpecsHelper.IsSelectQuery(q.QueryType) || q.QueryType == SparqlQueryType.Ask) ? MimeTypesHelper.HttpSparqlAcceptHeader : MimeTypesHelper.HttpAcceptHeader;
//Create the Request
HttpWebRequest request;
Dictionary <String, String> queryParams = new Dictionary <string, string>();
if (sparqlQuery.Length < 2048)
{
queryParams.Add("query", sparqlQuery);
request = this.CreateRequest("/sparql", accept, "GET", queryParams);
}
else
{
request = this.CreateRequest("/sparql", accept, "POST", queryParams);
//Build the Post Data and add to the Request Body
request.ContentType = MimeTypesHelper.WWWFormURLEncoded;
StringBuilder postData = new StringBuilder();
postData.Append("query=");
postData.Append(HttpUtility.UrlEncode(sparqlQuery));
StreamWriter writer = new StreamWriter(request.GetRequestStream());
writer.Write(postData);
writer.Close();
}
Tools.HttpDebugRequest(request);
//Get the Response and process based on the Content Type
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
Tools.HttpDebugResponse(response);
StreamReader data = new StreamReader(response.GetResponseStream());
String ctype = response.ContentType;
if (SparqlSpecsHelper.IsSelectQuery(q.QueryType) || q.QueryType == SparqlQueryType.Ask)
{
//ASK/SELECT should return SPARQL Results
ISparqlResultsReader resreader = MimeTypesHelper.GetSparqlParser(ctype, q.QueryType == SparqlQueryType.Ask);
resreader.Load(resultsHandler, data);
response.Close();
}
else
{
//CONSTRUCT/DESCRIBE should return a Graph
IRdfReader rdfreader = MimeTypesHelper.GetParser(ctype);
rdfreader.Load(rdfHandler, data);
response.Close();
}
}
}
catch (WebException webEx)
{
throw StorageHelper.HandleHttpQueryError(webEx);
}
}
/// <summary>
/// Makes a SPARQL Query against the underlying Store 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 virtual void Query(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler, String sparqlQuery)
{
try
{
//Pre-parse the query to determine what the Query Type is
bool isAsk = false;
SparqlQuery q = null;
try
{
q = this._parser.ParseFromString(sparqlQuery);
isAsk = q.QueryType == SparqlQueryType.Ask;
}
catch
{
//If parsing error fallback to naive detection
isAsk = Regex.IsMatch(sparqlQuery, "ASK", RegexOptions.IgnoreCase);
}
//Select Accept Header
String accept;
if (q != null)
{
accept = (SparqlSpecsHelper.IsSelectQuery(q.QueryType) || q.QueryType == SparqlQueryType.Ask ? MimeTypesHelper.HttpSparqlAcceptHeader : MimeTypesHelper.HttpAcceptHeader);
}
else
{
accept = MimeTypesHelper.HttpRdfOrSparqlAcceptHeader;
}
HttpWebRequest request;
//Create the Request
Dictionary <String, String> queryParams = new Dictionary <string, string>();
if (sparqlQuery.Length < 2048 && !this._postAllQueries)
{
queryParams.Add("query", EscapeQuery(sparqlQuery));
request = this.CreateRequest(this._repositoriesPrefix + this._store + this._queryPath, accept, "GET", queryParams);
}
else
{
request = this.CreateRequest(this._repositoriesPrefix + this._store + this._queryPath, accept, "POST", queryParams);
//Build the Post Data and add to the Request Body
request.ContentType = MimeTypesHelper.WWWFormURLEncoded;
StringBuilder postData = new StringBuilder();
postData.Append("query=");
postData.Append(Uri.EscapeDataString(EscapeQuery(sparqlQuery)));
StreamWriter writer = new StreamWriter(request.GetRequestStream());
writer.Write(postData);
writer.Close();
}
#if DEBUG
if (Options.HttpDebugging)
{
Tools.HttpDebugRequest(request);
}
#endif
//Get the Response and process based on the Content Type
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
#if DEBUG
if (Options.HttpDebugging)
{
Tools.HttpDebugResponse(response);
}
#endif
StreamReader data = new StreamReader(response.GetResponseStream());
String ctype = response.ContentType;
try
{
//Is the Content Type referring to a Sparql Result Set format?
ISparqlResultsReader resreader = MimeTypesHelper.GetSparqlParser(ctype, isAsk);
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(ctype);
if (q != null && (SparqlSpecsHelper.IsSelectQuery(q.QueryType) || q.QueryType == SparqlQueryType.Ask))
{
SparqlRdfParser resreader = new SparqlRdfParser(rdfreader);
resreader.Load(resultsHandler, data);
}
else
{
rdfreader.Load(rdfHandler, data);
}
response.Close();
}
}
}
catch (WebException webEx)
{
if (webEx.Response != null)
{
#if DEBUG
if (Options.HttpDebugging)
{
Tools.HttpDebugResponse((HttpWebResponse)webEx.Response);
}
#endif
if (webEx.Response.ContentLength > 0)
{
try
{
String responseText = new StreamReader(webEx.Response.GetResponseStream()).ReadToEnd();
throw new RdfQueryException("A HTTP error occured while querying the Store. Store returned the following error message: " + responseText, webEx);
}
catch
{
throw new RdfQueryException("A HTTP error occurred while querying the Store", webEx);
}
}
else
{
throw new RdfQueryException("A HTTP error occurred while querying the Store", webEx);
}
}
else
{
throw new RdfQueryException("A HTTP error occurred while querying the Store", webEx);
}
}
}
static void DoQuery(Dictionary <String, String> arguments)
{
SparqlRemoteEndpoint endpoint;
bool verbose = arguments.ContainsKey("verbose") || arguments.ContainsKey("v");
if (verbose)
{
Options.HttpDebugging = true;
}
//First get the Server to which we are going to connect
try
{
if (arguments.ContainsKey("server") && !arguments["server"].Equals(String.Empty))
{
endpoint = new SparqlRemoteEndpoint(new Uri(arguments["server"]));
}
else if (arguments.ContainsKey("service") && !arguments["service"].Equals(String.Empty))
{
endpoint = new SparqlRemoteEndpoint(new Uri(arguments["service"]));
}
else
{
Console.Error.WriteLine("soh: Error: Required --server/--service argument not present");
Environment.Exit(-1);
return;
}
}
catch (UriFormatException uriEx)
{
Console.Error.WriteLine("soh: Error: Malformed SPARQL Endpoint URI");
Console.Error.WriteLine(uriEx.Message);
Environment.Exit(-1);
return;
}
if (verbose)
{
Console.Error.WriteLine("soh: SPARQL Endpoint for URI " + endpoint.Uri + " created OK");
}
//Then decide where to get the query to execute from
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery query;
try
{
if (arguments.ContainsKey("query") && !arguments["query"].Equals(String.Empty))
{
query = parser.ParseFromFile(arguments["query"]);
}
else if (arguments.ContainsKey("file") && !arguments["file"].Equals(String.Empty))
{
query = parser.ParseFromFile(arguments["file"]);
}
else if (arguments.ContainsKey("$1") && !arguments["$1"].Equals(String.Empty))
{
query = parser.ParseFromString(arguments["$1"]);
}
else
{
Console.Error.WriteLine("soh: Error: Required SPARQL Query not found - may be specified as --file/--query FILE or as final argument");
Environment.Exit(-1);
return;
}
}
catch (Exception ex)
{
Console.Error.WriteLine("soh: Error: Error Parsing SPARQL Query");
Console.Error.WriteLine(ex.Message);
Environment.Exit(-1);
return;
}
if (verbose)
{
Console.Error.WriteLine("soh: Parsed Query OK");
Console.Error.WriteLine("soh: dotNetRDF's interpretation of the Query:");
SparqlFormatter formatter = new SparqlFormatter();
Console.Error.WriteLine(formatter.Format(query));
Console.Error.WriteLine("soh: Submitting Query");
}
try
{
using (HttpWebResponse response = endpoint.QueryRaw(query.ToString()))
{
MimeTypeDefinition definition = MimeTypesHelper.GetDefinitions(response.ContentType).FirstOrDefault();
Encoding enc;
if (definition != null)
{
enc = definition.Encoding;
}
else if (!response.ContentEncoding.Equals(String.Empty))
{
enc = Encoding.GetEncoding(response.ContentEncoding);
}
else if (response.ContentType.Contains("charset="))
{
enc = Encoding.GetEncoding(response.ContentType.Substring(response.ContentType.IndexOf('=') + 1));
}
else
{
enc = Console.OutputEncoding;
}
if (verbose)
{
Console.Error.WriteLine("soh: Got Response from SPARQL Endpoint OK");
Console.Error.WriteLine("soh: Content-Type: " + response.ContentType);
Console.Error.WriteLine("soh: Content-Encoding: " + enc.WebName);
}
String requestedType = arguments.ContainsKey("accept") ? arguments["accept"] : null;
if (requestedType == null || response.ContentType.StartsWith(requestedType, StringComparison.OrdinalIgnoreCase))
{
//If no --accept (OR matches servers content type) then just return whatever the server has given us
using (StreamReader reader = new StreamReader(response.GetResponseStream()))
{
using (StreamWriter writer = new StreamWriter(Console.OpenStandardOutput(), enc))
{
while (!reader.EndOfStream)
{
writer.WriteLine(reader.ReadLine());
}
writer.Close();
}
reader.Close();
}
}
else
{
if (verbose)
{
Console.Error.WriteLine("soh: Warning: Retrieved Content Type '" + response.ContentType + "' does not match your desired Content Type '" + requestedType + "' so dotNetRDF will not attempt to transcode the response into your desired format");
}
//Requested Type Doesn't match servers returned type so parse then serialize
MimeTypeDefinition outputDefinition;
try
{
ISparqlResultsReader sparqlParser = MimeTypesHelper.GetSparqlParser(response.ContentType);
SparqlResultSet results = new SparqlResultSet();
using (StreamReader reader = new StreamReader(response.GetResponseStream()))
{
sparqlParser.Load(results, reader);
reader.Close();
}
outputDefinition = MimeTypesHelper.GetDefinitions(requestedType).FirstOrDefault(d => d.CanWriteSparqlResults || d.CanWriteRdf);
if (outputDefinition == null)
{
throw new RdfWriterSelectionException("No MIME Type Definition for the MIME Type '" + requestedType + "' was found that can write SPARQL Results/RDF");
}
ISparqlResultsWriter writer = outputDefinition.GetSparqlResultsWriter();
Console.OutputEncoding = outputDefinition.Encoding;
writer.Save(results, new StreamWriter(Console.OpenStandardOutput(), outputDefinition.Encoding));
}
catch (RdfParserSelectionException)
{
try
{
IRdfReader rdfParser = MimeTypesHelper.GetParser(response.ContentType);
Graph g = new Graph();
using (StreamReader reader = new StreamReader(response.GetResponseStream()))
{
rdfParser.Load(g, reader);
reader.Close();
}
outputDefinition = MimeTypesHelper.GetDefinitions(requestedType).FirstOrDefault(d => d.CanWriteRdf);
if (outputDefinition == null)
{
throw new RdfWriterSelectionException("No MIME Type Definition for the MIME Type '" + requestedType + "' was found that can write RDF");
}
IRdfWriter writer = outputDefinition.GetRdfWriter();
Console.OutputEncoding = outputDefinition.Encoding;
writer.Save(g, new StreamWriter(Console.OpenStandardOutput(), outputDefinition.Encoding));
}
catch (Exception ex)
{
//For any other exception show a warning
Console.Error.WriteLine("soh: Warning: You wanted results in the format '" + requestedType + "' but the server returned '" + response.ContentType + "' and dotNetRDF was unable to translate the response into your desired format.");
Console.Error.WriteLine(ex.Message);
}
}
catch (Exception ex)
{
//For any other exception show a warning
Console.Error.WriteLine("soh: Warning: You wanted results in the format '" + requestedType + "' but the server returned '" + response.ContentType + "' and dotNetRDF was unable to translate the response into your desired format.");
Console.Error.WriteLine(ex.Message);
}
}
response.Close();
}
if (verbose)
{
Console.Error.WriteLine("soh: Query Completed OK");
}
}
catch (Exception ex)
{
Console.Error.WriteLine("soh: Error: Error while making the SPARQL Query");
Console.Error.WriteLine(ex.Message);
Environment.Exit(-1);
return;
}
}
private void btnOpenQueryResults_Click(object sender, RoutedEventArgs e)
{
try
{
Uri u = new Uri(this.txtEndpoint.Text);
String defGraph = this.txtDefaultGraph.Text;
SparqlRemoteEndpoint endpoint;
if (String.IsNullOrEmpty(defGraph))
{
endpoint = new SparqlRemoteEndpoint(u);
}
else
{
endpoint = new SparqlRemoteEndpoint(u, defGraph);
}
String[] accept = MimeTypesHelper.HttpRdfOrSparqlAcceptHeader.Split(',');
if (!String.IsNullOrEmpty(this.txtAcceptHeader.Text))
{
accept = this.txtAcceptHeader.Text.Split(',');
}
String data;
using (HttpWebResponse response = endpoint.QueryRaw(this._editor.DocumentManager.ActiveDocument.Text, accept))
{
data = new StreamReader(response.GetResponseStream()).ReadToEnd();
try
{
this._parser = MimeTypesHelper.GetSparqlParser(response.ContentType);
}
catch (RdfParserSelectionException)
{
//Ignore here we'll try other means of getting a parser after this
}
response.Close();
}
this._data = data;
if (this._parser == null)
{
try
{
this._parser = StringParser.GetResultSetParser(this._data);
}
catch (RdfParserSelectionException)
{
this._parser = null;
}
}
this.DialogResult = true;
this.Close();
}
catch (UriFormatException)
{
MessageBox.Show("You have failed to enter a valid Endpoint URI", "Invalid URI");
}
catch (WebException webEx)
{
MessageBox.Show("A HTTP error occurred making the Query: " + webEx.Message, "Open Query Results Failed");
}
catch (Exception ex)
{
MessageBox.Show("An error occurred while making the Query: " + ex.Message, "Open Query Results Failed");
}
}
/// <summary>
/// Makes a SPARQL Query against the Joseki store 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>
/// <returns></returns>
public void Query(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler, String sparqlQuery)
{
try
{
HttpWebRequest request;
//Create the Request
Dictionary <String, String> queryParams = new Dictionary <string, string>();
if (sparqlQuery.Length < 2048)
{
queryParams.Add("query", sparqlQuery);
request = this.CreateRequest(this._queryService, MimeTypesHelper.HttpRdfOrSparqlAcceptHeader, "GET", queryParams);
}
else
{
request = this.CreateRequest(this._queryService, MimeTypesHelper.HttpRdfOrSparqlAcceptHeader, "POST", queryParams);
//Build the Post Data and add to the Request Body
request.ContentType = MimeTypesHelper.WWWFormURLEncoded;
StringBuilder postData = new StringBuilder();
postData.Append("query=");
postData.Append(HttpUtility.UrlEncode(sparqlQuery));
StreamWriter writer = new StreamWriter(request.GetRequestStream());
writer.Write(postData);
writer.Close();
}
#if DEBUG
if (Options.HttpDebugging)
{
Tools.HttpDebugRequest(request);
}
#endif
//Get the Response and process based on the Content Type
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
#if DEBUG
if (Options.HttpDebugging)
{
Tools.HttpDebugResponse(response);
}
#endif
StreamReader data = new StreamReader(response.GetResponseStream());
String ctype = response.ContentType;
try
{
//Is the Content Type referring to a Sparql Result Set format?
ISparqlResultsReader resreader = MimeTypesHelper.GetSparqlParser(ctype, true);
resreader.Load(resultsHandler, data);
response.Close();
}
catch (RdfParserSelectionException)
{
//If we get a Parse 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(ctype);
rdfreader.Load(rdfHandler, data);
response.Close();
}
}
}
catch (WebException webEx)
{
#if DEBUG
if (Options.HttpDebugging)
{
if (webEx.Response != null)
{
Tools.HttpDebugResponse((HttpWebResponse)webEx.Response);
}
}
#endif
throw new RdfQueryException("A HTTP error occurred while querying the Store", webEx);
}
}