public void SparqlUpdateTimeout()
{
String update = "CREATE GRAPH <http://example.org/1>; LOAD <http://www.dotnetrdf.org/configuration#>; CREATE GRAPH <http://example.org/2>";
SparqlUpdateCommandSet cmds = this._parser.ParseFromString(update);
cmds.Timeout = 1;
TripleStore store = new TripleStore();
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(store);
try
{
processor.ProcessCommandSet(cmds);
Assert.Fail("Expected a SparqlUpdateTimeoutException");
}
catch (SparqlUpdateTimeoutException timeoutEx)
{
TestTools.ReportError("Timeout", timeoutEx);
Console.WriteLine();
Console.WriteLine("Execution Time: " + cmds.UpdateExecutionTime.Value.ToString());
Assert.IsFalse(store.HasGraph(new Uri("http://example.org/1")), "Graph 1 should not exist");
Assert.IsFalse(store.HasGraph(new Uri("http://example.org/2")), "Graph 2 should not exist");
}
}
public void SparqlUpdateDeleteWithBind()
{
TripleStore store = new TripleStore();
Graph g = new Graph();
g.LoadFromFile("resources\\rvesse.ttl");
store.Add(g);
int origTriples = g.Triples.Count;
SparqlParameterizedString command = new SparqlParameterizedString();
command.Namespaces.AddNamespace("foaf", new Uri("http://xmlns.com/foaf/0.1/"));
command.CommandText = "DELETE { ?x foaf:mbox ?y } WHERE { ?x foaf:mbox ?email . BIND(?email AS ?y) }";
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet cmds = parser.ParseFromString(command);
InMemoryDataset dataset = new InMemoryDataset(store, g.BaseUri);
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);
processor.ProcessCommandSet(cmds);
Assert.NotEqual(origTriples, g.Triples.Count);
Assert.False(g.GetTriplesWithPredicate(g.CreateUriNode(new Uri("http://xmlns.com/foaf/0.1/mbox"))).Any(), "Expected triples to have been deleted");
}
public void SparqlUpdateAddCommand2()
{
IGraph g = new Graph();
FileLoader.Load(g, "InferenceTest.ttl");
g.BaseUri = new Uri("http://example.org/source");
IGraph h = new Graph();
FileLoader.Load(h, "Turtle.ttl");
h.BaseUri = null;
TripleStore store = new TripleStore();
store.Add(g);
store.Add(h);
Assert.AreNotEqual(g, h, "Graphs should not be equal");
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet commands = parser.ParseFromString("ADD GRAPH <http://example.org/source> TO DEFAULT");
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(store);
processor.ProcessCommandSet(commands);
g = store[new Uri("http://example.org/source")];
h = store[null];
Assert.IsFalse(g.IsEmpty, "Source Graph should not be empty");
Assert.IsFalse(h.IsEmpty, "Destination Graph should not be empty");
Assert.IsTrue(h.HasSubGraph(g), "Destination Graph should have Source Graph as a subgraph");
}
private void TestDeleteDataThenInsertDataRollback()
{
ISparqlDataset dataset = this.GetNonEmptyDataset();
IGraph g = dataset.GetModifiableGraph(TestGraphUri);
g.Assert(new Triple(g.CreateUriNode(new Uri("ex:subj")), g.CreateUriNode(new Uri("ex:pred")), g.CreateUriNode(new Uri("ex:obj"))));
String updates = "DELETE DATA { GRAPH <" + TestGraphUri.ToString() + "> { <ex:subj> <ex:pred> <ex:obj> } }; INSERT DATA { GRAPH <" + TestGraphUri.ToString() + "> { <ex:subj> <ex:pred> <ex:obj> } }; 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[TestGraphUri].IsEmpty, "Graph should not be empty as the Discard() should reverse first the insert then the delete so the end results should be the triple still being in the Graph");
}
public void SparqlUpdateInsertCommand3()
{
SparqlParameterizedString command = new SparqlParameterizedString();
command.Namespaces.AddNamespace("rdf", new Uri(NamespaceMapper.RDF));
command.Namespaces.AddNamespace("rdfs", new Uri(NamespaceMapper.RDFS));
command.CommandText = "INSERT { ?s rdf:type ?class } USING NAMED <http://example.org/temp> WHERE { ?s a ?type . ?type rdfs:subClassOf+ ?class };";
command.CommandText += "INSERT { ?s ?property ?value } USING NAMED <http://example.org/temp> WHERE {?s ?p ?value . ?p rdfs:subPropertyOf+ ?property };";
command.CommandText += "INSERT { ?s rdf:type rdfs:Class } USING NAMED <http://example.org/temp> WHERE { ?s rdfs:subClassOf ?class };";
command.CommandText += "INSERT { ?s rdf:type rdf:Property } USING NAMED <http://example.org/temp> WHERE { ?s rdfs:subPropertyOf ?property };";
TripleStore store = new TripleStore();
Graph g = new Graph();
FileLoader.Load(g, "InferenceTest.ttl");
g.BaseUri = new Uri("http://example.org/temp");
store.Add(g);
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet cmds = parser.ParseFromString(command);
InMemoryDataset dataset = new InMemoryDataset(store);
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);
dataset.SetDefaultGraph((Uri)null);
processor.ProcessCommandSet(cmds);
IGraph def = store[null];
TestTools.ShowGraph(def);
Assert.IsTrue(def.IsEmpty, "Graph should be empty as the commands only used USING NAMED (so shouldn't have changed the dataset) and the Active Graph for the dataset was empty so there should have been nothing matched to generate insertions from");
}
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);
}
public void SparqlUpdateInsertDataCombination()
{
SparqlParameterizedString command = new SparqlParameterizedString();
command.Namespaces.AddNamespace("ex", new Uri("http://example.org/"));
command.CommandText = "INSERT 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();
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"));
IGraph def = dataset[null];
Assert.AreEqual(1, def.Triples.Count, "Should be 1 Triple in the Default Graph");
Assert.IsTrue(def.ContainsTriple(t), "Should have the inserted Triple in the Default Graph");
IGraph ex = dataset[new Uri("http://example.org/graph")];
Assert.AreEqual(1, ex.Triples.Count, "Should be 1 Triple in the Named Graph");
Assert.IsTrue(ex.ContainsTriple(t), "Should have the inserted Triple in the Named Graph");
}
public void SparqlUpdateCopyCommand3()
{
IGraph g = new Graph();
FileLoader.Load(g, "InferenceTest.ttl");
g.BaseUri = null;
IGraph h = new Graph();
FileLoader.Load(h, "Turtle.ttl");
h.BaseUri = new Uri("http://example.org/destination");
TripleStore store = new TripleStore();
store.Add(g);
store.Add(h);
Assert.AreNotEqual(g, h, "Graphs should not be equal");
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet commands = parser.ParseFromString("COPY DEFAULT TO GRAPH <http://example.org/destination>");
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(store);
processor.ProcessCommandSet(commands);
g = store[null];
h = store[new Uri("http://example.org/destination")];
Assert.IsFalse(g.IsEmpty, "Source Graph should not be empty");
Assert.IsFalse(h.IsEmpty, "Destination Graph should not be empty");
Assert.AreEqual(g, h, "Graphs should now be equal");
}
public void SparqlUpdateInsertWithBind()
{
TripleStore store = new TripleStore();
Graph g = new Graph();
g.LoadFromFile("rvesse.ttl");
store.Add(g);
int origTriples = g.Triples.Count;
SparqlParameterizedString command = new SparqlParameterizedString();
command.Namespaces.AddNamespace("foaf", new Uri("http://xmlns.com/foaf/0.1/"));
command.CommandText = "INSERT { ?x foaf:mbox_sha1sum ?hash } WHERE { ?x foaf:mbox ?email . BIND(SHA1(STR(?email)) AS ?hash) }";
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet cmds = parser.ParseFromString(command);
InMemoryDataset dataset = new InMemoryDataset(store, g.BaseUri);
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);
processor.ProcessCommandSet(cmds);
Assert.AreNotEqual(origTriples, g.Triples.Count, "Expected new triples to have been added");
Assert.IsTrue(g.GetTriplesWithPredicate(g.CreateUriNode(new Uri("http://xmlns.com/foaf/0.1/mbox_sha1sum"))).Any(), "Expected new triples to have been added");
}
public void SparqlUpdateDeleteWithFilter()
{
TripleStore store = new TripleStore();
Graph g = new Graph();
g.LoadFromFile("rvesse.ttl");
store.Add(g);
int origTriples = g.Triples.Count;
SparqlParameterizedString command = new SparqlParameterizedString();
command.Namespaces.AddNamespace("foaf", new Uri("http://xmlns.com/foaf/0.1/"));
command.CommandText = "DELETE { ?x foaf:mbox ?email } WHERE { ?x foaf:mbox ?email . FILTER(REGEX(STR(?email), 'dotnetrdf\\.org')) }";
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet cmds = parser.ParseFromString(command);
InMemoryDataset dataset = new InMemoryDataset(store, g.BaseUri);
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);
processor.ProcessCommandSet(cmds);
Assert.AreNotEqual(origTriples, g.Triples.Count, "Expected triples to have been deleted");
Assert.IsFalse(g.GetTriplesWithPredicate(g.CreateUriNode(new Uri("http://xmlns.com/foaf/0.1/mbox"))).Where(t => t.Object.ToString().Contains("dotnetrdf.org")).Any(), "Expected triples to have been deleted");
}
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");
}
private void TestUpdate(IInMemoryQueryableStore store, IGraph expected, String update)
{
SparqlUpdateCommandSet cmds = this._updateParser.ParseFromString(update);
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(store);
processor.ProcessCommandSet(cmds);
Assert.IsTrue(store.HasGraph(null), "Store should have a default unnamed Graph");
IGraph result = store.Graph(null);
NTriplesFormatter formatter = new NTriplesFormatter();
Console.WriteLine("Result Data");
foreach (Triple t in result.Triples)
{
Console.WriteLine(t.ToString(formatter));
}
Console.WriteLine();
Console.WriteLine("Expected Data");
foreach (Triple t in expected.Triples)
{
Console.WriteLine(t.ToString(formatter));
}
Console.WriteLine();
Assert.AreEqual(expected, result, "Graphs should be equal");
}
public void SparqlUpdateDeleteCommandWithNoMatchingGraph()
{
var dataset = new InMemoryDataset();
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 {} WHERE {}");
processor.ProcessCommandSet(cmdSet);
dataset.HasGraph(egGraph).Should().BeFalse();
}
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.IsTrue(dataset.HasGraph(TestGraphUri), "Graph should exist");
}
private void TestInsertDataThenDeleteDataCommit()
{
ISparqlDataset dataset = this.GetNonEmptyDataset();
String updates = "INSERT DATA { GRAPH <" + TestGraphUri.ToString() + "> { <ex:subj> <ex:pred> <ex:obj> } }; DELETE 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[TestGraphUri].IsEmpty, "Graph should be empty as the Flush() should persist first the insert then the delete");
}
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");
}
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");
}
public void SparqlUpdateInsertCommand2()
{
SparqlParameterizedString command = new SparqlParameterizedString();
command.Namespaces.AddNamespace("rdf", new Uri(NamespaceMapper.RDF));
command.Namespaces.AddNamespace("rdfs", new Uri(NamespaceMapper.RDFS));
command.CommandText = "INSERT { ?s rdf:type ?class } USING <http://example.org/temp> WHERE { ?s a ?type . ?type rdfs:subClassOf+ ?class };";
command.CommandText += "INSERT { ?s ?property ?value } USING <http://example.org/temp> WHERE {?s ?p ?value . ?p rdfs:subPropertyOf+ ?property };";
command.CommandText += "INSERT { ?s rdf:type rdfs:Class } USING <http://example.org/temp> WHERE { ?s rdfs:subClassOf ?class };";
command.CommandText += "INSERT { ?s rdf:type rdf:Property } USING <http://example.org/temp> WHERE { ?s rdfs:subPropertyOf ?property };";
TripleStore store = new TripleStore();
Graph g = new Graph();
FileLoader.Load(g, "InferenceTest.ttl");
g.BaseUri = new Uri("http://example.org/temp");
store.Add(g);
int origTriples = g.Triples.Count;
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet cmds = parser.ParseFromString(command);
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(store);
processor.ProcessCommandSet(cmds);
Assert.AreEqual(origTriples, g.Triples.Count, "Triples in input Graph shouldn't have changed as INSERTs should have gone to the default graph");
IGraph def = store[null];
TestTools.ShowGraph(def);
Console.WriteLine();
//Apply a RDFS reasoner over the original input and output it into another graph
//Should be equivalent to the default Graph
Graph h = new Graph();
RdfsReasoner reasoner = new RdfsReasoner();
reasoner.Apply(g, h);
TestTools.ShowGraph(h);
GraphDiffReport report = h.Difference(def);
if (!report.AreEqual)
{
TestTools.ShowDifferences(report);
Assert.IsTrue(report.RemovedTriples.Count() == 1, "Should have only 1 missing Triple (due to rdfs:domain inference which is hard to encode in an INSERT command)");
}
}
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");
}
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);
}
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");
}
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);
}
public void SparqlUpdateInsertCommand()
{
SparqlParameterizedString command = new SparqlParameterizedString();
command.Namespaces.AddNamespace("rdf", new Uri(NamespaceMapper.RDF));
command.Namespaces.AddNamespace("rdfs", new Uri(NamespaceMapper.RDFS));
command.CommandText = "INSERT { ?s rdf:type ?class } WHERE { ?s a ?type . ?type rdfs:subClassOf+ ?class };";
command.CommandText += "INSERT { ?s ?property ?value } WHERE {?s ?p ?value . ?p rdfs:subPropertyOf+ ?property };";
command.CommandText += "INSERT { ?s rdf:type rdfs:Class } WHERE { ?s rdfs:subClassOf ?class };";
command.CommandText += "INSERT { ?s rdf:type rdf:Property } WHERE { ?s rdfs:subPropertyOf ?property };";
TripleStore store = new TripleStore();
Graph g = new Graph();
FileLoader.Load(g, "InferenceTest.ttl");
g.Retract(g.Triples.Where(t => !t.IsGroundTriple).ToList());
g.BaseUri = null;
store.Add(g);
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet cmds = parser.ParseFromString(command);
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(store);
processor.ProcessCommandSet(cmds);
TestTools.ShowGraph(g);
Console.WriteLine();
//Now reload the test data and apply an RDFS reasoner over it
//This should give us a Graph equivalent to the one created by the previous INSERT commands
Graph h = new Graph();
FileLoader.Load(h, "InferenceTest.ttl");
h.Retract(h.Triples.Where(t => !t.IsGroundTriple).ToList());
RdfsReasoner reasoner = new RdfsReasoner();
reasoner.Apply(h);
GraphDiffReport diff = h.Difference(g);
if (!diff.AreEqual)
{
TestTools.ShowDifferences(diff);
}
Assert.AreEqual(h, g, "Graphs should be equal");
}
private void TestDeleteDataThenInsertDataCommit()
{
ISparqlDataset dataset = this.GetNonEmptyDataset();
IGraph g = dataset.GetModifiableGraph(TestGraphUri);
g.Assert(new Triple(g.CreateUriNode(new Uri("ex:subj")), g.CreateUriNode(new Uri("ex:pred")), g.CreateUriNode(new Uri("ex:obj"))));
dataset.Flush();
String updates = "DELETE DATA { GRAPH <" + TestGraphUri.ToString() + "> { <ex:subj> <ex:pred> <ex:obj> } }; 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.False(dataset[TestGraphUri].IsEmpty, "Graph should not be empty as the Flush() should persist first the delete then the insert so the end results should be the triple still being in the Graph");
}
public void SparqlUpdateInsertCommandWithNoMatchingGraph()
{
var dataset = new InMemoryDataset();
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 + "> INSERT {} WHERE {}");
processor.ProcessCommandSet(cmdSet);
dataset.HasGraph(egGraph).Should().BeFalse(); // No triples got added
cmdSet = new SparqlUpdateParser().ParseFromString(
"WITH <" + egGraph + "> INSERT { <http://example.org/s> <http://example.org/p> <http://example.org/o> } WHERE {}");
processor.ProcessCommandSet(cmdSet);
dataset.HasGraph(egGraph).Should().BeTrue(); // Triples got added
}
public void SparqlUpdateInsertWithGraphClause1()
{
Graph g = new Graph();
g.Assert(g.CreateUriNode(UriFactory.Create("http://subject")), g.CreateUriNode(UriFactory.Create("http://predicate")), g.CreateUriNode(UriFactory.Create("http://object")));
InMemoryDataset dataset = new InMemoryDataset(g);
String updates = "INSERT { GRAPH ?s { ?s ?p ?o } } WHERE { ?s ?p ?o }";
SparqlUpdateCommandSet commands = new SparqlUpdateParser().ParseFromString(updates);
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);
processor.ProcessCommandSet(commands);
Assert.Equal(2, dataset.GraphUris.Count());
Assert.True(dataset.HasGraph(UriFactory.Create("http://subject")));
}
public void SparqlUpdateWithDefaultQueryProcessor()
{
Graph g = new Graph();
g.LoadFromEmbeddedResource("VDS.RDF.Configuration.configuration.ttl");
g.BaseUri = null;
TripleStore store = new TripleStore();
store.Add(g);
InMemoryDataset dataset = new InMemoryDataset(store);
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet cmds = parser.ParseFromString("DELETE { ?s a ?type } WHERE { ?s a ?type }");
ISparqlUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);
processor.ProcessCommandSet(cmds);
}
public void SparqlUpdateChangesNotReflectedInOriginalGraph2()
{
//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 ] .");
TripleStore store = new TripleStore();
store.Add(sourceGraph);
ISparqlDataset dataset = new InMemoryDataset(store, sourceGraph.BaseUri);
// 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.True(ReferenceEquals(g, sourceGraph), "Result Graph should be the Source Graph");
Assert.Equal(2, sourceGraph.Triples.Count);
Assert.Equal(expectedGraph, sourceGraph);
}
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.Fail("Did not thrown a SparqlUpdateException as expected");
}
catch (SparqlUpdateException upEx)
{
TestTools.ReportError("Update Exception", upEx, false);
}
Assert.IsFalse(dataset.HasGraph(TestGraphUri), "Graph should not exist as the Discard() should cause it to be removed from the Dataset");
}
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");
}
private void TestInsertDataThenDeleteDataRollback()
{
ISparqlDataset dataset = this.GetNonEmptyDataset();
String updates = "INSERT DATA { GRAPH <" + TestGraphUri.ToString() + "> { <ex:subj> <ex:pred> <ex:obj> } }; DELETE DATA { GRAPH <" + TestGraphUri.ToString() + "> { <ex:subj> <ex:pred> <ex:obj> } }; 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[TestGraphUri].IsEmpty, "Graph should be empty as the Discard() should reverse first the delete then the insert");
}
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");
}
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");
}
public void SparqlUpdateTimeout()
{
String update = "CREATE GRAPH <http://example.org/1>; LOAD <http://www.dotnetrdf.org/configuration#>; CREATE GRAPH <http://example.org/2>";
SparqlUpdateCommandSet cmds = this._parser.ParseFromString(update);
cmds.Timeout = 1;
TripleStore store = new TripleStore();
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(store);
try
{
processor.ProcessCommandSet(cmds);
Assert.Fail("Expected a SparqlUpdateTimeoutException");
}
catch (SparqlUpdateTimeoutException timeoutEx)
{
TestTools.ReportError("Timeout", timeoutEx, false);
Console.WriteLine();
Console.WriteLine("Execution Time: " + cmds.UpdateExecutionTime.Value.ToString());
Assert.IsFalse(store.HasGraph(new Uri("http://example.org/1")), "Graph 1 should not exist");
Assert.IsFalse(store.HasGraph(new Uri("http://example.org/2")), "Graph 2 should not exist");
}
}
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.Fail("Expected SPARQL Update Exception was not thrown");
}
catch (SparqlUpdateException upEx)
{
TestTools.ReportError("Update Exception", upEx, false);
}
Assert.IsTrue(dataset.HasGraph(TestGraphUri), "Graph should not exist");
}
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.IsFalse(dataset.HasGraph(TestGraphUri), "Graph should not exist");
}
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.Fail("Did not thrown a SparqlUpdateException as expected");
}
catch (SparqlUpdateException upEx)
{
TestTools.ReportError("Update Exception", upEx, false);
}
Assert.IsTrue(dataset.HasGraph(TestGraphUri), "Graph should exist as the Discard() should ensure it was still in the Dataset");
}
public void SparqlDatasetDefaultGraphManagementWithUpdate3()
{
TripleStore store = new TripleStore();
Graph g = new Graph();
g.BaseUri = new Uri("http://example.org/graph");
store.Add(g);
Graph h = new Graph();
h.BaseUri = new Uri("http://example.org/someOtherGraph");
store.Add(h);
InMemoryDataset dataset = new InMemoryDataset(store, h.BaseUri);
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet cmds = parser.ParseFromString("LOAD <http://www.dotnetrdf.org/configuration#> INTO GRAPH <http://example.org/graph>; LOAD <http://www.dotnetrdf.org/configuration#> INTO GRAPH <http://example.org/someOtherGraph>");
processor.ProcessCommandSet(cmds);
Assert.IsFalse(g.IsEmpty, "First Graph should not be empty as should have been filled by the first LOAD command");
Assert.IsFalse(h.IsEmpty, "Second Graph should not be empty as should not have been filled by the second LOAD command");
Assert.AreEqual(g, h, "Graphs should be equal");
}
/// <summary>
/// Tries to load a SPARQL Update based on information from the Configuration Graph
/// </summary>
/// <param name="g">Configuration Graph</param>
/// <param name="objNode">Object Node</param>
/// <param name="targetType">Target Type</param>
/// <param name="obj">Output Object</param>
/// <returns></returns>
public bool TryLoadObject(IGraph g, INode objNode, Type targetType, out object obj)
{
obj = null;
ISparqlUpdateProcessor processor = null;
INode storeObj;
Object temp;
switch (targetType.FullName)
{
case LeviathanUpdateProcessor:
INode datasetObj = ConfigurationLoader.GetConfigurationNode(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyUsingDataset));
if (datasetObj != null)
{
temp = ConfigurationLoader.LoadObject(g, datasetObj);
if (temp is ISparqlDataset)
{
processor = new LeviathanUpdateProcessor((ISparqlDataset)temp);
}
else
{
throw new DotNetRdfConfigurationException("Unable to load the Leviathan Update Processor identified by the Node '" + objNode.ToString() + "' as the value given for the dnr:usingDataset property points to an Object that cannot be loaded as an object which implements the ISparqlDataset interface");
}
}
else
{
storeObj = ConfigurationLoader.GetConfigurationNode(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyUsingStore));
if (storeObj == null) return false;
temp = ConfigurationLoader.LoadObject(g, storeObj);
if (temp is IInMemoryQueryableStore)
{
processor = new LeviathanUpdateProcessor((IInMemoryQueryableStore)temp);
}
else
{
throw new DotNetRdfConfigurationException("Unable to load the Leviathan Update Processor identified by the Node '" + objNode.ToString() + "' as the value given for the dnr:usingStore property points to an Object that cannot be loaded as an object which implements the IInMemoryQueryableStore interface");
}
}
break;
case SimpleUpdateProcessor:
storeObj = ConfigurationLoader.GetConfigurationNode(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyUsingStore));
if (storeObj == null) return false;
temp = ConfigurationLoader.LoadObject(g, storeObj);
if (temp is IUpdateableTripleStore)
{
processor = new SimpleUpdateProcessor((IUpdateableTripleStore)temp);
}
else
{
throw new DotNetRdfConfigurationException("Unable to load the Simple Update Processor identified by the Node '" + objNode.ToString() + "' as the value given for the dnr:usingStore property points to an Object that cannot be loaded as an object which implements the IUpdateableTripleStore interface");
}
break;
#if !NO_STORAGE
case GenericUpdateProcessor:
INode managerObj = ConfigurationLoader.GetConfigurationNode(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyGenericManager));
if (managerObj == null) return false;
temp = ConfigurationLoader.LoadObject(g, managerObj);
if (temp is IGenericIOManager)
{
processor = new GenericUpdateProcessor((IGenericIOManager)temp);
}
else
{
throw new DotNetRdfConfigurationException("Unable to load the Generic Update Processor identified by the Node '" + objNode.ToString() + "' as the value given for the dnr:genericManager property points to an Object that cannot be loaded as an object which implements the IGenericIOManager interface");
}
break;
#endif
}
obj = processor;
return (processor != null);
}
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.IsTrue(dataset.HasGraph(TestGraphUri), "Graph should exist");
Assert.AreEqual(1, dataset[TestGraphUri].Triples.Count, "Expected 1 Triple");
}
/// <inheritdoc />
void IUpdateableTripleStore.ExecuteUpdate(SparqlUpdateCommandSet updates)
{
lock (Locker)
{
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(this);
processor.ProcessCommandSet(updates);
Write();
}
}
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 void TestDeleteDataThenInsertDataRollback()
{
ISparqlDataset dataset = this.GetNonEmptyDataset();
IGraph g = dataset.GetModifiableGraph(TestGraphUri);
g.Assert(new Triple(g.CreateUriNode(new Uri("ex:subj")), g.CreateUriNode(new Uri("ex:pred")), g.CreateUriNode(new Uri("ex:obj"))));
String updates = "DELETE DATA { GRAPH <" + TestGraphUri.ToString() + "> { <ex:subj> <ex:pred> <ex:obj> } }; INSERT DATA { GRAPH <" + TestGraphUri.ToString() + "> { <ex:subj> <ex:pred> <ex:obj> } }; CREATE GRAPH <" + TestGraphUri.ToString() + ">";
SparqlUpdateCommandSet cmds = this._parser.ParseFromString(updates);
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);
try
{
processor.ProcessCommandSet(cmds);
Assert.Fail("Did not thrown a SparqlUpdateException as expected");
}
catch (SparqlUpdateException upEx)
{
TestTools.ReportError("Update Exception", upEx, false);
}
Assert.IsFalse(dataset[TestGraphUri].IsEmpty, "Graph should not be empty as the Discard() should reverse first the insert then the delete so the end results should be the triple still being in the Graph");
}
private void TestDeleteDataThenInsertDataCommit()
{
ISparqlDataset dataset = this.GetNonEmptyDataset();
IGraph g = dataset.GetModifiableGraph(TestGraphUri);
g.Assert(new Triple(g.CreateUriNode(new Uri("ex:subj")), g.CreateUriNode(new Uri("ex:pred")), g.CreateUriNode(new Uri("ex:obj"))));
dataset.Flush();
String updates = "DELETE DATA { GRAPH <" + TestGraphUri.ToString() + "> { <ex:subj> <ex:pred> <ex:obj> } }; 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.IsFalse(dataset[TestGraphUri].IsEmpty, "Graph should not be empty as the Flush() should persist first the delete then the insert so the end results should be the triple still being in the Graph");
}
private void TestInsertDataThenDeleteDataRollback()
{
ISparqlDataset dataset = this.GetNonEmptyDataset();
String updates = "INSERT DATA { GRAPH <" + TestGraphUri.ToString() + "> { <ex:subj> <ex:pred> <ex:obj> } }; DELETE DATA { GRAPH <" + TestGraphUri.ToString() + "> { <ex:subj> <ex:pred> <ex:obj> } }; CREATE GRAPH <" + TestGraphUri.ToString() + ">";
SparqlUpdateCommandSet cmds = this._parser.ParseFromString(updates);
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);
try
{
processor.ProcessCommandSet(cmds);
Assert.Fail("Did not thrown a SparqlUpdateException as expected");
}
catch (SparqlUpdateException upEx)
{
TestTools.ReportError("Update Exception", upEx, false);
}
Assert.IsTrue(dataset[TestGraphUri].IsEmpty, "Graph should be empty as the Discard() should reverse first the delete then the insert");
}
public void SparqlUpdateAddCommand()
{
IGraph g = new Graph();
FileLoader.Load(g, "InferenceTest.ttl");
g.BaseUri = new Uri("http://example.org/source");
IGraph h = new Graph();
FileLoader.Load(h, "Turtle.ttl");
h.BaseUri = new Uri("http://example.org/destination");
TripleStore store = new TripleStore();
store.Add(g);
store.Add(h);
Assert.AreNotEqual(g, h, "Graphs should not be equal");
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet commands = parser.ParseFromString("ADD GRAPH <http://example.org/source> TO GRAPH <http://example.org/destination>");
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(store);
processor.ProcessCommandSet(commands);
g = store.Graph(new Uri("http://example.org/source"));
h = store.Graph(new Uri("http://example.org/destination"));
Assert.IsFalse(g.IsEmpty, "Source Graph should not be empty");
Assert.IsFalse(h.IsEmpty, "Destination Graph should not be empty");
Assert.IsTrue(h.HasSubGraph(g), "Destination Graph should have Source Graph as a subgraph");
}
public void SparqlDatasetDefaultGraphManagementWithUpdate()
{
TripleStore store = new TripleStore();
Graph g = new Graph();
store.Add(g);
Graph h = new Graph();
h.BaseUri = new Uri("http://example.org/someOtherGraph");
store.Add(h);
InMemoryDataset dataset = new InMemoryDataset(store, h.BaseUri);
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet cmds = parser.ParseFromString("LOAD <http://www.dotnetrdf.org/configuration#>");
processor.ProcessCommandSet(cmds);
Assert.IsTrue(g.IsEmpty, "Graph with null URI (normally the default Graph) should be empty as the Default Graph for the Dataset should have been a named Graph so this Graph should not have been filled by the LOAD Command");
Assert.IsFalse(h.IsEmpty, "Graph with name should be non-empty as it should have been the Default Graph for the Dataset and so filled by the LOAD Command");
}
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.Fail("Did not throw a SparqlUpdateException as expected");
}
catch (SparqlUpdateException upEx)
{
TestTools.ReportError("Update Exception", upEx, false);
}
Assert.IsTrue(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.Fail("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, false);
}
//Now discard
processor.Discard();
Assert.IsFalse(dataset.HasGraph(TestGraphUri), "Graph should not exist as the Discard() should cause it to be removed from the Dataset");
}
public void SparqlDatasetDefaultGraphManagementWithUpdate5()
{
TripleStore store = new TripleStore();
Graph g = new Graph();
g.BaseUri = new Uri("http://example.org/graph");
store.Add(g);
Graph h = new Graph();
h.BaseUri = new Uri("http://example.org/someOtherGraph");
store.Add(h);
InMemoryDataset dataset = new InMemoryDataset(store, h.BaseUri);
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet cmds = parser.ParseFromString("LOAD <http://www.dotnetrdf.org/configuration#>; WITH <http://example.org/graph> INSERT { ?s a ?type } USING <http://example.org/someOtherGraph> WHERE { ?s a ?type }; DELETE WHERE { ?s a ?type }");
processor.ProcessCommandSet(cmds);
Assert.IsFalse(g.IsEmpty, "First Graph should not be empty as should have been filled by the INSERT command");
Assert.IsFalse(h.IsEmpty, "Second Graph should not be empty as should not have been filled by the LOAD command");
Assert.IsFalse(h.HasSubGraph(g), "First Graph should not be a subgraph of the Second Graph as the DELETE should have eliminated the subgraph relationship");
}
public void SparqlUpdateInsertCommand4()
{
SparqlParameterizedString command = new SparqlParameterizedString();
command.Namespaces.AddNamespace("rdf", new Uri(NamespaceMapper.RDF));
command.Namespaces.AddNamespace("rdfs", new Uri(NamespaceMapper.RDFS));
command.CommandText = "INSERT { ?s rdf:type ?class } USING NAMED <http://example.org/temp> WHERE { GRAPH ?g { ?s a ?type . ?type rdfs:subClassOf+ ?class } };";
command.CommandText += "INSERT { ?s ?property ?value } USING NAMED <http://example.org/temp> WHERE { GRAPH ?g { ?s ?p ?value . ?p rdfs:subPropertyOf+ ?property } };";
command.CommandText += "INSERT { ?s rdf:type rdfs:Class } USING NAMED <http://example.org/temp> WHERE { GRAPH ?g { ?s rdfs:subClassOf ?class } };";
command.CommandText += "INSERT { ?s rdf:type rdf:Property } USING NAMED <http://example.org/temp> WHERE { GRAPH ?g { ?s rdfs:subPropertyOf ?property } };";
TripleStore store = new TripleStore();
Graph g = new Graph();
FileLoader.Load(g, "InferenceTest.ttl");
g.BaseUri = new Uri("http://example.org/temp");
store.Add(g);
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet cmds = parser.ParseFromString(command);
InMemoryDataset dataset = new InMemoryDataset(store);
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);
dataset.SetDefaultGraph(store.Graph(null));
processor.ProcessCommandSet(cmds);
IGraph def = store.Graph(null);
TestTools.ShowGraph(def);
//Apply a RDFS reasoner over the original input and output it into another graph
//Should be equivalent to the default Graph
Graph h = new Graph();
RdfsReasoner reasoner = new RdfsReasoner();
reasoner.Apply(g, h);
TestTools.ShowGraph(h);
GraphDiffReport report = h.Difference(def);
if (!report.AreEqual)
{
TestTools.ShowDifferences(report);
Assert.IsTrue(report.RemovedTriples.Count() == 1, "Should have only 1 missing Triple (due to rdfs:domain inference which is hard to encode in an INSERT command)");
}
}
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.IsFalse(q1.UsesDefaultDataset, "Query 1 should not be thread safe");
Assert.IsFalse(q2.UsesDefaultDataset, "Query 2 should not be thread safe");
Assert.IsFalse(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.Functions.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.AreEqual(g, gQuery, "Query 1 Result not as expected");
IGraph hQuery = d.EndInvoke(r2);
Assert.AreEqual(h, hQuery, "Query 2 Result not as expected");
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.IsFalse(iQuery.IsEmpty, "Graph should not be empty as INSERT DATA should have inserted a Triple");
Assert.AreNotEqual(new Graph(), iQuery, "Graphs should not be equal");
Assert.AreNotEqual(g, h, "Graphs should not be different");
}
public void SparqlUpdateInsertCommand3()
{
SparqlParameterizedString command = new SparqlParameterizedString();
command.Namespaces.AddNamespace("rdf", new Uri(NamespaceMapper.RDF));
command.Namespaces.AddNamespace("rdfs", new Uri(NamespaceMapper.RDFS));
command.CommandText = "INSERT { ?s rdf:type ?class } USING NAMED <http://example.org/temp> WHERE { ?s a ?type . ?type rdfs:subClassOf+ ?class };";
command.CommandText += "INSERT { ?s ?property ?value } USING NAMED <http://example.org/temp> WHERE {?s ?p ?value . ?p rdfs:subPropertyOf+ ?property };";
command.CommandText += "INSERT { ?s rdf:type rdfs:Class } USING NAMED <http://example.org/temp> WHERE { ?s rdfs:subClassOf ?class };";
command.CommandText += "INSERT { ?s rdf:type rdf:Property } USING NAMED <http://example.org/temp> WHERE { ?s rdfs:subPropertyOf ?property };";
TripleStore store = new TripleStore();
Graph g = new Graph();
FileLoader.Load(g, "InferenceTest.ttl");
g.BaseUri = new Uri("http://example.org/temp");
store.Add(g);
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet cmds = parser.ParseFromString(command);
InMemoryDataset dataset = new InMemoryDataset(store);
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);
dataset.SetDefaultGraph(store.Graph(null));
processor.ProcessCommandSet(cmds);
IGraph def = store.Graph(null);
TestTools.ShowGraph(def);
Assert.IsTrue(def.IsEmpty, "Graph should be empty as the commands only used USING NAMED (so shouldn't have changed the dataset) and the Active Graph for the dataset was empty so there should have been nothing matched to generate insertions from");
}
public void SparqlUpdateInsertCommand()
{
SparqlParameterizedString command = new SparqlParameterizedString();
command.Namespaces.AddNamespace("rdf", new Uri(NamespaceMapper.RDF));
command.Namespaces.AddNamespace("rdfs", new Uri(NamespaceMapper.RDFS));
command.CommandText = "INSERT { ?s rdf:type ?class } WHERE { ?s a ?type . ?type rdfs:subClassOf+ ?class };";
command.CommandText += "INSERT { ?s ?property ?value } WHERE {?s ?p ?value . ?p rdfs:subPropertyOf+ ?property };";
command.CommandText += "INSERT { ?s rdf:type rdfs:Class } WHERE { ?s rdfs:subClassOf ?class };";
command.CommandText += "INSERT { ?s rdf:type rdf:Property } WHERE { ?s rdfs:subPropertyOf ?property };";
TripleStore store = new TripleStore();
Graph g = new Graph();
FileLoader.Load(g, "InferenceTest.ttl");
g.Retract(g.Triples.Where(t => !t.IsGroundTriple));
g.BaseUri = null;
store.Add(g);
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet cmds = parser.ParseFromString(command);
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(store);
processor.ProcessCommandSet(cmds);
TestTools.ShowGraph(g);
Console.WriteLine();
//Now reload the test data and apply an RDFS reasoner over it
//This should give us a Graph equivalent to the one created by the previous INSERT commands
Graph h = new Graph();
FileLoader.Load(h, "InferenceTest.ttl");
h.Retract(h.Triples.Where(t => !t.IsGroundTriple));
RdfsReasoner reasoner = new RdfsReasoner();
reasoner.Apply(h);
GraphDiffReport diff = h.Difference(g);
if (!diff.AreEqual)
{
TestTools.ShowDifferences(diff);
}
Assert.AreEqual(h, g, "Graphs should be equal");
}
public void SparqlUpdateMoveCommand3()
{
IGraph g = new Graph();
FileLoader.Load(g, "InferenceTest.ttl");
g.BaseUri = null;
IGraph h = new Graph();
FileLoader.Load(h, "Turtle.ttl");
h.BaseUri = new Uri("http://example.org/destination");
TripleStore store = new TripleStore();
store.Add(g);
store.Add(h);
Assert.AreNotEqual(g, h, "Graphs should not be equal");
SparqlUpdateParser parser = new SparqlUpdateParser();
SparqlUpdateCommandSet commands = parser.ParseFromString("MOVE DEFAULT TO GRAPH <http://example.org/destination>");
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(store);
processor.ProcessCommandSet(commands);
g = store.HasGraph(null) ? store.Graph(null) : null;
h = store.Graph(new Uri("http://example.org/destination"));
Assert.IsFalse(h.IsEmpty, "Destination Graph should not be empty");
Assert.IsFalse(g == null, "Default Graph should still exist");
Assert.IsTrue(g.IsEmpty, "Source Graph (the Default Graph) should be Empty");
Graph orig = new Graph();
FileLoader.Load(orig, "InferenceTest.ttl");
Assert.AreEqual(orig, h, "Destination Graph should be equal to the original contents of the Source Graph");
}
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.IsFalse(dataset.HasGraph(TestGraphUri), "Graph should not exist as the Flush() should cause it to be removed from the Dataset");
}
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.IsTrue(dataset.HasGraph(TestGraphUri), "Graph should exist");
}
/// <summary>
/// Applies SPARQL Updates to the Store
/// </summary>
/// <param name="sparqlUpdate">SPARQL Update</param>
public void Update(String sparqlUpdate)
{
if (this._updateParser == null) this._updateParser = new SparqlUpdateParser();
SparqlUpdateCommandSet cmds = this._updateParser.ParseFromString(sparqlUpdate);
if (this._updateProcessor == null) this._updateProcessor = new LeviathanUpdateProcessor(this._dataset);
this._updateProcessor.ProcessCommandSet(cmds);
}
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.Fail("Did not thrown a SparqlUpdateException as expected");
}
catch (SparqlUpdateException upEx)
{
TestTools.ReportError("Update Exception", upEx, false);
}
Assert.IsTrue(dataset.HasGraph(TestGraphUri), "Graph should not exist as the Discard() should cause it to be removed from the Dataset");
Assert.IsTrue(dataset[TestGraphUri].IsEmpty, "Graph should be empty as the Discard() should have reversed the INSERT DATA");
}
public void SparqlDatasetListGraphs()
{
InMemoryDataset dataset = new InMemoryDataset(new TripleStore());
LeviathanUpdateProcessor processor = new LeviathanUpdateProcessor(dataset);
Assert.IsTrue(dataset.GraphUris.Count() == 1, "Should be 1 Graph as the Update Processor should ensure a Default unnamed Graph exists");
}
private void TestInsertDataThenDeleteDataCommit()
{
ISparqlDataset dataset = this.GetNonEmptyDataset();
String updates = "INSERT DATA { GRAPH <" + TestGraphUri.ToString() + "> { <ex:subj> <ex:pred> <ex:obj> } }; DELETE 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.IsTrue(dataset[TestGraphUri].IsEmpty, "Graph should be empty as the Flush() should persist first the insert then the delete");
}
