public void SparqlGraphClause4() { String query = "SELECT * WHERE { GRAPH ?g { ?s ?p ?o } }"; SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery q = parser.ParseFromString(query); InMemoryDataset dataset = new InMemoryDataset(false); IGraph ex = new Graph(); FileLoader.Load(ex, "resources\\InferenceTest.ttl"); ex.BaseUri = new Uri("http://example.org/graph"); dataset.AddGraph(ex); IGraph def = new Graph(); dataset.AddGraph(def); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(dataset); Object results = processor.ProcessQuery(q); if (results is SparqlResultSet) { SparqlResultSet rset = (SparqlResultSet)results; TestTools.ShowResults(rset); Assert.Equal(ex.Triples.Count, rset.Count); } else { Assert.True(false, "Did not get a SPARQL Result Set as expected"); } }
/// <summary> /// /// </summary> /// <param name="spinGraph"></param> /// <returns></returns> internal IGraph Initialise(IGraph spinGraph) { if (_spinConfiguration.GraphUris.Contains(spinGraph.BaseUri)) { _spinConfiguration.RemoveGraph(spinGraph.BaseUri); } String ontQuery = "CONSTRUCT { ?graphUri a <" + SPIN.ClassLibraryOntology + ">} WHERE { {?s (<" + SPIN.PropertyImports + ">|<" + OWL.PropertyImports + ">) ?graphUri} UNION {?graphUri a <" + SPIN.ClassLibraryOntology + ">} }"; IGraph imports = (Graph)spinGraph.ExecuteQuery(ontQuery); // Explore for subsequent imports foreach (Triple t in imports.GetTriplesWithPredicateObject(RDF.PropertyType, SPIN.ClassLibraryOntology)) { Uri importUri = ((IUriNode)t.Subject).Uri; if (!_spinConfiguration.GraphUris.Contains(importUri) && !RDFUtil.sameTerm(importUri, spinGraph.BaseUri)) { Initialise(importUri); } } _spinConfiguration.AddGraph(spinGraph); _reasoner.Initialise(spinGraph); IGraph inferenceGraph = ApplyInference(spinGraph); _spinConfiguration.AddGraph(inferenceGraph); _reasoner.Initialise(inferenceGraph); return(inferenceGraph); }
public void SparqlUpdateDeleteCommandWithNoMatchingGraphAndChildGraphPatterns() { var dataset = new InMemoryDataset(); var updateGraphUri = new Uri("http://example.org/g2"); var updateGraph = new Graph { BaseUri = updateGraphUri }; updateGraph.Assert(new Triple(updateGraph.CreateUriNode(new Uri("http://example.org/s")), updateGraph.CreateUriNode(new Uri("http://example.org/p")), updateGraph.CreateUriNode(new Uri("http://example.org/o")))); dataset.AddGraph(updateGraph); var egGraph = new Uri("http://example.org/graph"); dataset.HasGraph(egGraph).Should().BeFalse(); var processor = new LeviathanUpdateProcessor(dataset); var cmdSet = new SparqlUpdateParser().ParseFromString( "WITH <" + egGraph + "> DELETE { GRAPH <http://example.org/g2> { <http://example.org/s> <http://example.org/p> <http://example.org/o> }} WHERE {}"); processor.ProcessCommandSet(cmdSet); dataset.HasGraph(egGraph).Should().BeFalse(because: "Update command should not create an empty graph for a DELETE operation"); dataset[updateGraphUri].IsEmpty.Should() .BeTrue("Triples should be deleted by child graph pattern"); }
public void SparqlUpdateDeleteWithGraphClause2() { Graph g = new Graph(); g.Assert(g.CreateUriNode(UriFactory.Create("http://subject")), g.CreateUriNode(UriFactory.Create("http://predicate")), g.CreateUriNode(UriFactory.Create("http://object"))); Graph h = new Graph(); h.Merge(g); h.BaseUri = UriFactory.Create("http://subject"); InMemoryDataset dataset = new InMemoryDataset(g); dataset.AddGraph(h); dataset.Flush(); Assert.Equal(2, dataset.GraphUris.Count()); String updates = "DELETE { GRAPH ?s { ?s ?p ?o } } INSERT { GRAPH ?o { ?s ?p ?o } } WHERE { ?s ?p ?o }"; SparqlUpdateCommandSet commands = new SparqlUpdateParser().ParseFromString(updates); LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset); processor.ProcessCommandSet(commands); Assert.Equal(3, dataset.GraphUris.Count()); Assert.True(dataset.HasGraph(UriFactory.Create("http://subject"))); Assert.True(dataset.HasGraph(UriFactory.Create("http://object"))); Assert.Equal(0, dataset[UriFactory.Create("http://subject")].Triples.Count); }
private static InMemoryDataset CreateDataset(int numberOfTriples) { var dataset = new InMemoryDataset(new TripleStore(), true); dataset.AddGraph(CreateGraph(numberOfTriples)); return(dataset); }
public void SparqlUpdateDeleteDataCombination() { SparqlParameterizedString command = new SparqlParameterizedString(); command.Namespaces.AddNamespace("ex", new Uri("http://example.org/")); command.CommandText = "DELETE DATA { ex:a ex:b ex:c GRAPH <http://example.org/graph> { ex:a ex:b ex:c } }"; SparqlUpdateParser parser = new SparqlUpdateParser(); SparqlUpdateCommandSet cmds = parser.ParseFromString(command); Assert.IsFalse(cmds.Commands.All(cmd => cmd.AffectsSingleGraph), "Commands should report that they do not affect a single Graph"); Assert.IsTrue(cmds.Commands.All(cmd => cmd.AffectsGraph(null)), "Commands should report that they affect the Default Graph"); Assert.IsTrue(cmds.Commands.All(cmd => cmd.AffectsGraph(new Uri("http://example.org/graph"))), "Commands should report that they affect the named Graph"); InMemoryDataset dataset = new InMemoryDataset(); IGraph def = new Graph(); def.NamespaceMap.Import(command.Namespaces); def.Assert(new Triple(def.CreateUriNode("ex:a"), def.CreateUriNode("ex:b"), def.CreateUriNode("ex:c"))); dataset.AddGraph(def); IGraph ex = new Graph(); ex.BaseUri = new Uri("http://example.org/graph"); ex.NamespaceMap.Import(command.Namespaces); ex.Assert(new Triple(ex.CreateUriNode("ex:a"), ex.CreateUriNode("ex:b"), ex.CreateUriNode("ex:c"))); dataset.AddGraph(ex); LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset); processor.ProcessCommandSet(cmds); Graph g = new Graph(); g.NamespaceMap.Import(command.Namespaces); Triple t = new Triple(g.CreateUriNode("ex:a"), g.CreateUriNode("ex:b"), g.CreateUriNode("ex:c")); def = dataset[null]; Assert.AreEqual(0, def.Triples.Count, "Should be 0 Triples in the Default Graph"); Assert.IsFalse(def.ContainsTriple(t), "Should not have the deleted Triple in the Default Graph"); ex = dataset[new Uri("http://example.org/graph")]; Assert.AreEqual(0, ex.Triples.Count, "Should be 0 Triples in the Named Graph"); Assert.IsFalse(ex.ContainsTriple(t), "Should not have the deleted Triple in the Named Graph"); }
private static ISparqlDataset GetTestData() { InMemoryDataset dataset = new InMemoryDataset(); Graph g = new Graph(); g.LoadFromFile("resources\\InferenceTest.ttl"); dataset.AddGraph(g); return(dataset); }
private ISparqlDataset GetTestData() { InMemoryDataset dataset = new InMemoryDataset(); Graph g = new Graph(); FileLoader.Load(g, "InferenceTest.ttl"); dataset.AddGraph(g); return(dataset); }
public RdfHandler() { _testGraphUri = new Uri("http://example.org/graph"); var dataset = new InMemoryDataset(new TripleStore(), _testGraphUri); dataset.AddGraph(new Graph { BaseUri = _testGraphUri }); _rdfQueryWrapper = new RdfQueryWrapper(dataset); }
protected virtual ISparqlDataset GetNonEmptyDataset() { InMemoryDataset dataset = new InMemoryDataset(); Graph g = new Graph(); g.BaseUri = TestGraphUri; dataset.AddGraph(g); return(dataset); }
private void SparqlQueryThreadSafeEvaluationActual() { String query1 = "CONSTRUCT { ?s ?p ?o } WHERE { GRAPH <http://example.org/1> { ?s ?p ?o } }"; String query2 = "CONSTRUCT { ?s ?p ?o } WHERE { GRAPH <http://example.org/2> { ?s ?p ?o } }"; SparqlQuery q1 = this._parser.ParseFromString(query1); SparqlQuery q2 = this._parser.ParseFromString(query2); Assert.False(q1.UsesDefaultDataset, "Query 1 should not be thread safe"); Assert.False(q2.UsesDefaultDataset, "Query 2 should not be thread safe"); InMemoryDataset dataset = new InMemoryDataset(); Graph g = new Graph(); g.LoadFromEmbeddedResource("VDS.RDF.Configuration.configuration.ttl"); g.BaseUri = new Uri("http://example.org/1"); Graph h = new Graph(); h.LoadFromEmbeddedResource("VDS.RDF.Query.Expressions.LeviathanFunctionLibrary.ttl"); h.BaseUri = new Uri("http://example.org/2"); dataset.AddGraph(g); dataset.AddGraph(h); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(dataset); QueryWithGraphDelegate d = new QueryWithGraphDelegate(this.QueryWithGraph); IAsyncResult r1 = d.BeginInvoke(q1, processor, null, null); IAsyncResult r2 = d.BeginInvoke(q2, processor, null, null); WaitHandle.WaitAll(new WaitHandle[] { r1.AsyncWaitHandle, r2.AsyncWaitHandle }); IGraph gQuery = d.EndInvoke(r1); Assert.Equal(g, gQuery); IGraph hQuery = d.EndInvoke(r2); Assert.Equal(h, hQuery); Assert.NotEqual(g, h); }
private void SparqlQueryThreadSafeEvaluationActual() { var query1 = "CONSTRUCT { ?s ?p ?o } WHERE { GRAPH <http://example.org/1> { ?s ?p ?o } }"; var query2 = "CONSTRUCT { ?s ?p ?o } WHERE { GRAPH <http://example.org/2> { ?s ?p ?o } }"; var q1 = _parser.ParseFromString(query1); var q2 = _parser.ParseFromString(query2); Assert.False(q1.UsesDefaultDataset, "Query 1 should not be thread safe"); Assert.False(q2.UsesDefaultDataset, "Query 2 should not be thread safe"); var dataset = new InMemoryDataset(); var g = new Graph(); g.LoadFromEmbeddedResource("VDS.RDF.Configuration.configuration.ttl"); g.BaseUri = new Uri("http://example.org/1"); var h = new Graph(); h.LoadFromEmbeddedResource("VDS.RDF.Query.Expressions.LeviathanFunctionLibrary.ttl"); h.BaseUri = new Uri("http://example.org/2"); dataset.AddGraph(g); dataset.AddGraph(h); var processor = new LeviathanQueryProcessor(dataset); var t1 = Task.Factory.StartNew(() => QueryWithGraph(q1, processor)); var t2 = Task.Factory.StartNew(() => QueryWithGraph(q2, processor)); Task.WaitAll(t1, t2); var gQuery = t1.Result; var hQuery = t2.Result; Assert.Equal(g, gQuery); Assert.Equal(h, hQuery); Assert.NotEqual(g, h); }
public void SparqlDescribeDefaultGraphHandling1() { InMemoryDataset dataset = new InMemoryDataset(); IGraph g = new Graph(); g.Assert(g.CreateUriNode(UriFactory.Create("http://subject")), g.CreateUriNode(UriFactory.Create("http://predicate")), g.CreateUriNode(UriFactory.Create("http://object"))); g.BaseUri = UriFactory.Create("http://graph"); dataset.AddGraph(g); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(dataset); IGraph description = processor.ProcessQuery(this._parser.ParseFromString("DESCRIBE ?s FROM <http://graph> WHERE { ?s ?p ?o }")) as IGraph; Assert.NotNull(description); Assert.False(description.IsEmpty); }
public void SparqlUpdateChangesNotReflectedInOriginalGraph1() { //Test Case originally submitted by Tomasz Pluskiewicz // given IGraph sourceGraph = new Graph(); sourceGraph.LoadFromString(@"@prefix ex: <http://www.example.com/> . ex:Subject ex:hasObject ex:Object ."); IGraph expectedGraph = new Graph(); expectedGraph.LoadFromString(@"@prefix ex: <http://www.example.com/> . ex:Subject ex:hasBlank [ ex:hasObject ex:Object ] ."); //IMPORTANT - Because we create the dataset without an existing store it //creates a new triple store internally which has a single unnamed graph //Then when we add another unnamed graph it merges into that existing graph, //this is why the update does not apply to the added graph but rather to //the merged graph that is internal to the dataset ISparqlDataset dataset = new InMemoryDataset(true); dataset.AddGraph(sourceGraph); // when var command = new SparqlParameterizedString { CommandText = @"PREFIX ex: <http://www.example.com/> DELETE { ex:Subject ex:hasObject ex:Object . } INSERT { ex:Subject ex:hasBlank [ ex:hasObject ex:Object ] . } WHERE { ?s ?p ?o . }" }; SparqlUpdateCommandSet cmds = new SparqlUpdateParser().ParseFromString(command); LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset); processor.ProcessCommandSet(cmds); Assert.Single(dataset.Graphs); IGraph g = dataset.Graphs.First(); Assert.Equal(2, g.Triples.Count); Assert.False(ReferenceEquals(g, sourceGraph), "Result Graph should not be the Source Graph"); Assert.Equal(1, sourceGraph.Triples.Count); Assert.NotEqual(expectedGraph, sourceGraph); }
private void EnsureTestData() { if (_dataset == null) { _dataset = new InMemoryDataset(); Graph g = new Graph(); g.LoadFromEmbeddedResource("VDS.RDF.Configuration.configuration.ttl"); g.Retract(g.Triples.Where(t => !t.IsGroundTriple).ToList()); if (g.Triples.Count > TripleLimit) { g.Retract(g.Triples.Skip(TripleLimit).ToList()); } _dataset.AddGraph(g); _dataset.SetDefaultGraph(g.BaseUri); _processor = new LeviathanQueryProcessor(_dataset); } }
private void SparqlQueryAndUpdateThreadSafeEvaluationActual() { var query1 = "CONSTRUCT { ?s ?p ?o } WHERE { GRAPH <http://example.org/1> { ?s ?p ?o } }"; var query2 = "CONSTRUCT { ?s ?p ?o } WHERE { GRAPH <http://example.org/2> { ?s ?p ?o } }"; var query3 = "CONSTRUCT { ?s ?p ?o } WHERE { GRAPH <http://example.org/3> { ?s ?p ?o } }"; var update1 = "INSERT DATA { GRAPH <http://example.org/3> { <ex:subj> <ex:pred> <ex:obj> } }"; var q1 = _parser.ParseFromString(query1); var q2 = _parser.ParseFromString(query2); var q3 = _parser.ParseFromString(query3); Assert.False(q1.UsesDefaultDataset, "Query 1 should not be thread safe"); Assert.False(q2.UsesDefaultDataset, "Query 2 should not be thread safe"); Assert.False(q3.UsesDefaultDataset, "Query 3 should not be thread safe"); var parser = new SparqlUpdateParser(); var cmds = parser.ParseFromString(update1); var dataset = new InMemoryDataset(); var g = new Graph(); g.LoadFromEmbeddedResource("VDS.RDF.Configuration.configuration.ttl"); g.BaseUri = new Uri("http://example.org/1"); var h = new Graph(); h.LoadFromEmbeddedResource("VDS.RDF.Query.Expressions.LeviathanFunctionLibrary.ttl"); h.BaseUri = new Uri("http://example.org/2"); var i = new Graph { BaseUri = new Uri("http://example.org/3") }; dataset.AddGraph(g); dataset.AddGraph(h); dataset.AddGraph(i); var processor = new LeviathanQueryProcessor(dataset); var upProcessor = new LeviathanUpdateProcessor(dataset); var d = new QueryWithGraphDelegate(QueryWithGraph); var d2 = new RunUpdateDelegate(RunUpdate); var t1 = Task.Factory.StartNew(() => QueryWithGraph(q1, processor)); var t2 = Task.Factory.StartNew(() => QueryWithGraph(q2, processor)); var t3 = Task.Factory.StartNew(() => QueryWithGraph(q3, processor)); var t4 = Task.Factory.StartNew(() => RunUpdate(cmds, upProcessor)); Task.WaitAll(t1, t2, t3, t4); var gQuery = t1.Result; var hQuery = t2.Result; var iQuery = t3.Result; Assert.Equal(g, gQuery); Assert.Equal(h, hQuery); if (iQuery.IsEmpty) { _output.WriteLine("Query 3 executed before the INSERT DATA command - running again to get the resulting graph"); iQuery = QueryWithGraph(q3, processor); } else { _output.WriteLine("Query 3 executed after the INSERT DATA command"); } //Test iQuery against an empty Graph Assert.False(iQuery.IsEmpty, "Graph should not be empty as INSERT DATA should have inserted a Triple"); Assert.NotEqual(new Graph(), iQuery); Assert.NotEqual(g, h); }
private void SparqlQueryAndUpdateThreadSafeEvaluationActual() { String query1 = "CONSTRUCT { ?s ?p ?o } WHERE { GRAPH <http://example.org/1> { ?s ?p ?o } }"; String query2 = "CONSTRUCT { ?s ?p ?o } WHERE { GRAPH <http://example.org/2> { ?s ?p ?o } }"; String query3 = "CONSTRUCT { ?s ?p ?o } WHERE { GRAPH <http://example.org/3> { ?s ?p ?o } }"; String update1 = "INSERT DATA { GRAPH <http://example.org/3> { <ex:subj> <ex:pred> <ex:obj> } }"; SparqlQuery q1 = this._parser.ParseFromString(query1); SparqlQuery q2 = this._parser.ParseFromString(query2); SparqlQuery q3 = this._parser.ParseFromString(query3); Assert.False(q1.UsesDefaultDataset, "Query 1 should not be thread safe"); Assert.False(q2.UsesDefaultDataset, "Query 2 should not be thread safe"); Assert.False(q3.UsesDefaultDataset, "Query 3 should not be thread safe"); SparqlUpdateParser parser = new SparqlUpdateParser(); SparqlUpdateCommandSet cmds = parser.ParseFromString(update1); InMemoryDataset dataset = new InMemoryDataset(); Graph g = new Graph(); g.LoadFromEmbeddedResource("VDS.RDF.Configuration.configuration.ttl"); g.BaseUri = new Uri("http://example.org/1"); Graph h = new Graph(); h.LoadFromEmbeddedResource("VDS.RDF.Query.Expressions.LeviathanFunctionLibrary.ttl"); h.BaseUri = new Uri("http://example.org/2"); Graph i = new Graph(); i.BaseUri = new Uri("http://example.org/3"); dataset.AddGraph(g); dataset.AddGraph(h); dataset.AddGraph(i); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(dataset); LeviathanUpdateProcessor upProcessor = new LeviathanUpdateProcessor(dataset); QueryWithGraphDelegate d = new QueryWithGraphDelegate(this.QueryWithGraph); RunUpdateDelegate d2 = new RunUpdateDelegate(this.RunUpdate); IAsyncResult r1 = d.BeginInvoke(q1, processor, null, null); IAsyncResult r2 = d.BeginInvoke(q2, processor, null, null); IAsyncResult r3 = d.BeginInvoke(q3, processor, null, null); IAsyncResult r4 = d2.BeginInvoke(cmds, upProcessor, null, null); WaitHandle.WaitAll(new WaitHandle[] { r1.AsyncWaitHandle, r2.AsyncWaitHandle, r3.AsyncWaitHandle, r4.AsyncWaitHandle }); IGraph gQuery = d.EndInvoke(r1); Assert.Equal(g, gQuery); IGraph hQuery = d.EndInvoke(r2); Assert.Equal(h, hQuery); IGraph iQuery = d.EndInvoke(r3); if (iQuery.IsEmpty) { Console.WriteLine("Query 3 executed before the INSERT DATA command - running again to get the resulting graph"); iQuery = this.QueryWithGraph(q3, processor); } else { Console.WriteLine("Query 3 executed after the INSERT DATA command"); } //Test iQuery against an empty Graph Assert.False(iQuery.IsEmpty, "Graph should not be empty as INSERT DATA should have inserted a Triple"); Assert.NotEqual(new Graph(), iQuery); Assert.NotEqual(g, h); }