コード例 #1
0
        public XmlRdfProcessor(IRdfHandler rdfHandler, XmlPlaceholderResolver entityResolver = null) : base(rdfHandler)
        {
            rdf      = rdfHandler;
            linkName = entityResolver?.InstructionTarget;

            ProcessingInstructionMapping["xml-stylesheet"] = xmlNSUri;

            rdf.StartRdf();

            rdf.HandleNamespace("rdf", new Uri(rdfNS));
            rdf.HandleNamespace("rdfs", new Uri(rdfsNS));
            rdf.HandleNamespace("xsd", new Uri(xsdNS));
        }
コード例 #2
0
 /// <summary>
 /// Handles Namespace Declarations by passing them to the inner handler and cancelling handling if it has been requested.
 /// </summary>
 /// <param name="prefix">Namespace Prefix.</param>
 /// <param name="namespaceUri">Namespace URI.</param>
 /// <returns></returns>
 protected override bool HandleNamespaceInternal(string prefix, Uri namespaceUri)
 {
     if (_cancelled)
     {
         return(false);
     }
     return(_handler.HandleNamespace(prefix, namespaceUri));
 }
コード例 #3
0
        /// <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;
            }
        }
コード例 #4
0
        /// <summary>
        /// Applies the triples of a Graph to an RDF Handler.
        /// </summary>
        /// <param name="handler">RDF Handler.</param>
        /// <param name="g">Graph.</param>
        public static void Apply(this IRdfHandler handler, IGraph g)
        {
            try
            {
                handler.StartRdf();
                if (g != null)
                {
                    // Handle the Base URI if present
                    if (g.BaseUri != null)
                    {
                        if (!handler.HandleBaseUri(g.BaseUri))
                        {
                            ParserHelper.Stop();
                        }
                    }
                    // Handle any namespaces
                    foreach (String prefix in g.NamespaceMap.Prefixes)
                    {
                        if (!handler.HandleNamespace(prefix, g.NamespaceMap.GetNamespaceUri(prefix)))
                        {
                            ParserHelper.Stop();
                        }
                    }
                    // Finally handle triples
                    foreach (Triple t in g.Triples)
                    {
                        if (!handler.HandleTriple(t))
                        {
                            ParserHelper.Stop();
                        }
                    }
                }

                handler.EndRdf(true);
            }
            catch (RdfParsingTerminatedException)
            {
                handler.EndRdf(true);
            }
            catch
            {
                handler.EndRdf(false);
                throw;
            }
        }
コード例 #5
0
        /// <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;
            }
        }
コード例 #6
0
 /// <summary>
 /// Delegates namespace handling to inner handler.
 /// </summary>
 protected override bool HandleNamespaceInternal(string prefix, Uri namespaceUri) => _handler.HandleNamespace(prefix, namespaceUri);
コード例 #7
0
        /// <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
        }