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