Esempio n. 1
0
        /// <summary>
        /// Loads a Graph from the Store.
        /// </summary>
        /// <param name="handler">RDF Handler.</param>
        /// <param name="graphUri">Graph URI to load.</param>
        public override void LoadGraph(IRdfHandler handler, Uri graphUri)
        {
            IGraph g = null;

            if (_dataset.HasGraph(graphUri))
            {
                g = _dataset[graphUri];
            }
            handler.Apply(g);
        }
Esempio n. 2
0
 /// <summary>
 /// Creates a new Leviathan Update Processor.
 /// </summary>
 /// <param name="data">SPARQL Dataset.</param>
 public LeviathanUpdateProcessor(ISparqlDataset data)
 {
     _dataset = data;
     if (!_dataset.HasGraph(null))
     {
         // Create the Default unnamed Graph if it doesn't exist and then Flush() the change
         _dataset.AddGraph(new Graph());
         _dataset.Flush();
     }
 }
Esempio n. 3
0
        private void TestCreateGraphRollbackWithoutAutoCommit()
        {
            ISparqlDataset dataset = this.GetEmptyDataset();

            String updates = "CREATE GRAPH <" + TestGraphUri.ToString() + ">; CREATE GRAPH <" + TestGraphUri.ToString() + ">";

            SparqlUpdateCommandSet cmds = this._parser.ParseFromString(updates);

            LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);

            processor.AutoCommit = false;
            try
            {
                processor.ProcessCommandSet(cmds);
                Assert.True(false, "Did not throw a SparqlUpdateException as expected");
            }
            catch (SparqlUpdateException upEx)
            {
                TestTools.ReportError("Update Exception", upEx);
            }

            Assert.True(dataset.HasGraph(TestGraphUri), "Graph should exist as the Transaction has not been committed yet as Auto-Commit is off");

            //Try to Flush() which should error
            try
            {
                processor.Flush();
                Assert.True(false, "Did not throw a SparqlUpdateException as expected on call to Flush()");
            }
            catch (SparqlUpdateException upEx)
            {
                Console.WriteLine("Threw error when attempting to Flush() as expected");
                TestTools.ReportError("Update Exception", upEx);
            }

            //Now discard
            processor.Discard();
            Assert.False(dataset.HasGraph(TestGraphUri), "Graph should not exist as the Discard() should cause it to be removed from the Dataset");
        }
Esempio n. 4
0
        private void TestCreateGraphCommit()
        {
            ISparqlDataset dataset = this.GetEmptyDataset();

            String updates = "CREATE GRAPH <" + TestGraphUri.ToString() + ">";

            SparqlUpdateCommandSet cmds = this._parser.ParseFromString(updates);

            LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);

            processor.ProcessCommandSet(cmds);

            Assert.True(dataset.HasGraph(TestGraphUri), "Graph should exist");
        }
Esempio n. 5
0
        private void TestInsertDataSequenceCommit()
        {
            ISparqlDataset dataset = this.GetEmptyDataset();

            String updates = "INSERT DATA { GRAPH <" + TestGraphUri.ToString() + "> { } }; INSERT DATA { GRAPH <" + TestGraphUri.ToString() + "> { <ex:subj> <ex:pred> <ex:obj> } }";

            SparqlUpdateCommandSet   cmds      = this._parser.ParseFromString(updates);
            LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);

            processor.ProcessCommandSet(cmds);

            Assert.True(dataset.HasGraph(TestGraphUri), "Graph should exist");
            Assert.Equal(1, dataset[TestGraphUri].Triples.Count);
        }
Esempio n. 6
0
        private void TestInsertDataThenDropCommit()
        {
            ISparqlDataset dataset = this.GetEmptyDataset();

            String updates = "INSERT DATA { GRAPH <" + TestGraphUri.ToString() + "> { <ex:subject> <ex:predicate> <ex:object> } }; DROP GRAPH <" + TestGraphUri.ToString() + ">";

            SparqlUpdateCommandSet cmds = this._parser.ParseFromString(updates);

            LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);

            processor.ProcessCommandSet(cmds);

            Assert.False(dataset.HasGraph(TestGraphUri), "Graph should not exist as the Flush() should cause it to be removed from the Dataset");
        }
Esempio n. 7
0
        private void TestLoadCommit()
        {
            ISparqlDataset dataset = this.GetEmptyDataset();

            String updates = "LOAD <http://www.dotnetrdf.org/configuration#> INTO GRAPH <" + TestGraphUri.ToString() + ">";

            SparqlUpdateCommandSet cmds = this._parser.ParseFromString(updates);

            LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);

            processor.ProcessCommandSet(cmds);

            Assert.True(dataset.HasGraph(TestGraphUri), "Graph should exist");
        }
Esempio n. 8
0
        private void TestDropGraphCommit()
        {
            ISparqlDataset dataset = this.GetNonEmptyDataset();

            String updates = "DROP GRAPH <" + TestGraphUri.ToString() + ">";

            SparqlUpdateParser     parser = new SparqlUpdateParser();
            SparqlUpdateCommandSet cmds   = parser.ParseFromString(updates);

            LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);

            processor.ProcessCommandSet(cmds);

            Assert.False(dataset.HasGraph(TestGraphUri), "Graph should not exist");
        }
