private void TestAddGraphDiscarded(IStorageProvider manager)
{
this.EnsureTestDataset(manager);
PersistentTripleStore store = new PersistentTripleStore(manager);
try
{
Graph g = new Graph();
g.BaseUri = new Uri("http://example.org/persistence/graphs/added/discarded");
this.EnsureGraphDeleted(manager, g.BaseUri);
g.Assert(g.CreateUriNode("rdf:subject"), g.CreateUriNode("rdf:predicate"), g.CreateUriNode("rdf:object"));
store.Add(g);
Assert.True(store.HasGraph(g.BaseUri), "Newly added graph should exist in in-memory view of store");
Assert.False(manager.ListGraphs().Contains(g.BaseUri), "Newly added graph should not yet exist in underlying store");
store.Discard();
Graph h = new Graph();
try
{
manager.LoadGraph(h, g.BaseUri);
}
catch
{
//No catch needed
}
Assert.True(h.IsEmpty, "After Discard() is called a graph may exist in the underlying store but it MUST be empty");
}
finally
{
store.Dispose();
}
}
private void TestRemoveGraphFlushed(IStorageProvider manager)
{
this.EnsureTestDataset(manager);
PersistentTripleStore store = new PersistentTripleStore(manager);
try
{
Uri toRemove = new Uri(TestGraphUri1);
Assert.True(store.HasGraph(toRemove), "In-memory view should contain the Graph we wish to remove");
store.Remove(toRemove);
Assert.False(store.HasGraph(toRemove), "In-memory view should no longer contain the Graph we removed prior to the Flush/Discard operation");
store.Flush();
Assert.False(store.HasGraph(toRemove), "In-Memory view should no longer contain the Graph we removed after Flushing");
AnyHandler handler = new AnyHandler();
try
{
manager.LoadGraph(handler, toRemove);
}
catch
{
}
Assert.False(handler.Any, "Attempting to load Graph from underlying store should return nothing after the Flush() operation");
}
finally
{
store.Dispose();
}
}
private void TestDumpStorePrimed(IStorageProvider manager)
{
this.EnsureTestDataset(manager);
PersistentTripleStore store = new PersistentTripleStore(manager);
try
{
// First prime the persistent store by loading a bunch of stuff
Assert.True(store.HasGraph(new Uri(TestGraphUri1)), "URI 1 should return true for HasGraph()");
Assert.True(store.Graphs.Contains(new Uri(TestGraphUri1)), "URI 1 should return true for Graphs.Contains()");
Assert.True(store.HasGraph(new Uri(TestGraphUri2)), "URI 2 should return true for HasGraph()");
Assert.True(store.Graphs.Contains(new Uri(TestGraphUri2)), "URI 2 should return true for Graphs.Contains()");
Assert.True(store.HasGraph(new Uri(TestGraphUri3)), "URI 3 should return true for HasGraph()");
Assert.True(store.Graphs.Contains(new Uri(TestGraphUri3)), "URI 3 should return true for Graphs.Contains()");
Uri noSuchThing = new Uri("http://example.org/persistence/graphs/noSuchGraph");
Assert.False(store.HasGraph(noSuchThing), "Bad URI should return false for HasGraph()");
Assert.False(store.Graphs.Contains(noSuchThing), "Bad URI should return false for Graphs.Contains()");
// Then try and dump
StringWriter strWriter = new StringWriter();
TriGWriter writer = new TriGWriter();
writer.UseMultiThreadedWriting = false;
writer.Save(store, strWriter);
Console.WriteLine("TriG output:");
Console.WriteLine(strWriter.ToString());
Assert.False(String.IsNullOrEmpty(strWriter.ToString()));
}
finally
{
store.Dispose();
}
}
private void TestAddTriplesDiscarded(IStorageProvider manager)
{
this.EnsureGraphDeleted(manager, new Uri(TestGraphUri1));
this.EnsureTestDataset(manager);
PersistentTripleStore store = new PersistentTripleStore(manager);
try
{
IGraph g = store[new Uri(TestGraphUri1)];
Triple toAdd = new Triple(g.CreateUriNode(new Uri("http://example.org/subject")), g.CreateUriNode(new Uri("http://example.org/predicate")), g.CreateUriNode(new Uri("http://example.org/object")));
g.Assert(toAdd);
Assert.True(g.ContainsTriple(toAdd), "Added triple should be present in in-memory view prior to Flush/Discard");
Graph h = new Graph();
manager.LoadGraph(h, g.BaseUri);
Assert.False(h.ContainsTriple(toAdd), "Added triple should not be present in underlying store prior to Flush/Discard");
store.Discard();
Assert.False(g.ContainsTriple(toAdd), "Added triple should not be present in in-memory view after Discard");
h = new Graph();
manager.LoadGraph(h, g.BaseUri);
Assert.False(h.ContainsTriple(toAdd), "Added triple should not be present in underlying store after Discard");
}
finally
{
store.Dispose();
}
}
private void TestRemoveTriplesDiscarded(IStorageProvider manager)
{
this.EnsureTestDataset(manager);
PersistentTripleStore store = new PersistentTripleStore(manager);
try
{
IGraph g = store[new Uri(TestGraphUri1)];
INode rdfType = g.CreateUriNode(new Uri(NamespaceMapper.RDF + "type"));
g.Retract(g.GetTriplesWithPredicate(rdfType).ToList());
Assert.False(g.GetTriplesWithPredicate(rdfType).Any(), "Removed triples should not be present in in-memory view prior to Flush/Discard");
Graph h = new Graph();
manager.LoadGraph(h, g.BaseUri);
Assert.True(h.GetTriplesWithPredicate(rdfType).Any(), "Removed triples should still be present in underlying store prior to Flush/Discard");
store.Discard();
Assert.True(g.GetTriplesWithPredicate(rdfType).Any(), "Removed triples should now be present in in-memory view after Discard");
h = new Graph();
manager.LoadGraph(h, g.BaseUri);
Assert.True(h.GetTriplesWithPredicate(rdfType).Any(), "Removed triples should still be present in underlying store after Discard");
}
finally
{
store.Dispose();
}
}
private void TestRemoveThenAddGraphDiscarded(IStorageProvider manager)
{
this.EnsureTestDataset(manager);
PersistentTripleStore store = new PersistentTripleStore(manager);
try
{
Uri toRemove = new Uri(TestGraphUri1);
IGraph g = store[toRemove];
Assert.True(store.HasGraph(toRemove), "In-memory view should contain the Graph we wish to remove");
store.Remove(toRemove);
Assert.False(store.HasGraph(toRemove), "In-memory view should no longer contain the Graph we removed prior to the Flush/Discard operation");
store.Add(g);
Assert.True(store.HasGraph(toRemove), "In-memory should now contain the Graph we added back");
store.Discard();
Assert.True(store.HasGraph(toRemove), "In-Memory view should still contain the Graph we removed and added back regardless as we Discarded that change");
AnyHandler handler = new AnyHandler();
manager.LoadGraph(handler, toRemove);
Assert.True(handler.Any, "Attempting to load Graph from underlying store should return something as the Discard() prevented the removal and add back being persisted");
}
finally
{
store.Dispose();
}
}
private void TestRemoveThenAddGraphFlushed(IStorageProvider manager)
{
this.EnsureTestDataset(manager);
PersistentTripleStore store = new PersistentTripleStore(manager);
try
{
Uri toRemove = new Uri(TestGraphUri1);
IGraph g = store[toRemove];
Assert.True(store.HasGraph(toRemove), "In-memory view should contain the Graph we wish to remove");
store.Remove(toRemove);
Assert.False(store.HasGraph(toRemove), "In-memory view should no longer contain the Graph we removed prior to the Flush/Discard operation");
store.Add(g);
Assert.True(store.HasGraph(toRemove), "In-memory should now contain the Graph we added back");
store.Flush();
Assert.True(store.HasGraph(toRemove), "In-Memory view should still contain the Graph we added back after Flushing");
AnyHandler handler = new AnyHandler();
manager.LoadGraph(handler, toRemove);
Assert.True(handler.Any, "Attempting to load Graph from underlying store should return something after the Flush() operation since we didn't remove the graph in the end");
}
finally
{
store.Dispose();
}
}
public void Init()
{
_allegroGraphConnector = new AllegroGraphConnector(_agConnData.Url, _agConnData.StoreId, _agConnData.User, _agConnData.Pass);
_repository = new PersistentTripleStore(_allegroGraphConnector);
_rdf4jMapper = new DotNetRdfMapper();
_logger.LogInformation("[CONFIG] The triple store repository configured correctly.");
}
private void TestUpdate(IStorageProvider manager)
{
this.EnsureTestDataset(manager);
Skip.IfNot(TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteParsing),
"Test Config marks Remote Parsing as unavailable, test cannot be run");
Uri updateUri = new Uri("http://example.org/persistence/update/temp");
this.EnsureGraphDeleted(manager, updateUri);
PersistentTripleStore store = new PersistentTripleStore(manager);
try
{
Assert.False(store.HasGraph(updateUri), "Prior to SPARQL Update our target graph should not exist using HasGraph()");
Assert.False(store.Graphs.Contains(updateUri), "Prior to SPARQL Update out target graph should not exist using Graphs.Contains()");
Assert.False(manager.ListGraphs().Contains(updateUri), "Prior to SPARQL Update our target graph should not exist in the underlying store");
store.ExecuteUpdate("LOAD <http://dbpedia.org/resource/Ilkeston> INTO GRAPH <" + updateUri.ToString() + ">");
Assert.True(store.HasGraph(updateUri), "SPARQL Update should have loaded into our target graph so that HasGraph() returns true");
Assert.True(store.Graphs.Contains(updateUri), "SPARQL Update should have loaded into out target graph so that Graphs.Contains() returns true");
//Note that SPARQL Updates go directly to the underlying store so the change is persisted immediately
Assert.True(manager.ListGraphs().Contains(updateUri), "SPARQL Update should loaded into our target graph directly in the underlying store");
}
finally
{
store.Dispose();
}
}
private void TestAddThenRemoveGraphDiscarded(IStorageProvider manager)
{
this.EnsureTestDataset(manager);
PersistentTripleStore store = new PersistentTripleStore(manager);
try
{
Graph g = new Graph();
g.BaseUri = new Uri("http://example.org/persistence/graphs/added/discarded");
this.EnsureGraphDeleted(manager, g.BaseUri);
g.Assert(g.CreateUriNode("rdf:subject"), g.CreateUriNode("rdf:predicate"), g.CreateUriNode("rdf:object"));
store.Add(g);
Assert.True(store.HasGraph(g.BaseUri), "Newly added graph should exist in in-memory view of store");
Assert.False(manager.ListGraphs().Contains(g.BaseUri), "Newly added graph should not yet exist in underlying store");
store.Remove(g.BaseUri);
Assert.False(store.HasGraph(g.BaseUri), "Graph then removed before Flush/Discard() should no longer exist in in-memory view of store");
Assert.False(manager.ListGraphs().Contains(g.BaseUri), "Graph then removed should still not exist in underlying store");
store.Discard();
Assert.False(store.HasGraph(g.BaseUri), "After Discard() is called graph should not exist in in-memory view of store");
Assert.False(manager.ListGraphs().Contains(g.BaseUri), "After Discard() is called added then removed graph should not exist in underlying store");
}
finally
{
store.Dispose();
}
}
public SelectQueries()
{
sparqlUtilities = new SparqlUtilities();
FusekiConnector fuseki = new FusekiConnector(sparqlUtilities.GraphPath);
store = new PersistentTripleStore(fuseki);
}
public void SparqlViewNativeAllegroGraph()
{
AllegroGraphConnector agraph = AllegroGraphTests.GetConnection();
PersistentTripleStore store = new PersistentTripleStore(agraph);
//Load a Graph into the Store to ensure there is some data for the view to retrieve
Graph g = new Graph();
FileLoader.Load(g, "resources\\InferenceTest.ttl");
agraph.SaveGraph(g);
//Create the SPARQL View
NativeSparqlView view = new NativeSparqlView("CONSTRUCT { ?s ?p ?o } WHERE { GRAPH ?g { ?s ?p ?o . FILTER(IsLiteral(?o)) } }", store);
Console.WriteLine("SPARQL View Populated");
TestTools.ShowGraph(view);
Console.WriteLine();
}
private void TestUpdateUnsynced(IStorageProvider manager)
{
this.EnsureTestDataset(manager);
PersistentTripleStore store = new PersistentTripleStore(manager);
try
{
store.Remove(new Uri(TestGraphUri1));
store.ExecuteUpdate("LOAD <http://dbpedia.org/resource/Ilkeston>");
}
finally
{
store.Discard();
store.Dispose();
}
}
private void TestQueryUnsynced(IStorageProvider manager)
{
this.EnsureTestDataset(manager);
PersistentTripleStore store = new PersistentTripleStore(manager);
try
{
store.Remove(new Uri(TestGraphUri1));
store.ExecuteQuery("SELECT * WHERE { ?s ?p ?o }");
}
finally
{
store.Discard();
store.Dispose();
}
}
private void TestUpdateUnsynced(IStorageProvider manager)
{
this.EnsureTestDataset(manager);
Skip.IfNot(TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteParsing),
"Test Config marks Remote Parsing as unavailable, test cannot be run");
PersistentTripleStore store = new PersistentTripleStore(manager);
try
{
store.Remove(new Uri(TestGraphUri1));
store.ExecuteUpdate("LOAD <http://dbpedia.org/resource/Ilkeston>");
}
finally
{
store.Discard();
store.Dispose();
}
}
private void TestQueryDescribe(IStorageProvider manager, String query)
{
this.EnsureTestDataset(manager);
PersistentTripleStore store = new PersistentTripleStore(manager);
try
{
IGraph g = store.ExecuteQuery(query) as IGraph;
if (g == null)
{
Assert.True(false, "Did not get a Graph as expected");
}
TestTools.ShowResults(g);
}
finally
{
store.Dispose();
}
}
private void TestQuerySelect(IStorageProvider manager, String query)
{
this.EnsureTestDataset(manager);
PersistentTripleStore store = new PersistentTripleStore(manager);
try
{
SparqlResultSet results = store.ExecuteQuery(query) as SparqlResultSet;
if (results == null)
{
Assert.True(false, "Did not get a SPARQL Result Set as expected");
}
TestTools.ShowResults(results);
}
finally
{
store.Dispose();
}
}
private void TestGetGraph(IStorageProvider manager)
{
this.EnsureTestDataset(manager);
PersistentTripleStore store = new PersistentTripleStore(manager);
try
{
Graph aExpected = new Graph();
aExpected.LoadFromEmbeddedResource("VDS.RDF.Configuration.configuration.ttl");
aExpected.Retract(aExpected.Triples.Where(t => !t.IsGroundTriple).ToList());
aExpected.BaseUri = new Uri(TestGraphUri1);
IGraph aActual = store[aExpected.BaseUri];
Assert.Equal(aExpected, aActual);
aActual = store.Graphs[aExpected.BaseUri];
Assert.Equal(aExpected, aActual);
Graph bExpected = new Graph();
bExpected.LoadFromFile("resources\\InferenceTest.ttl");
bExpected.Retract(bExpected.Triples.Where(t => !t.IsGroundTriple).ToList());
bExpected.BaseUri = new Uri(TestGraphUri2);
IGraph bActual = store[bExpected.BaseUri];
Assert.Equal(bExpected, bActual);
bActual = store.Graphs[bExpected.BaseUri];
Assert.Equal(bExpected, bActual);
Graph cExpected = new Graph();
cExpected.LoadFromEmbeddedResource("VDS.RDF.Query.Optimisation.OptimiserStats.ttl");
cExpected.Retract(cExpected.Triples.Where(t => !t.IsGroundTriple).ToList());
cExpected.BaseUri = new Uri(TestGraphUri3);
IGraph cActual = store[cExpected.BaseUri];
Assert.Equal(cExpected, cActual);
cActual = store.Graphs[cExpected.BaseUri];
Assert.Equal(cExpected, cActual);
}
finally
{
store.Dispose();
}
}
private void TestDumpStoreEmpty(IStorageProvider manager)
{
this.EnsureTestDataset(manager);
PersistentTripleStore store = new PersistentTripleStore(manager);
try
{
// Try and dump
StringWriter strWriter = new StringWriter();
TriGWriter writer = new TriGWriter();
writer.UseMultiThreadedWriting = false;
writer.Save(store, strWriter);
Console.WriteLine("TriG output:");
Console.WriteLine(strWriter.ToString());
Assert.True(String.IsNullOrEmpty(strWriter.ToString()));
}
finally
{
store.Dispose();
}
}
private void TestQueryAsk(IStorageProvider manager, String query, bool expected)
{
this.EnsureTestDataset(manager);
PersistentTripleStore store = new PersistentTripleStore(manager);
try
{
SparqlResultSet results = store.ExecuteQuery(query) as SparqlResultSet;
if (results == null)
{
Assert.Fail("Did not get a SPARQL Result Set as expected");
}
TestTools.ShowResults(results);
Assert.AreEqual(SparqlResultsType.Boolean, results.ResultsType, "Did not get Boolean result as expected");
Assert.AreEqual(expected, results.Result, "Boolean Result failed to match");
}
finally
{
store.Dispose();
}
}
private void TestContains(IStorageProvider manager)
{
this.EnsureTestDataset(manager);
PersistentTripleStore store = new PersistentTripleStore(manager);
try
{
Assert.True(store.HasGraph(new Uri(TestGraphUri1)), "URI 1 should return true for HasGraph()");
Assert.True(store.Graphs.Contains(new Uri(TestGraphUri1)), "URI 1 should return true for Graphs.Contains()");
Assert.True(store.HasGraph(new Uri(TestGraphUri2)), "URI 2 should return true for HasGraph()");
Assert.True(store.Graphs.Contains(new Uri(TestGraphUri2)), "URI 2 should return true for Graphs.Contains()");
Assert.True(store.HasGraph(new Uri(TestGraphUri3)), "URI 3 should return true for HasGraph()");
Assert.True(store.Graphs.Contains(new Uri(TestGraphUri3)), "URI 3 should return true for Graphs.Contains()");
Uri noSuchThing = new Uri("http://example.org/persistence/graphs/noSuchGraph");
Assert.False(store.HasGraph(noSuchThing), "Bad URI should return false for HasGraph()");
Assert.False(store.Graphs.Contains(noSuchThing), "Bad URI should return false for Graphs.Contains()");
}
finally
{
store.Dispose();
}
}
/// <summary>
/// Tries to load a Triple Store 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;
ITripleStore store = null;
INode subObj;
bool isAsync;
Object temp;
//Get Property Nodes we need
INode propSqlManager = ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertySqlManager),
propGenericManager = ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyGenericManager),
propAsync = ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyAsync);
//Instantiate the Store Class
switch (targetType.FullName)
{
case TripleStore:
store = new TripleStore();
break;
#if !SILVERLIGHT
case WebDemandTripleStore:
store = new WebDemandTripleStore();
break;
#endif
#if !NO_DATA && !NO_STORAGE
case SqlTripleStore:
case ThreadedSqlTripleStore:
case OnDemandTripleStore:
subObj = ConfigurationLoader.GetConfigurationNode(g, objNode, propSqlManager);
if (subObj == null)
{
return(false);
}
temp = ConfigurationLoader.LoadObject(g, subObj);
if (temp is ISqlIOManager)
{
if (targetType.FullName.Equals(SqlTripleStore))
{
store = new SqlTripleStore((ISqlIOManager)temp);
}
else if (targetType.FullName.Equals(OnDemandTripleStore))
{
store = new OnDemandTripleStore((ISqlIOManager)temp);
}
else if (temp is IThreadedSqlIOManager)
{
isAsync = ConfigurationLoader.GetConfigurationBoolean(g, objNode, propAsync, false);
store = new ThreadedSqlTripleStore((IThreadedSqlIOManager)temp, isAsync);
}
else
{
throw new DotNetRdfConfigurationException("Unable to load a SQL Triple Store identified by the Node '" + objNode.ToString() + "' as the value given for the dnr:sqlManager property points to an Object which could not be loaded as an object which implements either the ISqlIOManager/IThreadedSqlIOManager interface");
}
}
else
{
throw new DotNetRdfConfigurationException("Unable to load a SQL Triple Store identified by the Node '" + objNode.ToString() + "' as the value given for the dnr:sqlManager property points to an Object which could not be loaded as an object which implements either the ISqlIOManager interface");
}
break;
#endif
#if !NO_STORAGE
case NativeTripleStore:
subObj = ConfigurationLoader.GetConfigurationNode(g, objNode, propGenericManager);
if (subObj == null)
{
return(false);
}
temp = ConfigurationLoader.LoadObject(g, subObj);
if (temp is IQueryableGenericIOManager)
{
store = new NativeTripleStore((IQueryableGenericIOManager)temp);
}
else
{
throw new DotNetRdfConfigurationException("Unable to load a Native Triple Store identified by the Node '" + objNode.ToString() + "' as the value given for the dnr:genericManager property points to an Object which could not be loaded as an object which implements the IQueryableGenericIOManager interface");
}
break;
case PersistentTripleStore:
subObj = ConfigurationLoader.GetConfigurationNode(g, objNode, propGenericManager);
if (subObj == null)
{
return(false);
}
temp = ConfigurationLoader.LoadObject(g, subObj);
if (temp is IGenericIOManager)
{
store = new PersistentTripleStore((IGenericIOManager)temp);
}
else
{
throw new DotNetRdfConfigurationException("Unable to load a Persistent Triple Store identified by the Node '" + objNode.ToString() + "' as the value given the for dnr:genericManager property points to an Object which could not be loaded as an object which implements the IGenericIOManager interface");
}
break;
#endif
}
//Read in additional data to be added to the Store
if (store != null)
{
IEnumerable <INode> sources = ConfigurationLoader.GetConfigurationData(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, "dnr:usingGraph"));
//Read from Graphs
foreach (INode source in sources)
{
temp = ConfigurationLoader.LoadObject(g, source);
if (temp is IGraph)
{
store.Add((IGraph)temp);
}
else
{
throw new DotNetRdfConfigurationException("Unable to load data from a Graph for the Triple Store identified by the Node '" + objNode.ToString() + "' as one of the values for the dnr:usingGraph property points to an Object that cannot be loaded as an object which implements the IGraph interface");
}
}
//Load from Embedded Resources
sources = ConfigurationLoader.GetConfigurationData(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyFromEmbedded));
foreach (INode source in sources)
{
if (source.NodeType == NodeType.Literal)
{
EmbeddedResourceLoader.Load(store, ((ILiteralNode)source).Value);
}
else
{
throw new DotNetRdfConfigurationException("Unable to load data from an Embedded Resource for the Graph identified by the Node '" + objNode.ToString() + "' as one of the values for the dnr:fromEmbedded property is not a Literal Node as required");
}
}
//Read from Files - we assume these files are Dataset Files
sources = ConfigurationLoader.GetConfigurationData(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyFromFile));
foreach (INode source in sources)
{
if (source.NodeType == NodeType.Literal)
{
FileLoader.Load(store, ConfigurationLoader.ResolvePath(((ILiteralNode)source).Value));
}
else
{
throw new DotNetRdfConfigurationException("Unable to load data from a file for the Triple Store identified by the Node '" + objNode.ToString() + "' as one of the values for the dnr:fromFile property is not a Literal Node as required");
}
}
//Finally we'll apply any reasoners
if (store is IInferencingTripleStore)
{
IEnumerable <INode> reasoners = ConfigurationLoader.GetConfigurationData(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyReasoner));
foreach (INode reasoner in reasoners)
{
temp = ConfigurationLoader.LoadObject(g, reasoner);
if (temp is IInferenceEngine)
{
((IInferencingTripleStore)store).AddInferenceEngine((IInferenceEngine)temp);
}
else
{
throw new DotNetRdfConfigurationException("Unable to apply a reasoner for the Graph identified by the Node '" + objNode.ToString() + "' as one of the values for the dnr:reasoner property points to an Object which cannot be loaded as an object which implements the IInferenceEngine interface");
}
}
}
//And as an absolute final step if the store is transactional we'll flush any changes we've made
if (store is ITransactionalStore)
{
((ITransactionalStore)store).Flush();
}
}
obj = store;
return(store != null);
}
public void StoragePersistentTripleStoreBadInstantiation()
{
PersistentTripleStore store = new PersistentTripleStore(null);
}
/// <summary>
/// Tries to load a Triple Store 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;
ITripleStore store = null;
INode subObj;
Object temp;
// Get Property Nodes we need
INode propStorageProvider = g.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyStorageProvider)),
propAsync = g.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyAsync));
// Check whether to use a specific Graph Collection
INode collectionNode = ConfigurationLoader.GetConfigurationNode(g, objNode, g.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyUsingGraphCollection)));
// Instantiate the Store Class
switch (targetType.FullName)
{
case TripleStore:
if (collectionNode == null)
{
store = new TripleStore();
}
else
{
BaseGraphCollection graphCollection = ConfigurationLoader.LoadObject(g, collectionNode) as BaseGraphCollection;
if (graphCollection == null)
{
throw new DotNetRdfConfigurationException("Unable to load the Triple Store identified by the Node '" + objNode.ToString() + "' as the dnr:usingGraphCollection points to an object which cannot be loaded as an instance of the required type BaseGraphCollection");
}
store = new TripleStore(graphCollection);
}
break;
case WebDemandTripleStore:
store = new WebDemandTripleStore();
break;
case PersistentTripleStore:
subObj = ConfigurationLoader.GetConfigurationNode(g, objNode, propStorageProvider);
if (subObj == null)
{
return(false);
}
temp = ConfigurationLoader.LoadObject(g, subObj);
if (temp is IStorageProvider)
{
store = new PersistentTripleStore((IStorageProvider)temp);
}
else
{
throw new DotNetRdfConfigurationException("Unable to load a Persistent Triple Store identified by the Node '" + objNode.ToString() + "' as the value given the for dnr:genericManager property points to an Object which could not be loaded as an object which implements the IStorageProvider interface");
}
break;
}
// Read in additional data to be added to the Store
if (store != null)
{
IEnumerable <INode> sources = ConfigurationLoader.GetConfigurationData(g, objNode, g.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyUsingGraph)));
// Read from Graphs
foreach (INode source in sources)
{
temp = ConfigurationLoader.LoadObject(g, source);
if (temp is IGraph)
{
store.Add((IGraph)temp);
}
else
{
throw new DotNetRdfConfigurationException("Unable to load data from a Graph for the Triple Store identified by the Node '" + objNode.ToString() + "' as one of the values for the dnr:usingGraph property points to an Object that cannot be loaded as an object which implements the IGraph interface");
}
}
// Load from Embedded Resources
sources = ConfigurationLoader.GetConfigurationData(g, objNode, g.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyFromEmbedded)));
foreach (INode source in sources)
{
if (source.NodeType == NodeType.Literal)
{
EmbeddedResourceLoader.Load(store, ((ILiteralNode)source).Value);
}
else
{
throw new DotNetRdfConfigurationException("Unable to load data from an Embedded Resource for the Graph identified by the Node '" + objNode.ToString() + "' as one of the values for the dnr:fromEmbedded property is not a Literal Node as required");
}
}
// Read from Files - we assume these files are Dataset Files
sources = ConfigurationLoader.GetConfigurationData(g, objNode, g.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyFromFile)));
foreach (INode source in sources)
{
if (source.NodeType == NodeType.Literal)
{
FileLoader.Load(store, ConfigurationLoader.ResolvePath(((ILiteralNode)source).Value));
}
else
{
throw new DotNetRdfConfigurationException("Unable to load data from a file for the Triple Store identified by the Node '" + objNode.ToString() + "' as one of the values for the dnr:fromFile property is not a Literal Node as required");
}
}
// Finally we'll apply any reasoners
if (store is IInferencingTripleStore)
{
IEnumerable <INode> reasoners = ConfigurationLoader.GetConfigurationData(g, objNode, g.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyReasoner)));
foreach (INode reasoner in reasoners)
{
temp = ConfigurationLoader.LoadObject(g, reasoner);
if (temp is IInferenceEngine)
{
((IInferencingTripleStore)store).AddInferenceEngine((IInferenceEngine)temp);
}
else
{
throw new DotNetRdfConfigurationException("Unable to apply a reasoner for the Graph identified by the Node '" + objNode.ToString() + "' as one of the values for the dnr:reasoner property points to an Object which cannot be loaded as an object which implements the IInferenceEngine interface");
}
}
}
// And as an absolute final step if the store is transactional we'll flush any changes we've made
if (store is ITransactionalStore)
{
((ITransactionalStore)store).Flush();
}
}
obj = store;
return(store != null);
}
/// <summary>
/// Tries to load a Triple Store 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;
ITripleStore store = null;
INode subObj;
bool isAsync;
Object temp;
//Get Property Nodes we need
INode propSqlManager = ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertySqlManager),
propGenericManager = ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyGenericManager),
propAsync = ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyAsync);
//Instantiate the Store Class
switch (targetType.FullName)
{
case TripleStore:
store = new TripleStore();
break;
#if !SILVERLIGHT
case WebDemandTripleStore:
store = new WebDemandTripleStore();
break;
#endif
#if !NO_DATA && !NO_STORAGE
case SqlTripleStore:
case ThreadedSqlTripleStore:
case OnDemandTripleStore:
subObj = ConfigurationLoader.GetConfigurationNode(g, objNode, propSqlManager);
if (subObj == null) return false;
temp = ConfigurationLoader.LoadObject(g, subObj);
if (temp is ISqlIOManager)
{
if (targetType.FullName.Equals(SqlTripleStore))
{
store = new SqlTripleStore((ISqlIOManager)temp);
}
else if (targetType.FullName.Equals(OnDemandTripleStore))
{
store = new OnDemandTripleStore((ISqlIOManager)temp);
}
else if (temp is IThreadedSqlIOManager)
{
isAsync = ConfigurationLoader.GetConfigurationBoolean(g, objNode, propAsync, false);
store = new ThreadedSqlTripleStore((IThreadedSqlIOManager)temp, isAsync);
}
else
{
throw new DotNetRdfConfigurationException("Unable to load a SQL Triple Store identified by the Node '" + objNode.ToString() + "' as the value given for the dnr:sqlManager property points to an Object which could not be loaded as an object which implements either the ISqlIOManager/IThreadedSqlIOManager interface");
}
}
else
{
throw new DotNetRdfConfigurationException("Unable to load a SQL Triple Store identified by the Node '" + objNode.ToString() + "' as the value given for the dnr:sqlManager property points to an Object which could not be loaded as an object which implements either the ISqlIOManager interface");
}
break;
#endif
#if !NO_STORAGE
case NativeTripleStore:
subObj = ConfigurationLoader.GetConfigurationNode(g, objNode, propGenericManager);
if (subObj == null) return false;
temp = ConfigurationLoader.LoadObject(g, subObj);
if (temp is IQueryableGenericIOManager)
{
store = new NativeTripleStore((IQueryableGenericIOManager)temp);
}
else
{
throw new DotNetRdfConfigurationException("Unable to load a Native Triple Store identified by the Node '" + objNode.ToString() + "' as the value given for the dnr:genericManager property points to an Object which could not be loaded as an object which implements the IQueryableGenericIOManager interface");
}
break;
case PersistentTripleStore:
subObj = ConfigurationLoader.GetConfigurationNode(g, objNode, propGenericManager);
if (subObj == null) return false;
temp = ConfigurationLoader.LoadObject(g, subObj);
if (temp is IGenericIOManager)
{
store = new PersistentTripleStore((IGenericIOManager)temp);
}
else
{
throw new DotNetRdfConfigurationException("Unable to load a Persistent Triple Store identified by the Node '" + objNode.ToString() + "' as the value given the for dnr:genericManager property points to an Object which could not be loaded as an object which implements the IGenericIOManager interface");
}
break;
#endif
}
//Read in additional data to be added to the Store
if (store != null)
{
IEnumerable<INode> sources = ConfigurationLoader.GetConfigurationData(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, "dnr:usingGraph"));
//Read from Graphs
foreach (INode source in sources)
{
temp = ConfigurationLoader.LoadObject(g, source);
if (temp is IGraph)
{
store.Add((IGraph)temp);
}
else
{
throw new DotNetRdfConfigurationException("Unable to load data from a Graph for the Triple Store identified by the Node '" + objNode.ToString() + "' as one of the values for the dnr:usingGraph property points to an Object that cannot be loaded as an object which implements the IGraph interface");
}
}
//Load from Embedded Resources
sources = ConfigurationLoader.GetConfigurationData(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyFromEmbedded));
foreach (INode source in sources)
{
if (source.NodeType == NodeType.Literal)
{
EmbeddedResourceLoader.Load(store, ((ILiteralNode)source).Value);
}
else
{
throw new DotNetRdfConfigurationException("Unable to load data from an Embedded Resource for the Graph identified by the Node '" + objNode.ToString() + "' as one of the values for the dnr:fromEmbedded property is not a Literal Node as required");
}
}
//Read from Files - we assume these files are Dataset Files
sources = ConfigurationLoader.GetConfigurationData(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyFromFile));
foreach (INode source in sources)
{
if (source.NodeType == NodeType.Literal)
{
FileLoader.Load(store, ConfigurationLoader.ResolvePath(((ILiteralNode)source).Value));
}
else
{
throw new DotNetRdfConfigurationException("Unable to load data from a file for the Triple Store identified by the Node '" + objNode.ToString() + "' as one of the values for the dnr:fromFile property is not a Literal Node as required");
}
}
//Finally we'll apply any reasoners
if (store is IInferencingTripleStore)
{
IEnumerable<INode> reasoners = ConfigurationLoader.GetConfigurationData(g, objNode, ConfigurationLoader.CreateConfigurationNode(g, ConfigurationLoader.PropertyReasoner));
foreach (INode reasoner in reasoners)
{
temp = ConfigurationLoader.LoadObject(g, reasoner);
if (temp is IInferenceEngine)
{
((IInferencingTripleStore)store).AddInferenceEngine((IInferenceEngine)temp);
}
else
{
throw new DotNetRdfConfigurationException("Unable to apply a reasoner for the Graph identified by the Node '" + objNode.ToString() + "' as one of the values for the dnr:reasoner property points to an Object which cannot be loaded as an object which implements the IInferenceEngine interface");
}
}
}
//And as an absolute final step if the store is transactional we'll flush any changes we've made
if (store is ITransactionalStore)
{
((ITransactionalStore)store).Flush();
}
}
obj = store;
return (store != null);
}
