/// <summary>
/// Determines whether the Knowledge Base is consistent
/// </summary>
/// <param name="callback">Callback to invoke when the operation completes</param>
/// <param name="state">State to be passed to the callback</param>
public void IsConsistent(PelletConsistencyCallback callback, Object state)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(this.Endpoint.Uri);
request.Method = this.Endpoint.HttpMethods.First();
request.Accept = MimeTypesHelper.HttpSparqlAcceptHeader;
#if DEBUG
if (Options.HttpDebugging)
{
Tools.HttpDebugRequest(request);
}
#endif
request.BeginGetResponse(result =>
{
using (HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(result))
{
#if DEBUG
if (Options.HttpDebugging)
{
Tools.HttpDebugResponse(response);
}
#endif
ISparqlResultsReader parser = MimeTypesHelper.GetSparqlParser(response.ContentType);
SparqlResultSet results = new SparqlResultSet();
parser.Load(results, new StreamReader(response.GetResponseStream()));
//Expect a boolean result set
callback(results.Result, state);
}
}, null);
}
/// <summary>
/// Makes a Query where the expected Result is a <see cref="SparqlResultSet">SparqlResultSet</see> i.e. SELECT and ASK Queries.
/// </summary>
/// <param name="handler">Results Handler.</param>
/// <param name="sparqlQuery">SPARQL Query String.</param>
public virtual void QueryWithResultSet(ISparqlResultsHandler handler, String sparqlQuery)
{
try
{
// Make the Query
HttpWebResponse httpResponse = QueryInternal(sparqlQuery, ResultsAcceptHeader);
// Parse into a ResultSet based on Content Type
String ctype = httpResponse.ContentType;
if (ctype.Contains(";"))
{
ctype = ctype.Substring(0, ctype.IndexOf(";"));
}
ISparqlResultsReader resultsParser = MimeTypesHelper.GetSparqlParser(ctype);
resultsParser.Load(handler, new StreamReader(httpResponse.GetResponseStream()));
httpResponse.Close();
}
catch (WebException webEx)
{
if (webEx.Response != null)
{
Tools.HttpDebugResponse((HttpWebResponse)webEx.Response);
}
// Some sort of HTTP Error occurred
throw new RdfQueryException("A HTTP Error occurred while trying to make the SPARQL Query, see inner exception for details", webEx);
}
catch (RdfException)
{
// Some problem with the RDF or Parsing thereof
throw;
}
}
/// <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 (!this._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
this._endpoint.QueryWithResultSet(resultsHandler, sparqlQuery);
break;
case SparqlQueryType.Construct:
case SparqlQueryType.Describe:
case SparqlQueryType.DescribeAll:
//Some kind of Graph
this._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 from Talis");
}
}
else
{
//If we're skipping local parsing then we'll need to just make a raw query and process the response
using (HttpWebResponse response = this._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();
}
}
}
}
private void btnOpenQueryResults_Click(object sender, RoutedEventArgs e)
{
try
{
Uri u = new Uri(this.txtEndpoint.Text);
String defGraph = this.txtDefaultGraph.Text;
SparqlRemoteEndpoint endpoint;
if (defGraph.Equals(String.Empty))
{
endpoint = new SparqlRemoteEndpoint(u);
}
else
{
endpoint = new SparqlRemoteEndpoint(u, defGraph);
}
String data;
using (HttpWebResponse response = endpoint.QueryRaw(this._editor.DocumentManager.ActiveDocument.Text))
{
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>
/// Returns whether the Knowledge Base is consistent.
/// </summary>
public bool IsConsistent()
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Endpoint.Uri);
request.Method = Endpoint.HttpMethods.First();
request.Accept = MimeTypesHelper.HttpSparqlAcceptHeader;
Tools.HttpDebugRequest(request);
try
{
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
Tools.HttpDebugResponse(response);
ISparqlResultsReader parser = MimeTypesHelper.GetSparqlParser(response.ContentType);
SparqlResultSet results = new SparqlResultSet();
parser.Load(results, new StreamReader(response.GetResponseStream()));
// Expect a boolean result set
return(results.Result);
}
}
catch (WebException webEx)
{
if (webEx.Response != null)
{
Tools.HttpDebugResponse((HttpWebResponse)webEx.Response);
}
throw new RdfReasoningException("A HTTP error occurred while communicating with the Pellet Server", webEx);
}
}
private void btnOpenQueryResults_Click(object sender, RoutedEventArgs e)
{
try
{
Uri u = new Uri(this.txtEndpoint.Text);
String defGraph = this.txtDefaultGraph.Text;
SparqlRemoteEndpoint endpoint;
if (defGraph.Equals(String.Empty))
{
endpoint = new SparqlRemoteEndpoint(u);
}
else
{
endpoint = new SparqlRemoteEndpoint(u, defGraph);
}
String data;
using (HttpWebResponse response = endpoint.QueryRaw(this._editor.DocumentManager.ActiveDocument.Text))
{
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 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);
}
}
public static void Load(this ISparqlResultsReader reader, ISparqlResultsHandler handler, string filename)
{
using (var input = new StreamReader(filename))
{
reader.Load(handler, input);
}
}
public static void Load(this ISparqlResultsReader reader, SparqlResultSet resultSet, string filename)
{
using (var input = new StreamReader(filename))
{
reader.Load(resultSet, input);
}
}
/// <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>
/// Parses a raw SPARQL Results String using the given Parser
/// </summary>
/// <param name="results">SPARQL Result Set to fill</param>
/// <param name="data">Raw SPARQL Results String</param>
/// <param name="reader">Parser to use</param>
public static void ParseResultSet(SparqlResultSet results, String data, ISparqlResultsReader reader)
{
if (results == null)
{
throw new RdfParseException("Cannot read SPARQL Results into a null Result Set");
}
if (data == null)
{
return;
}
if (reader == null)
{
//If no parser specified then auto-detect syntax
ParseResultSet(results, data);
}
else
{
try
{
MemoryStream mem = new MemoryStream();
StreamWriter writer = new StreamWriter(mem);
writer.Write(data);
writer.Flush();
mem.Seek(0, SeekOrigin.Begin);
reader.Load(results, new StreamReader(mem));
}
catch
{
throw;
}
}
}
/// <summary>
/// Creates a new GZipped results parser.
/// </summary>
/// <param name="parser">Underlying parser.</param>
public BaseGZipResultsParser(ISparqlResultsReader parser)
{
if (parser == null)
{
throw new ArgumentNullException("parser");
}
_parser = parser;
_parser.Warning += RaiseWarning;
}
/// <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="callback">Callback to invoke when the query completes</param>
/// <param name="state">State to pass to the callback</param>
public void QueryWithResultSet(String query, SparqlResultsCallback callback, Object state)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(this.Uri);
request.Method = "POST";
request.ContentType = MimeTypesHelper.WWWFormURLEncoded;
request.Accept = MimeTypesHelper.HttpSparqlAcceptHeader;
#if DEBUG
if (Options.HttpDebugging)
{
Tools.HttpDebugRequest(request);
}
#endif
request.BeginGetRequestStream(result =>
{
Stream stream = request.EndGetRequestStream(result);
using (StreamWriter writer = new StreamWriter(stream))
{
writer.Write("query=");
writer.Write(HttpUtility.UrlEncode(query));
foreach (String u in this.DefaultGraphs)
{
writer.Write("&default-graph-uri=");
writer.Write(Uri.EscapeDataString(u));
}
foreach (String u in this.NamedGraphs)
{
writer.Write("&named-graph-uri=");
writer.Write(Uri.EscapeDataString(u));
}
writer.Close();
}
request.BeginGetResponse(innerResult =>
{
using (HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(innerResult))
{
#if DEBUG
if (Options.HttpDebugging)
{
Tools.HttpDebugResponse(response);
}
#endif
ISparqlResultsReader parser = MimeTypesHelper.GetSparqlParser(response.ContentType, false);
SparqlResultSet rset = new SparqlResultSet();
parser.Load(rset, new StreamReader(response.GetResponseStream()));
response.Close();
callback(rset, state);
}
}, null);
}, null);
}
/// <summary>
/// Requests that the document auto-detect its syntax
/// </summary>
public void AutoDetectSyntax()
{
if (this._filename != null && !this._filename.Equals(String.Empty))
{
try
{
//Try filename based syntax detection
MimeTypeDefinition def = MimeTypesHelper.GetDefinitionsByFileExtension(MimeTypesHelper.GetTrueFileExtension(this._filename)).FirstOrDefault();
if (def != null)
{
this.Syntax = def.SyntaxName.GetSyntaxName();
return;
}
}
catch (RdfParserSelectionException)
{
//Ignore and use string based detection instead
}
}
//Otherwise try and use string based detection
//First take a guess at it being a SPARQL Results format
String text = this.Text;
try
{
ISparqlResultsReader resultsReader = StringParser.GetResultSetParser(text);
this.Syntax = resultsReader.GetSyntaxName();
}
catch (RdfParserSelectionException)
{
//Then see whether it may be a SPARQL query
if (text.Contains("SELECT") || text.Contains("CONSTRUCT") || text.Contains("DESCRIBE") || text.Contains("ASK"))
{
//Likely a SPARQL Query
this.Syntax = "SparqlQuery11";
}
else
{
//Then take a guess at it being a RDF format
try
{
IRdfReader rdfReader = StringParser.GetParser(text);
this.Syntax = rdfReader.GetSyntaxName();
}
catch (RdfParserSelectionException)
{
//Finally take a guess at it being a RDF Dataset format
IStoreReader datasetReader = StringParser.GetDatasetParser(text);
this.Syntax = datasetReader.GetSyntaxName();
}
}
}
}
/// <summary>
/// Determines whether the Knowledge Base is consistent.
/// </summary>
/// <param name="callback">Callback to invoke when the operation completes.</param>
/// <param name="state">State to be passed to the callback.</param>
/// <remarks>
/// If the operation succeeds the callback will be invoked normally, if there is an error the callback will be invoked with a instance of <see cref="AsyncError"/> passed as the state which provides access to the error message and the original state passed in.
/// </remarks>
public void IsConsistent(PelletConsistencyCallback callback, Object state)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Endpoint.Uri);
request.Method = Endpoint.HttpMethods.First();
request.Accept = MimeTypesHelper.HttpSparqlAcceptHeader;
Tools.HttpDebugRequest(request);
try
{
request.BeginGetResponse(result =>
{
try
{
using (HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(result))
{
Tools.HttpDebugResponse(response);
ISparqlResultsReader parser = MimeTypesHelper.GetSparqlParser(response.ContentType);
SparqlResultSet results = new SparqlResultSet();
parser.Load(results, new StreamReader(response.GetResponseStream()));
// Expect a boolean result set
callback(results.Result, state);
}
}
catch (WebException webEx)
{
if (webEx.Response != null)
{
Tools.HttpDebugResponse((HttpWebResponse)webEx.Response);
}
callback(false, new AsyncError(new RdfReasoningException("A HTTP error occurred while communicating with the Pellet Server, see inner exception for details", webEx), state));
}
catch (Exception ex)
{
callback(false, new AsyncError(new RdfReasoningException("An unexpected error occurred while communicating with the Pellet Server, see inner exception for details", ex), state));
}
}, null);
}
catch (WebException webEx)
{
if (webEx.Response != null)
{
Tools.HttpDebugResponse((HttpWebResponse)webEx.Response);
}
callback(false, new AsyncError(new RdfReasoningException("A HTTP error occurred while communicating with the Pellet Server, see inner exception for details", webEx), state));
}
catch (Exception ex)
{
callback(false, new AsyncError(new RdfReasoningException("An unexpected error occurred while communicating with the Pellet Server, see inner exception for details", ex), state));
}
}
public void ParsingGZipResultsByFilenameAuto2()
{
foreach (String filename in this._autoResultsTestFiles)
{
SparqlResultSet results = new SparqlResultSet();
ISparqlResultsReader reader = MimeTypesHelper.GetSparqlParserByFileExtension(MimeTypesHelper.GetTrueFileExtension(filename));
reader.Load(results, filename);
Assert.IsTrue(this._results.Equals(results), "Result Sets for file " + filename + " were not equal");
}
}
/// <summary>
/// Sets the Syntax Highlighter based on a Parser
/// </summary>
/// <param name="parser">SPARQL Results Parser</param>
public void SetHighlighter(ISparqlResultsReader parser)
{
if (parser is SparqlXmlParser)
{
this.SetHighlighter("SparqlResultsXml");
}
else if (parser is SparqlJsonParser)
{
this.SetHighlighter("SparqlResultsJson");
}
else
{
this.SetNoHighlighting();
}
}
/// <summary>
/// Convert SPARQL results parser into internal syntax name
/// </summary>
/// <param name="parser">SPARQL Results Parser</param>
/// <returns>Internal Syntax Name</returns>
public static String GetSyntaxName(this ISparqlResultsReader parser)
{
if (parser is SparqlJsonParser)
{
return("SparqlResultsJson");
}
else if (parser is SparqlXmlParser)
{
return("SparqlResultsXml");
}
else
{
return(parser.ToString());
}
}
/// <summary>
/// Makes a Query where the expected Result is a <see cref="SparqlResultSet">SparqlResultSet</see> i.e. SELECT and ASK Queries
/// </summary>
/// <param name="handler">Results Handler</param>
/// <param name="sparqlQuery">SPARQL Query String</param>
public virtual void QueryWithResultSet(ISparqlResultsHandler handler, String sparqlQuery)
{
try
{
//Make the Query
HttpWebResponse httpResponse = this.QueryInternal(sparqlQuery, MimeTypesHelper.HttpSparqlAcceptHeader);
//Parse into a ResultSet based on Content Type
String ctype = httpResponse.ContentType;
if (ctype.Contains(";"))
{
ctype = ctype.Substring(0, ctype.IndexOf(";"));
}
if (MimeTypesHelper.SparqlResults.Contains(ctype))
{
ISparqlResultsReader resultsParser = MimeTypesHelper.GetSparqlParser(ctype);
resultsParser.Load(handler, new StreamReader(httpResponse.GetResponseStream()));
httpResponse.Close();
}
else
{
httpResponse.Close();
throw new RdfParseException("The SPARQL Endpoint returned unexpected Content Type '" + ctype + "', this error may be due to the given URI not returning a SPARQL Result Set");
}
}
catch (WebException webEx)
{
#if DEBUG
if (Options.HttpDebugging)
{
if (webEx.Response != null)
{
Tools.HttpDebugResponse((HttpWebResponse)webEx.Response);
}
}
#endif
//Some sort of HTTP Error occurred
throw new RdfQueryException("A HTTP Error occurred while trying to make the SPARQL Query, see inner exception for details", webEx);
}
catch (RdfException)
{
//Some problem with the RDF or Parsing thereof
throw;
}
}
public void ParsingGZipResultsByStreamManual()
{
foreach (String filename in this._manualResultsTestFiles)
{
SparqlResultSet results = new SparqlResultSet();
String ext = MimeTypesHelper.GetTrueFileExtension(filename);
ext = ext.Substring(1);
MimeTypeDefinition def = MimeTypesHelper.Definitions.Where(d => d.CanParseSparqlResults && d.SupportsFileExtension(ext)).FirstOrDefault();
Assert.NotNull(def);
ISparqlResultsReader reader = def.GetSparqlResultsParser();
reader.Load(results, File.OpenText(filename));
Assert.True(this._results.Equals(results), "Result Sets for file " + filename + " were not equal");
}
}
public void ParsingGZipResultsByGZipStreamAuto()
{
foreach (String filename in this._autoResultsTestFiles)
{
SparqlResultSet results = new SparqlResultSet();
String ext = MimeTypesHelper.GetTrueFileExtension(filename);
ext = ext.Substring(1);
MimeTypeDefinition def = MimeTypesHelper.Definitions.Where(d => d.CanParseSparqlResults && d.SupportsFileExtension(ext)).FirstOrDefault();
Assert.NotNull(def);
ISparqlResultsReader reader = def.GetSparqlResultsParser();
reader.Load(results, new StreamReader(new GZipStream(new FileStream(filename, FileMode.Open, FileAccess.Read), CompressionMode.Decompress)));
Assert.True(this._results.Equals(results), "Result Sets for file " + filename + " were not equal");
}
}
/// <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(this.Uri);
request.Method = "POST";
request.ContentType = MimeTypesHelper.WWWFormURLEncoded;
request.Accept = this.RdfAcceptHeader;
Tools.HttpDebugRequest(request);
request.BeginGetRequestStream(result =>
{
Stream stream = request.EndGetRequestStream(result);
using (StreamWriter writer = new StreamWriter(stream))
{
writer.Write("query=");
writer.Write(HttpUtility.UrlEncode(query));
foreach (String u in this.DefaultGraphs)
{
writer.Write("&default-graph-uri=");
writer.Write(HttpUtility.UrlEncode(u));
}
foreach (String u in this.NamedGraphs)
{
writer.Write("&named-graph-uri=");
writer.Write(HttpUtility.UrlEncode(u));
}
writer.Close();
}
request.BeginGetResponse(innerResult =>
{
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);
}
}, null);
}, null);
}
public BaseResultsParserSuite(ISparqlResultsReader testParser, ISparqlResultsReader resultsParser, String baseDir)
{
if (testParser == null)
{
throw new ArgumentNullException("testParser");
}
if (resultsParser == null)
{
throw new ArgumentNullException("resultsParser");
}
if (baseDir == null)
{
throw new ArgumentNullException("baseDir");
}
this._parser = testParser;
this._resultsParser = resultsParser;
this._baseDir = baseDir;
}
/// <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 void ParsingGZipResultsByStreamAuto()
{
foreach (String filename in this._autoResultsTestFiles)
{
SparqlResultSet results = new SparqlResultSet();
String ext = MimeTypesHelper.GetTrueFileExtension(filename);
ext = ext.Substring(1);
MimeTypeDefinition def = MimeTypesHelper.Definitions.Where(d => d.CanParseSparqlResults && d.SupportsFileExtension(ext)).FirstOrDefault();
if (def == null)
{
Assert.Fail("Failed to find MIME Type Definition for File Extension ." + ext);
}
ISparqlResultsReader reader = def.GetSparqlResultsParser();
reader.Load(results, new StreamReader(filename));
Assert.IsTrue(this._results.Equals(results), "Result Sets for file " + filename + " were not equal");
}
}
public void ParsingGZipResultsByGZipStreamManual()
{
foreach (String filename in this._manualResultsTestFiles)
{
SparqlResultSet results = new SparqlResultSet();
String ext = MimeTypesHelper.GetTrueFileExtension(filename);
ext = ext.Substring(1);
MimeTypeDefinition def = MimeTypesHelper.Definitions.Where(d => d.CanParseSparqlResults && d.SupportsFileExtension(ext)).FirstOrDefault();
if (def == null)
{
Assert.Fail("Failed to find MIME Type Definition for File Extension ." + ext);
}
ISparqlResultsReader reader = def.GetSparqlResultsParser();
reader.Load(results, new StreamReader(new GZipStream(new FileStream(filename, FileMode.Open, FileAccess.Read), CompressionMode.Decompress)));
Assert.AreEqual(this._results, results, "Result Sets for file " + filename + " were not equal");
}
}
public void WritingFormattingResultSets()
{
Graph g = new Graph();
g.LoadFromEmbeddedResource("VDS.RDF.Configuration.configuration.ttl");
SparqlResultSet expected = g.ExecuteQuery("SELECT * WHERE { ?s a ?type }") as SparqlResultSet;
List <IResultSetFormatter> formatters = new List <IResultSetFormatter>()
{
new SparqlXmlFormatter()
};
List <ISparqlResultsReader> parsers = new List <ISparqlResultsReader>()
{
new SparqlXmlParser()
};
Console.WriteLine("Using Formatter " + formatters.GetType().ToString());
for (int i = 0; i < formatters.Count; i++)
{
IResultSetFormatter formatter = formatters[i];
StringBuilder output = new StringBuilder();
output.AppendLine(formatter.FormatResultSetHeader(expected.Variables));
foreach (SparqlResult r in expected)
{
output.AppendLine(formatter.Format(r));
}
output.AppendLine(formatter.FormatResultSetFooter());
Console.WriteLine(output.ToString());
//Try parsing to check it round trips
SparqlResultSet actual = new SparqlResultSet();
ISparqlResultsReader parser = parsers[i];
parser.Load(actual, new StringReader(output.ToString()));
Assert.AreEqual(expected, actual, "Result Sets should be equal after round tripping");
}
Console.WriteLine();
}
/// <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)
{
HttpWebResponse response = this._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();
}
}
/// <summary>
/// Lists the Graphs from the Repository
/// </summary>
/// <returns></returns>
public IEnumerable <Uri> ListGraphs()
{
try
{
//Use the /contexts method to get the Graph URIs
//HACK: Have to use SPARQL JSON as currently Dydra's SPARQL XML Results are malformed
HttpWebRequest request = this.CreateRequest("/contexts", MimeTypesHelper.CustomHttpAcceptHeader(MimeTypesHelper.SparqlJson), "GET", new Dictionary <string, string>());
SparqlResultSet results = new SparqlResultSet();
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
ISparqlResultsReader parser = MimeTypesHelper.GetSparqlParser(response.ContentType);
parser.Load(results, new StreamReader(response.GetResponseStream()));
response.Close();
}
List <Uri> graphUris = new List <Uri>();
foreach (SparqlResult r in results)
{
if (r.HasValue("contextID"))
{
INode value = r["contextID"];
if (value.NodeType == NodeType.Uri)
{
graphUris.Add(((IUriNode)value).Uri);
}
else if (value.NodeType == NodeType.Blank)
{
//Dydra allows BNode Graph URIs
graphUris.Add(new Uri("dydra:bnode:" + ((IBlankNode)value).InternalID));
}
}
}
return(graphUris);
}
catch (Exception ex)
{
throw new RdfStorageException("An error occurred while attempting to retrieve the Graph List from the Store, see inner exception for details", ex);
}
}
/// <summary>
/// Lists the Graphs from the Repository
/// </summary>
/// <param name="callback">Callback</param>
/// <param name="state">State to pass to the callback</param>
/// <returns></returns>
public override void ListGraphs(AsyncStorageCallback callback, Object state)
{
try
{
//Use the /contexts method to get the Graph URIs
//HACK: Have to use SPARQL JSON as currently Dydra's SPARQL XML Results are malformed
HttpWebRequest request = this.CreateRequest("/contexts", MimeTypesHelper.CustomHttpAcceptHeader(MimeTypesHelper.SparqlResultsJson), "GET", new Dictionary <string, string>());
request.BeginGetResponse(r =>
{
try
{
HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(r);
ISparqlResultsReader parser = MimeTypesHelper.GetSparqlParser(response.ContentType);
ListUrisHandler handler = new ListUrisHandler("contextID");
parser.Load(handler, new StreamReader(response.GetResponseStream()));
response.Close();
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.ListGraphs, handler.Uris), state);
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.ListGraphs, StorageHelper.HandleHttpError(webEx, "list Graphs asynchronously from")), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.ListGraphs, StorageHelper.HandleError(ex, "list Graphs asynchronously from")), state);
}
}, state);
}
catch (WebException webEx)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.ListGraphs, StorageHelper.HandleHttpError(webEx, "list Graphs asynchronously from")), state);
}
catch (Exception ex)
{
callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.ListGraphs, StorageHelper.HandleError(ex, "list Graphs asynchronously from")), state);
}
}
public static async Task <SparqlResultSet> SelectQuery(this string endpointUri, string sparqlQuery)
{
WriteLine($"Querying : {endpointUri} whith \"{sparqlQuery}\"");
SparqlResultSet results = new SparqlResultSet();
using (var client = new System.Net.Http.HttpClient())
{
try
{
client.Timeout = new TimeSpan(23, 23, 59, 59, 59);
var httpQuery = Tools.UrlEncode(sparqlQuery);
var response = await client.GetAsync(endpointUri + "?query=" + httpQuery);
response.EnsureSuccessStatusCode();
ISparqlResultsHandler handler = new VDS.RDF.Parsing.Handlers.ResultSetHandler(results);
String ctype = response.Content.Headers.ContentType.ToString();
if (ctype.Contains(";"))
{
ctype = ctype.Substring(0, ctype.IndexOf(";"));
}
ISparqlResultsReader resultsParser = MimeTypesHelper.GetSparqlParser(ctype);
resultsParser.Load(handler, new System.IO.StreamReader(response.Content.ReadAsStreamAsync().Result));
}
catch (System.Net.Http.HttpRequestException e)
{
Console.WriteLine("\nException Caught !");
WriteLine($"endpoint : {endpointUri}");
WriteLine($"sparqlQuery : {sparqlQuery}");
Console.WriteLine("Message :{0} ", e.Message);
}
return(results);
}
}
/// <summary>
/// Sets the Syntax Highlighter based on a Parser
/// </summary>
/// <param name="parser">SPARQL Results Parser</param>
public void SetHighlighter(ISparqlResultsReader parser)
{
if (parser is SparqlXmlParser)
{
this.SetHighlighter("SparqlResultsXml");
}
else if (parser is SparqlJsonParser)
{
this.SetHighlighter("SparqlResultsJson");
}
else
{
this.SetNoHighlighting();
}
}
/// <summary>
/// Creates a new SPARQL Results Format validator that uses the given parser
/// </summary>
/// <param name="parser">SPARQL Results Parser</param>
public SparqlResultsValidator(ISparqlResultsReader parser)
{
this._parser = parser;
}
/// <summary>
/// Creates a new GZipped results parser
/// </summary>
/// <param name="parser">Underlying parser</param>
public BaseGZipResultsParser(ISparqlResultsReader parser)
{
if (parser == null) throw new ArgumentNullException("parser");
this._parser = parser;
this._parser.Warning += this.RaiseWarning;
}
/// <summary>
/// Parses a raw SPARQL Results String using the given Parser
/// </summary>
/// <param name="results">SPARQL Result Set to fill</param>
/// <param name="data">Raw SPARQL Results String</param>
/// <param name="reader">Parser to use</param>
public static void ParseResultSet(SparqlResultSet results, String data, ISparqlResultsReader reader)
{
if (results == null) throw new RdfParseException("Cannot read SPARQL Results into a null Result Set");
if (data == null) return;
if (reader == null)
{
//If no parser specified then auto-detect syntax
ParseResultSet(results, data);
}
else
{
try
{
MemoryStream mem = new MemoryStream();
StreamWriter writer = new StreamWriter(mem);
writer.Write(data);
writer.Flush();
mem.Seek(0, SeekOrigin.Begin);
reader.Load(results, new StreamReader(mem));
}
catch
{
throw;
}
}
}
private void CompareSparqlResults(string results, string expectedResultsPath, bool reduced, ISparqlResultsReader resultsReader = null)
{
if (resultsReader == null)
{
resultsReader = new SparqlXmlParser();
}
var actualResultSet = new SparqlResultSet();
using (var tr = new StringReader(results))
{
resultsReader.Load(actualResultSet, tr);
}
var expectedResultSet = new SparqlResultSet();
resultsReader.Load(expectedResultSet, expectedResultsPath);
var bnodeMap = new Dictionary<string, string>();
CompareSparqlResults(actualResultSet, expectedResultSet, reduced, bnodeMap);
}
/// <summary>
/// Registers a parser as the default SPARQL Rsults Parser for all the given MIME types and updates relevant definitions to include the MIME types and file extensions
/// </summary>
/// <param name="parser">SPARQL Results Parser</param>
/// <param name="mimeTypes">MIME Types</param>
/// <param name="fileExtensions">File Extensions</param>
public static void RegisterParser(ISparqlResultsReader parser, IEnumerable<String> mimeTypes, IEnumerable<String> fileExtensions)
{
if (!_init) Init();
if (!mimeTypes.Any()) throw new RdfException("Cannot register a parser without specifying at least 1 MIME Type");
//Get any existing defintions that are to be altered
IEnumerable<MimeTypeDefinition> existing = GetDefinitions(mimeTypes);
foreach (MimeTypeDefinition def in existing)
{
foreach (String type in mimeTypes)
{
def.AddMimeType(type);
}
foreach (String ext in fileExtensions)
{
def.AddFileExtension(ext);
}
def.SparqlResultsParserType = parser.GetType();
}
//Create any new defintions
IEnumerable<String> newTypes = mimeTypes.Where(t => !GetDefinitions(t).Any());
if (newTypes.Any())
{
MimeTypeDefinition newDef = new MimeTypeDefinition(String.Empty, newTypes, fileExtensions);
newDef.SparqlResultsParserType = parser.GetType();
AddDefinition(newDef);
}
}