Esempio n. 9
0
        private void TestCreateGraphRollback()
        {
            ISparqlDataset dataset = this.GetEmptyDataset();

            String updates = "CREATE GRAPH <" + TestGraphUri.ToString() + ">; CREATE GRAPH <" + TestGraphUri.ToString() + ">";

            SparqlUpdateCommandSet cmds = this._parser.ParseFromString(updates);

            LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);

            try
            {
                processor.ProcessCommandSet(cmds);
                Assert.True(false, "Did not thrown a SparqlUpdateException as expected");
            }
            catch (SparqlUpdateException upEx)
            {
                TestTools.ReportError("Update Exception", upEx);
            }

            Assert.False(dataset.HasGraph(TestGraphUri), "Graph should not exist as the Discard() should cause it to be removed from the Dataset");
        }
Esempio n. 10
0
        private void TestCreateDropSequenceRollback2()
        {
            ISparqlDataset dataset = this.GetNonEmptyDataset();

            String updates = "DROP GRAPH <" + TestGraphUri.ToString() + ">; CREATE GRAPH <" + TestGraphUri.ToString() + ">; DROP GRAPH <" + TestGraphUri.ToString() + ">; DROP GRAPH <" + TestGraphUri.ToString() + ">";

            SparqlUpdateCommandSet cmds = this._parser.ParseFromString(updates);

            LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);

            try
            {
                processor.ProcessCommandSet(cmds);
                Assert.True(false, "Expected SPARQL Update Exception was not thrown");
            }
            catch (SparqlUpdateException upEx)
            {
                TestTools.ReportError("Update Exception", upEx);
            }

            Assert.True(dataset.HasGraph(TestGraphUri), "Graph should not exist");
        }
Esempio n. 11
0
        private void TestDropGraphRollback()
        {
            ISparqlDataset dataset = this.GetNonEmptyDataset();

            String updates = "DROP GRAPH <" + TestGraphUri.ToString() + ">; DROP GRAPH <" + TestGraphUri.ToString() + ">";

            SparqlUpdateCommandSet cmds = this._parser.ParseFromString(updates);

            LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);

            try
            {
                processor.ProcessCommandSet(cmds);
                Assert.True(false, "Did not thrown a SparqlUpdateException as expected");
            }
            catch (SparqlUpdateException upEx)
            {
                TestTools.ReportError("Update Exception", upEx);
            }

            Assert.True(dataset.HasGraph(TestGraphUri), "Graph should exist as the Discard() should ensure it was still in the Dataset");
        }
Esempio n. 12
0
        private void TestDropThenInsertDataRollback()
        {
            ISparqlDataset dataset = this.GetNonEmptyDataset();

            String updates = "DROP GRAPH <" + TestGraphUri.ToString() + ">; INSERT DATA { GRAPH <" + TestGraphUri.ToString() + "> { <ex:subject> <ex:predicate> <ex:object> } }; CREATE GRAPH <" + TestGraphUri.ToString() + ">";

            SparqlUpdateCommandSet cmds = this._parser.ParseFromString(updates);

            LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);

            try
            {
                processor.ProcessCommandSet(cmds);
                Assert.True(false, "Did not thrown a SparqlUpdateException as expected");
            }
            catch (SparqlUpdateException upEx)
            {
                TestTools.ReportError("Update Exception", upEx);
            }

            Assert.True(dataset.HasGraph(TestGraphUri), "Graph should not exist as the Discard() should cause it to be removed from the Dataset");
            Assert.True(dataset[TestGraphUri].IsEmpty, "Graph should be empty as the Discard() should have reversed the INSERT DATA");
        }
Esempio n. 13
0
 /// <summary>
 /// Gets whether the dataset contains a given Graph.
 /// </summary>
 /// <param name="graphUri">Graph URI.</param>
 /// <returns></returns>
 public virtual bool HasGraph(Uri graphUri)
 {
     return(_dataset.HasGraph(graphUri));
 }
 /// <summary>
 /// Gets whether the Collection contains a Graph with the given URI.
 /// </summary>
 /// <param name="graphUri">Graph URI.</param>
 /// <returns></returns>
 public override bool Contains(Uri graphUri)
 {
     return(_dataset.HasGraph(graphUri));
 }
        /// <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
            ReaderWriterLockSlim currLock = (_dataset is IThreadSafeDataset) ? ((IThreadSafeDataset)_dataset).Lock : _lock;

            try
            {
                currLock.EnterReadLock();
                // 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)
                        {
                            _dataset.HasGraph(defGraphUri);
                        }
                        _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
                        _dataset.SetDefaultGraph(Enumerable.Empty <Uri>());
                    }
                    _dataset.SetActiveGraph(_dataset.DefaultGraphUris);
                    datasetOk = true;

                    // Convert to Algebra and execute the Query
                    SparqlEvaluationContext context = 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
                            if (context.OutputMultiset is IdentityMultiset)
                            {
                                context.OutputMultiset = new SingletonMultiset();
                            }
                            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)
                    {
                        _dataset.ResetDefaultGraph();
                    }
                    if (datasetOk)
                    {
                        _dataset.ResetActiveGraph();
                    }
                }
            }
            finally
            {
                currLock.ExitReadLock();
            }
        }