/// <inheritdoc /> public void Load(IRdfHandler handler, TextReader input) { bool finished = false; try { handler.StartRdf(); using (JsonReader jsonReader = new JsonTextReader(input)) { jsonReader.DateParseHandling = DateParseHandling.None; JToken json = JsonLD.Core.JsonLdProcessor.Expand(JToken.Load(jsonReader)); foreach (JObject subjectJObject in json) { string subject = subjectJObject["@id"].ToString(); JToken type; if (subjectJObject.TryGetValue("@type", out type)) { HandleType(handler, subject, type); } foreach (var property in subjectJObject.Properties().Where(property => (property.Name != "@id") && (property.Name != "@type"))) { HandleProperty(handler, subject, property); } } } finished = true; handler.EndRdf(true); } catch { finished = true; handler.EndRdf(false); throw; } finally { if (!finished) { handler.EndRdf(true); } } }
private void TryParseGraphset(XmlReader reader, IRdfHandler handler) { try { handler.StartRdf(); reader.Read(); //Skip XML Declaration if present if (reader.NodeType == XmlNodeType.XmlDeclaration) reader.Read(); if (!reader.Name.Equals("TriX")) { throw new RdfParseException("Unexpected Document Element '" + reader.Name + "' encountered, expected the Document Element of a TriX Document to be the <TriX> element"); } if (!reader.HasAttributes) { throw new RdfParseException("<TriX> fails to define any attributes, the element must define the xmlns attribute to be the TriX namespace"); } else { bool trixNSDefined = false; for (int i = 0; i < reader.AttributeCount; i++) { reader.MoveToNextAttribute(); if (reader.Name.Equals("xmlns")) { //Ensure that the xmlns attribute is defined and is the TriX namespace if (trixNSDefined) throw new RdfParseException("The xmlns attribute can only occur once on the <TriX> element"); if (!reader.Value.Equals(TriXNamespaceURI)) throw new RdfParseException("The xmlns attribute of the <TriX> element must have it's value set to the TriX Namespace URI which is '" + TriXNamespaceURI + "'"); trixNSDefined = true; } else if (reader.LocalName.Equals("xmlns")) { //Don't think we need to do anything here } } if (!trixNSDefined) throw new RdfParseException("The <TriX> element fails to define the required xmlns attribute defining the TriX Namespace"); } //Process Child Nodes while (reader.Read()) { if (reader.NodeType == XmlNodeType.Element) { //For elements we recurse to try and parse a Graph this.TryParseGraph(reader, handler); } else if (reader.NodeType == XmlNodeType.EndElement) { //Stop when we hit an end element break; } else { //Stop if we hit an unexpected element break; } } //Expect the </TriX> element if (reader.NodeType == XmlNodeType.EndElement) { if (!reader.Name.Equals("TriX")) throw new RdfParseException("Expected </TriX> element was not found, encountered </" + reader.Name + "> instead"); } else { throw new RdfParseException("Unexpected Note Type " + reader.NodeType.ToString() + " encountered, expected a </TriX> element"); } handler.EndRdf(true); } catch (RdfParsingTerminatedException) { handler.EndRdf(true); //Discard this - it justs means the Handler told us to stop } catch { handler.EndRdf(false); throw; } }
private void TryParseGraphset(XmlDocument doc, IRdfHandler handler) { try { handler.StartRdf(); XmlElement graphsetEl = doc.DocumentElement; if (!graphsetEl.Name.Equals("TriX")) { throw new RdfParseException("Unexpected Document Element '" + graphsetEl.Name + "' encountered, expected the Document Element of a TriX Document to be the <TriX> element"); } if (!graphsetEl.HasAttributes) { throw new RdfParseException("<TriX> fails to define any attributes, the element must define the xmlns attribute to be the TriX namespace"); } else { bool trixNSDefined = false; foreach (XmlAttribute attr in graphsetEl.Attributes) { if (attr.Name.Equals("xmlns")) { //Ensure that the xmlns attribute is defined and is the TriX namespace if (trixNSDefined) throw new RdfParseException("The xmlns attribute can only occur once on the <TriX> element"); if (!attr.Value.Equals(TriXNamespaceURI)) throw new RdfParseException("The xmlns attribute of the <TriX> element must have it's value set to the TriX Namespace URI which is '" + TriXNamespaceURI + "'"); trixNSDefined = true; } else if (attr.LocalName.Equals("xmlns")) { //Don't think we need to do anything here } } if (!trixNSDefined) throw new RdfParseException("The <TriX> element fails to define the required xmlns attribute defining the TriX Namespace"); } //Process Child Nodes foreach (XmlNode graph in graphsetEl.ChildNodes) { //Ignore non-Element nodes if (graph.NodeType == XmlNodeType.Element) { //OPT: Do this multi-threaded? this.TryParseGraph(graph, handler); } } handler.EndRdf(true); } catch (RdfParsingTerminatedException) { handler.EndRdf(true); //Discard this - it justs means the Handler told us to stop } catch { handler.EndRdf(false); throw; } }
/// <summary> /// Loads a Graph from the Store asynchronously /// </summary> /// <param name="handler">Handler to load with</param> /// <param name="graphUri">URI of the Graph to load</param> /// <param name="callback">Callback</param> /// <param name="state">State to pass to the callback</param> public override void LoadGraph(IRdfHandler handler, string graphUri, AsyncStorageCallback callback, object state) { try { HttpWebRequest request; Dictionary<String, String> serviceParams = new Dictionary<string, string>(); Uri baseUri = null; SparqlParameterizedString construct = new SparqlParameterizedString(); if (!graphUri.Equals(string.Empty)) { construct.CommandText = "CONSTRUCT { ?s ?p ?o } WHERE { GRAPH @graph { ?s ?p ?o } }"; baseUri = UriFactory.Create(graphUri); construct.SetUri("graph", baseUri); } else { construct.CommandText = "CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o }"; } serviceParams.Add("query", construct.ToString()); request = this.CreateRequest("/sparql", MimeTypesHelper.HttpAcceptHeader, "GET", serviceParams); Tools.HttpDebugRequest(request); request.BeginGetResponse(r => { try { using (HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(r)) { Tools.HttpDebugResponse(response); IRdfReader parser = MimeTypesHelper.GetParser(response.ContentType); parser.Load(handler, new StreamReader(response.GetResponseStream())); if (baseUri != null) { handler.StartRdf(); handler.HandleBaseUri(baseUri); handler.EndRdf(true); } response.Close(); } callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.LoadWithHandler, handler), state); } catch (WebException webEx) { callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.LoadWithHandler, StorageHelper.HandleHttpError(webEx, "loading a Graph from")), state); } catch (Exception ex) { callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.LoadWithHandler, StorageHelper.HandleError(ex, "loading a Graph from")), state); } }, state); } catch (WebException webEx) { callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.LoadWithHandler, StorageHelper.HandleHttpError(webEx, "loading a Graph from")), state); } catch (Exception ex) { callback(this, new AsyncStorageCallbackArgs(AsyncStorageOperation.LoadWithHandler, StorageHelper.HandleError(ex, "loading a Graph from")), state); } }
/// <summary> /// Gets the Description Graph based on the Query Results from the given Evaluation Context passing the resulting Triples to the given RDF Handler /// </summary> /// <param name="handler">RDF Handler</param> /// <param name="context">SPARQL Evaluation Context</param> public void Describe(IRdfHandler handler, SparqlEvaluationContext context) { try { handler.StartRdf(); //Apply Base URI and Namespaces to the Handler if (context.Query != null) { if (context.Query.BaseUri != null) { if (!handler.HandleBaseUri(context.Query.BaseUri)) ParserHelper.Stop(); } foreach (String prefix in context.Query.NamespaceMap.Prefixes) { if (!handler.HandleNamespace(prefix, context.Query.NamespaceMap.GetNamespaceUri(prefix))) ParserHelper.Stop(); } } //Get the Nodes needing describing List<INode> nodes = this.GetNodes(handler, context); if (nodes.Count > 0) { //If there is at least 1 Node then start describing this.DescribeInternal(handler, context, nodes); } handler.EndRdf(true); } catch (RdfParsingTerminatedException) { handler.EndRdf(true); } catch { handler.EndRdf(false); throw; } }
/// <summary> /// Makes a Query where the expected result is a Graph i.e. a CONSTRUCT or DESCRIBE query /// </summary> /// <param name="handler">RDF Handler to process the results</param> /// <param name="sparqlQuery">SPARQL Query</param> public override void QueryWithResultGraph(IRdfHandler handler, string sparqlQuery) { //If no endpoints do nothing if (this._endpoints.Count == 0) return; //Fire off all the Asychronous Requests List<AsyncQueryWithResultGraph> asyncCalls = new List<AsyncQueryWithResultGraph>(); List<IAsyncResult> asyncResults = new List<IAsyncResult>(); int count = 0; foreach (SparqlRemoteEndpoint endpoint in this._endpoints) { //Limit the number of simultaneous requests we make to the user defined level (default 4) //We do this limiting check before trying to issue a request so that when the last request //is issued we'll always drop out of the loop and move onto our WaitAll() while (count >= this._maxSimultaneousRequests) { //First check that the count of active requests is accurate int active = asyncResults.Count(r => !r.IsCompleted); if (active < count) { //Some of the requests have already completed so we don't need to wait count = active; break; } else if (active > count) { //There are more active requests then we thought count = active; } //While the number of requests is at/above the maximum we'll wait for any of the requests to finish //Then we can decrement the count and if this drops back below our maximum then we'll go back into the //main loop and fire off our next request WaitHandle.WaitAny(asyncResults.Select(r => r.AsyncWaitHandle).ToArray()); count--; } //Make an asynchronous query to the next endpoint AsyncQueryWithResultGraph d = new AsyncQueryWithResultGraph(endpoint.QueryWithResultGraph); asyncCalls.Add(d); IAsyncResult asyncResult = d.BeginInvoke(sparqlQuery, null, null); asyncResults.Add(asyncResult); count++; } //Wait for all our requests to finish int waitTimeout = (base.Timeout > 0) ? base.Timeout : System.Threading.Timeout.Infinite; WaitHandle.WaitAll(asyncResults.Select(r => r.AsyncWaitHandle).ToArray(), waitTimeout); //Check for and handle timeouts if (!this._ignoreFailedRequests && !asyncResults.All(r => r.IsCompleted)) { for (int i = 0; i < asyncCalls.Count; i++) { try { asyncCalls[i].EndInvoke(asyncResults[i]); } catch { //Exceptions don't matter as we're just ensuring all the EndInvoke() calls are made } } throw new RdfQueryTimeoutException("Federated Querying failed due to one/more endpoints failing to return results within the Timeout specified which is currently " + (base.Timeout / 1000) + " seconds"); } //Now merge all the results together HashSet<String> varsSeen = new HashSet<string>(); bool cont = true; for (int i = 0; i < asyncCalls.Count; i++) { //Retrieve the result for this call AsyncQueryWithResultGraph call = asyncCalls[i]; IGraph g; try { g = call.EndInvoke(asyncResults[i]); } catch (Exception ex) { if (!this._ignoreFailedRequests) { //Clean up in the event of an error for (int j = i + 1; j < asyncCalls.Count; j++) { try { asyncCalls[j].EndInvoke(asyncResults[j]); } catch { //Exceptions don't matter as we're just ensuring all the EndInvoke() calls are made } } //If a single request fails then the entire query fails throw new RdfQueryException("Federated Querying failed due to the query against the endpoint '" + this._endpoints[i] + "' failing", ex); } else { //If we're ignoring failed requests we continue here continue; } } //Merge the result into the final results //If the handler has previously told us to stop we skip this step if (cont) { handler.StartRdf(); foreach (Triple t in g.Triples) { cont = handler.HandleTriple(t); //Stop if the Handler tells us to if (!cont) break; } handler.EndRdf(true); } } }
/// <summary> /// Loads a Graph from the Quad Store /// </summary> /// <param name="handler">RDF Handler</param> /// <param name="graphUri">URI of the Graph to Load</param> public void LoadGraph(IRdfHandler handler, Uri graphUri) { if (graphUri == null) throw new RdfStorageException("Cannot load an unnamed Graph from Virtuoso as this would require loading the entirety of the Virtuoso Quad Store into memory!"); try { handler.StartRdf(); //Need to keep Database Open as Literals require extra trips to the Database to get additional //information about Language and Type this.Open(false); DataTable data = this.LoadTriples(graphUri); foreach (DataRow row in data.Rows) { Object s, p, o; INode subj, pred, obj; //Get Data s = row["S"]; p = row["P"]; o = row["O"]; //Create Nodes subj = this.LoadNode(handler, s); pred = this.LoadNode(handler, p); obj = this.LoadNode(handler, o); //Assert Triple if (!handler.HandleTriple(new Triple(subj, pred, obj))) ParserHelper.Stop(); } handler.EndRdf(true); this.Close(false); } catch (RdfParsingTerminatedException) { handler.EndRdf(true); this.Close(false); } catch { handler.EndRdf(false); this.Close(true); throw; } }
/// <summary> /// Processes a SPARQL Query sending the results to a RDF/SPARQL Results handler as appropriate /// </summary> /// <param name="rdfHandler">RDF Handler</param> /// <param name="resultsHandler">Results Handler</param> /// <param name="query">SPARQL Query</param> public void ProcessQuery(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler, SparqlQuery query) { //Do Handler null checks before evaluating the query if (query == null) { throw new ArgumentNullException("query", "Cannot evaluate a null query"); } if (rdfHandler == null && (query.QueryType == SparqlQueryType.Construct || query.QueryType == SparqlQueryType.Describe || query.QueryType == SparqlQueryType.DescribeAll)) { throw new ArgumentNullException("rdfHandler", "Cannot use a null RDF Handler when the Query is a CONSTRUCT/DESCRIBE"); } if (resultsHandler == null && (query.QueryType == SparqlQueryType.Ask || SparqlSpecsHelper.IsSelectQuery(query.QueryType))) { throw new ArgumentNullException("resultsHandler", "Cannot use a null resultsHandler when the Query is an ASK/SELECT"); } //Handle the Thread Safety of the Query Evaluation #if !NO_RWLOCK ReaderWriterLockSlim currLock = (this._dataset is IThreadSafeDataset) ? ((IThreadSafeDataset)this._dataset).Lock : this._lock; try { currLock.EnterReadLock(); #endif //Reset Query Timers query.QueryExecutionTime = null; bool datasetOk = false, defGraphOk = false; try { //Set up the Default and Active Graphs if (query.DefaultGraphs.Any()) { //Call HasGraph() on each Default Graph but ignore the results, we just do this //in case a dataset has any kind of load on demand behaviour foreach (Uri defGraphUri in query.DefaultGraphs) { this._dataset.HasGraph(defGraphUri); } this._dataset.SetDefaultGraph(query.DefaultGraphs); defGraphOk = true; } else if (query.NamedGraphs.Any()) { //No FROM Clauses but one/more FROM NAMED means the Default Graph is the empty graph this._dataset.SetDefaultGraph(Enumerable.Empty <Uri>()); } this._dataset.SetActiveGraph(this._dataset.DefaultGraphUris); datasetOk = true; //Convert to Algebra and execute the Query SparqlEvaluationContext context = this.GetContext(query); BaseMultiset result; try { context.StartExecution(); ISparqlAlgebra algebra = query.ToAlgebra(); result = context.Evaluate(algebra); context.EndExecution(); query.QueryExecutionTime = new TimeSpan(context.QueryTimeTicks); } catch (RdfQueryException) { context.EndExecution(); query.QueryExecutionTime = new TimeSpan(context.QueryTimeTicks); throw; } catch { context.EndExecution(); query.QueryExecutionTime = new TimeSpan(context.QueryTimeTicks); throw; } //Return the Results switch (query.QueryType) { case SparqlQueryType.Ask: case SparqlQueryType.Select: case SparqlQueryType.SelectAll: case SparqlQueryType.SelectAllDistinct: case SparqlQueryType.SelectAllReduced: case SparqlQueryType.SelectDistinct: case SparqlQueryType.SelectReduced: //For SELECT and ASK can populate a Result Set directly from the Evaluation Context //return new SparqlResultSet(context); resultsHandler.Apply(context); break; case SparqlQueryType.Construct: //Create a new Empty Graph for the Results try { rdfHandler.StartRdf(); foreach (String prefix in query.NamespaceMap.Prefixes) { if (!rdfHandler.HandleNamespace(prefix, query.NamespaceMap.GetNamespaceUri(prefix))) { ParserHelper.Stop(); } } //Construct the Triples for each Solution foreach (ISet s in context.OutputMultiset.Sets) { //List<Triple> constructedTriples = new List<Triple>(); try { ConstructContext constructContext = new ConstructContext(rdfHandler, s, false); foreach (IConstructTriplePattern p in query.ConstructTemplate.TriplePatterns.OfType <IConstructTriplePattern>()) { try { if (!rdfHandler.HandleTriple(p.Construct(constructContext))) { ParserHelper.Stop(); } //constructedTriples.Add(((IConstructTriplePattern)p).Construct(constructContext)); } catch (RdfQueryException) { //If we get an error here then we could not construct a specific triple //so we continue anyway } } } catch (RdfQueryException) { //If we get an error here this means we couldn't construct for this solution so the //entire solution is discarded continue; } //h.Assert(constructedTriples); } rdfHandler.EndRdf(true); } catch (RdfParsingTerminatedException) { rdfHandler.EndRdf(true); } catch { rdfHandler.EndRdf(false); throw; } break; case SparqlQueryType.Describe: case SparqlQueryType.DescribeAll: //For DESCRIBE we retrieve the Describe algorithm and apply it ISparqlDescribe describer = query.Describer; describer.Describe(rdfHandler, context); break; default: throw new RdfQueryException("Unknown query types cannot be processed by Leviathan"); } } finally { if (defGraphOk) { this._dataset.ResetDefaultGraph(); } if (datasetOk) { this._dataset.ResetActiveGraph(); } } #if !NO_RWLOCK } finally { currLock.ExitReadLock(); } #endif }
/// <inheritdoc/> public void Load(IRdfHandler handler, TextReader input) { handler.StartRdf(); var rdfTypeNode = handler.CreateUriNode(new Uri(RdfNs + "type")); try { JToken element; using (var reader = new JsonTextReader(input) { DateParseHandling = DateParseHandling.None }) { element = JToken.ReadFrom(reader); } var expandedElement = JsonLdProcessor.Expand(element, ParserOptions); var nodeMap = JsonLdProcessor.GenerateNodeMap(expandedElement); foreach (var p in nodeMap.Properties()) { var graphName = p.Name; var graph = p.Value as JObject; if (graph == null) { continue; } Uri graphIri; if (graphName == "@default") { graphIri = null; } else { if (!Uri.TryCreate(graphName, UriKind.Absolute, out graphIri)) { continue; } } foreach (var gp in graph.Properties()) { var subject = gp.Name; var node = gp.Value as JObject; INode subjectNode; if (IsBlankNodeIdentifier(subject)) { subjectNode = handler.CreateBlankNode(subject.Substring(2)); } else { Uri subjectIri; if (!Uri.TryCreate(subject, UriKind.Absolute, out subjectIri)) { continue; } subjectNode = handler.CreateUriNode(subjectIri); } foreach (var np in node.Properties()) { var property = np.Name; var values = np.Value as JArray; if (property.Equals("@type")) { foreach (var type in values) { var typeNode = MakeNode(handler, type); handler.HandleTriple(new Triple(subjectNode, rdfTypeNode, typeNode, graphIri)); } } else if (JsonLdProcessor.IsKeyword(property)) { continue; } else if (JsonLdProcessor.IsBlankNodeIdentifier(property) && !ParserOptions.ProduceGeneralizedRdf) { continue; } else if (JsonLdProcessor.IsRelativeIri(property)) { continue; } else { foreach (var item in values) { var predicateNode = MakeNode(handler, property); var objectNode = MakeNode(handler, item); if (objectNode != null) { handler.HandleTriple(new Triple(subjectNode, predicateNode, objectNode, graphIri)); } } } } } } } catch (Exception) { handler.EndRdf(false); throw; } handler.EndRdf(true); }
private void TryParseGraphset(XmlReader reader, IRdfHandler handler) { try { handler.StartRdf(); reader.Read(); //Skip XML Declaration if present if (reader.NodeType == XmlNodeType.XmlDeclaration) { reader.Read(); } if (!reader.Name.Equals("TriX")) { throw new RdfParseException("Unexpected Document Element '" + reader.Name + "' encountered, expected the Document Element of a TriX Document to be the <TriX> element"); } if (!reader.HasAttributes) { throw new RdfParseException("<TriX> fails to define any attributes, the element must define the xmlns attribute to be the TriX namespace"); } else { bool trixNSDefined = false; for (int i = 0; i < reader.AttributeCount; i++) { reader.MoveToNextAttribute(); if (reader.Name.Equals("xmlns")) { //Ensure that the xmlns attribute is defined and is the TriX namespace if (trixNSDefined) { throw new RdfParseException("The xmlns attribute can only occur once on the <TriX> element"); } if (!reader.Value.Equals(TriXNamespaceURI)) { throw new RdfParseException("The xmlns attribute of the <TriX> element must have it's value set to the TriX Namespace URI which is '" + TriXNamespaceURI + "'"); } trixNSDefined = true; } else if (reader.LocalName.Equals("xmlns")) { //Don't think we need to do anything here } } if (!trixNSDefined) { throw new RdfParseException("The <TriX> element fails to define the required xmlns attribute defining the TriX Namespace"); } } //Process Child Nodes while (reader.Read()) { if (reader.NodeType == XmlNodeType.Element) { //For elements we recurse to try and parse a Graph this.TryParseGraph(reader, handler); } else if (reader.NodeType == XmlNodeType.EndElement) { //Stop when we hit an end element break; } else { //Stop if we hit an unexpected element break; } } //Expect the </TriX> element if (reader.NodeType == XmlNodeType.EndElement) { if (!reader.Name.Equals("TriX")) { throw new RdfParseException("Expected </TriX> element was not found, encountered </" + reader.Name + "> instead"); } } else { throw new RdfParseException("Unexpected Note Type " + reader.NodeType.ToString() + " encountered, expected a </TriX> element"); } handler.EndRdf(true); } catch (RdfParsingTerminatedException) { handler.EndRdf(true); //Discard this - it justs means the Handler told us to stop } catch { handler.EndRdf(false); throw; } }
/// <summary> /// Makes a Query where the expected result is a Graph i.e. a CONSTRUCT or DESCRIBE query /// </summary> /// <param name="handler">RDF Handler to process the results</param> /// <param name="sparqlQuery">SPARQL Query</param> public override void QueryWithResultGraph(IRdfHandler handler, string sparqlQuery) { //If no endpoints do nothing if (this._endpoints.Count == 0) { return; } //Fire off all the Asychronous Requests List <AsyncQueryWithResultGraph> asyncCalls = new List <AsyncQueryWithResultGraph>(); List <IAsyncResult> asyncResults = new List <IAsyncResult>(); int count = 0; foreach (SparqlRemoteEndpoint endpoint in this._endpoints) { //Limit the number of simultaneous requests we make to the user defined level (default 4) //We do this limiting check before trying to issue a request so that when the last request //is issued we'll always drop out of the loop and move onto our WaitAll() while (count >= this._maxSimultaneousRequests) { //First check that the count of active requests is accurate int active = asyncResults.Count(r => !r.IsCompleted); if (active < count) { //Some of the requests have already completed so we don't need to wait count = active; break; } else if (active > count) { //There are more active requests then we thought count = active; } //While the number of requests is at/above the maximum we'll wait for any of the requests to finish //Then we can decrement the count and if this drops back below our maximum then we'll go back into the //main loop and fire off our next request WaitHandle.WaitAny(asyncResults.Select(r => r.AsyncWaitHandle).ToArray()); count--; } //Make an asynchronous query to the next endpoint AsyncQueryWithResultGraph d = new AsyncQueryWithResultGraph(endpoint.QueryWithResultGraph); asyncCalls.Add(d); IAsyncResult asyncResult = d.BeginInvoke(sparqlQuery, null, null); asyncResults.Add(asyncResult); count++; } //Wait for all our requests to finish int waitTimeout = (base.Timeout > 0) ? base.Timeout : System.Threading.Timeout.Infinite; WaitHandle.WaitAll(asyncResults.Select(r => r.AsyncWaitHandle).ToArray(), waitTimeout); //Check for and handle timeouts if (!this._ignoreFailedRequests && !asyncResults.All(r => r.IsCompleted)) { for (int i = 0; i < asyncCalls.Count; i++) { try { asyncCalls[i].EndInvoke(asyncResults[i]); } catch { //Exceptions don't matter as we're just ensuring all the EndInvoke() calls are made } } throw new RdfQueryTimeoutException("Federated Querying failed due to one/more endpoints failing to return results within the Timeout specified which is currently " + (base.Timeout / 1000) + " seconds"); } //Now merge all the results together HashSet <String> varsSeen = new HashSet <string>(); bool cont = true; for (int i = 0; i < asyncCalls.Count; i++) { //Retrieve the result for this call AsyncQueryWithResultGraph call = asyncCalls[i]; IGraph g; try { g = call.EndInvoke(asyncResults[i]); } catch (Exception ex) { if (!this._ignoreFailedRequests) { //Clean up in the event of an error for (int j = i + 1; j < asyncCalls.Count; j++) { try { asyncCalls[j].EndInvoke(asyncResults[j]); } catch { //Exceptions don't matter as we're just ensuring all the EndInvoke() calls are made } } //If a single request fails then the entire query fails throw new RdfQueryException("Federated Querying failed due to the query against the endpoint '" + this._endpoints[i] + "' failing", ex); } else { //If we're ignoring failed requests we continue here continue; } } //Merge the result into the final results //If the handler has previously told us to stop we skip this step if (cont) { handler.StartRdf(); foreach (Triple t in g.Triples) { cont = handler.HandleTriple(t); //Stop if the Handler tells us to if (!cont) { break; } } handler.EndRdf(true); } } }
private void TryParseGraphset(XmlDocument doc, IRdfHandler handler) { try { handler.StartRdf(); XmlElement graphsetEl = doc.DocumentElement; if (!graphsetEl.Name.Equals("TriX")) { throw new RdfParseException("Unexpected Document Element '" + graphsetEl.Name + "' encountered, expected the Document Element of a TriX Document to be the <TriX> element"); } if (!graphsetEl.HasAttributes) { throw new RdfParseException("<TriX> fails to define any attributes, the element must define the xmlns attribute to be the TriX namespace"); } else { bool trixNSDefined = false; foreach (XmlAttribute attr in graphsetEl.Attributes) { if (attr.Name.Equals("xmlns")) { //Ensure that the xmlns attribute is defined and is the TriX namespace if (trixNSDefined) { throw new RdfParseException("The xmlns attribute can only occur once on the <TriX> element"); } if (!attr.Value.Equals(TriXNamespaceURI)) { throw new RdfParseException("The xmlns attribute of the <TriX> element must have it's value set to the TriX Namespace URI which is '" + TriXNamespaceURI + "'"); } trixNSDefined = true; } else if (attr.LocalName.Equals("xmlns")) { //Don't think we need to do anything here } } if (!trixNSDefined) { throw new RdfParseException("The <TriX> element fails to define the required xmlns attribute defining the TriX Namespace"); } } //Process Child Nodes foreach (XmlNode graph in graphsetEl.ChildNodes) { //Ignore non-Element nodes if (graph.NodeType == XmlNodeType.Element) { //OPT: Do this multi-threaded? this.TryParseGraph(graph, handler); } } handler.EndRdf(true); } catch (RdfParsingTerminatedException) { handler.EndRdf(true); //Discard this - it justs means the Handler told us to stop } catch { handler.EndRdf(false); throw; } }
/// <summary> /// Ends RDF Handling on the inner Handler /// </summary> /// <param name="ok">Indicates whether parsing completed without error</param> protected override void EndRdfInternal(bool ok) { _cancelled = false; _handler.EndRdf(ok); }
/// <summary> /// Ends inner handler /// </summary> protected override void EndRdfInternal(bool ok) => _handler.EndRdf(ok);
public void Load(IRdfHandler handler, TextReader input) { bool finished = false; try { // Tell handler we starting parsing handler.StartRdf(); // Perform actual parsing using (JsonReader jsonReader = new JsonTextReader(input)) { jsonReader.DateParseHandling = DateParseHandling.None; JToken json = JToken.Load(jsonReader); foreach (JObject subjectJObject in json) { string subject = subjectJObject["@id"].ToString(); JToken type; if (subjectJObject.TryGetValue("@type", out type)) { if (type is JArray) { foreach (JToken t in (JArray) type) { if (!HandleTriple(handler, subject, "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", t.ToString(), null, false)) return; } } else { if (!HandleTriple(handler, subject, "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", type.ToString(), null, false)) return; } } foreach (JProperty property in subjectJObject.Properties()) { if (property.Name == "@id" || property.Name == "@type") { continue; } foreach (JObject objectJObject in property.Value) { JToken id; JToken value; if (objectJObject.TryGetValue("@id", out id)) { if (!HandleTriple(handler, subject, property.Name, id.ToString(), null, false)) return; } else if (objectJObject.TryGetValue("@value", out value)) { string datatype = null; JToken datatypeJToken; if (objectJObject.TryGetValue("@type", out datatypeJToken)) { datatype = datatypeJToken.ToString(); } else { switch (value.Type) { case JTokenType.Boolean: datatype = "http://www.w3.org/2001/XMLSchema#boolean"; break; case JTokenType.Float: datatype = "http://www.w3.org/2001/XMLSchema#double"; break; case JTokenType.Integer: datatype = "http://www.w3.org/2001/XMLSchema#integer"; break; } } if (!HandleTriple(handler, subject, property.Name, value.ToString(), datatype, true)) return; } } } } } // Tell handler we've finished parsing finished = true; handler.EndRdf(true); } catch { // Catch all block to fulfill the IRdfHandler contract of informing the handler when the parsing has ended with failure finished = true; handler.EndRdf(false); throw; } finally { // Finally block handles the case where we exit the parsing loop early because the handler indicated it did not want // to receive further triples. In this case finished will be set to false and we need to inform the handler we're are done if (!finished) { handler.EndRdf(true); } } }
public void Load(IRdfHandler handler, TextReader input) { bool finished = false; try { // Tell handler we starting parsing handler.StartRdf(); // Perform actual parsing using (JsonReader jsonReader = new JsonTextReader(input)) { jsonReader.DateParseHandling = DateParseHandling.None; JToken json = JToken.Load(jsonReader); foreach (JObject subjectJObject in json) { string subject = subjectJObject["@id"].ToString(); JToken type; if (subjectJObject.TryGetValue("@type", out type)) { if (type is JArray) { foreach (JToken t in (JArray)type) { if (!HandleTriple(handler, subject, "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", t.ToString(), null, false)) { return; } } } else { if (!HandleTriple(handler, subject, "http://www.w3.org/1999/02/22-rdf-syntax-ns#type", type.ToString(), null, false)) { return; } } } foreach (JProperty property in subjectJObject.Properties()) { if (property.Name == "@id" || property.Name == "@type") { continue; } foreach (JObject objectJObject in property.Value) { JToken id; JToken value; if (objectJObject.TryGetValue("@id", out id)) { if (!HandleTriple(handler, subject, property.Name, id.ToString(), null, false)) { return; } } else if (objectJObject.TryGetValue("@value", out value)) { string datatype = null; JToken datatypeJToken; if (objectJObject.TryGetValue("@type", out datatypeJToken)) { datatype = datatypeJToken.ToString(); } else { switch (value.Type) { case JTokenType.Boolean: datatype = "http://www.w3.org/2001/XMLSchema#boolean"; break; case JTokenType.Float: datatype = "http://www.w3.org/2001/XMLSchema#double"; break; case JTokenType.Integer: datatype = "http://www.w3.org/2001/XMLSchema#integer"; break; } } if (!HandleTriple(handler, subject, property.Name, value.ToString(), datatype, true)) { return; } } } } } } // Tell handler we've finished parsing finished = true; handler.EndRdf(true); } catch { // Catch all block to fulfill the IRdfHandler contract of informing the handler when the parsing has ended with failure finished = true; handler.EndRdf(false); throw; } finally { // Finally block handles the case where we exit the parsing loop early because the handler indicated it did not want // to receive further triples. In this case finished will be set to false and we need to inform the handler we're are done if (!finished) { handler.EndRdf(true); } } }
private void Parse(IRdfHandler handler, ITokenQueue tokens) { IToken next; IToken s, p, o; try { handler.StartRdf(); //Expect a BOF token at start next = tokens.Dequeue(); if (next.TokenType != Token.BOF) { throw ParserHelper.Error("Unexpected Token '" + next.GetType().ToString() + "' encountered, expected a BOF token at the start of the input", next); } do { next = tokens.Peek(); if (next.TokenType == Token.EOF) return; s = this.TryParseSubject(tokens); p = this.TryParsePredicate(tokens); o = this.TryParseObject(tokens); Uri context = this.TryParseContext(tokens); this.TryParseTriple(handler, s, p, o, context); next = tokens.Peek(); } while (next.TokenType != Token.EOF); handler.EndRdf(true); } catch (RdfParsingTerminatedException) { handler.EndRdf(true); //Discard this - it justs means the Handler told us to stop } catch { handler.EndRdf(false); throw; } }
/// <summary> /// Ends handling of RDF /// </summary> /// <param name="ok">Whether parsing completed OK</param> protected override void EndRdfInternal(bool ok) { _handler.EndRdf(ok); base.EndRdfInternal(ok); }