static void Main(string[] args)
{
ParserFactory parserFactory = new XsltParserFactory();
TripleStoreFactory tripleStoreFactory = new MemoryTripleStoreFactory();
TripleStore model = tripleStoreFactory.MakeTripleStore();
// Parse the bloggers RDF file
FileStream fileStream = new FileStream("./bloggers.rdf", FileMode.Open);
Parser parser = parserFactory.MakeParser(tripleStoreFactory.MakeResourceFactory(), new StatementFactory());
parser.NewStatement += model.GetStatementHandler();
parser.Parse(fileStream, "");
parser.NewStatement -= model.GetStatementHandler();
/* Define the query. Equivalent to:
* ?blogger rdf:type foaf:Agent .
* ?blogger foaf:name ?name .
*/
Query queryListOfBloggers = new Query();
queryListOfBloggers.AddPattern(new Pattern(new Variable("blogger"), new UriRef("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"), new UriRef("http://xmlns.com/foaf/0.1/Agent")));
queryListOfBloggers.AddPattern(new Pattern(new Variable("blogger"), new UriRef("http://xmlns.com/foaf/0.1/name"), new Variable("name")));
IEnumerator solutions = model.Solve(queryListOfBloggers);
while (solutions.MoveNext())
{
QuerySolution solution = (QuerySolution)solutions.Current;
Console.WriteLine(solution["name"]);
}
}
private ResourceDescription GetDescriptionOf(Resource theResource, TripleStore store, Hashtable processedResources)
{
ConciseBoundedDescription cbd = new ConciseBoundedDescription(theResource);
IList denotingNodes = store.GetNodesDenoting(theResource);
processedResources[theResource] = denotingNodes;
foreach (GraphMember member in denotingNodes)
{
cbd.AddDenotation(member, theResource);
}
Query query = new Query();
query.AddPattern(new Pattern(store.GetBestDenotingNode(theResource), new Variable("pred"), new Variable("obj")));
IEnumerator solutions = store.Solve(query);
while (solutions.MoveNext())
{
QuerySolution solution = (QuerySolution)solutions.Current;
foreach (GraphMember member in store.GetNodesDenoting(solution["pred"]))
{
cbd.AddDenotation(member, solution["pred"]);
}
foreach (GraphMember member in store.GetNodesDenoting(solution["obj"]))
{
cbd.AddDenotation(member, solution["obj"]);
}
cbd.Add(new ResourceStatement(theResource, solution["pred"], solution["obj"]));
if (store.GetBestDenotingNode(solution["obj"]) is BlankNode)
{
if (!processedResources.ContainsKey(solution["obj"]))
{
cbd.Add((ConciseBoundedDescription)GetDescriptionOf(solution["obj"], store, processedResources));
}
}
}
return(cbd);
}
public TripleStore ExecuteTripleStore(TripleStore defaultStore)
{
MemoryTripleStore results = new MemoryTripleStore();
if (HasPatterns)
{
IEnumerator solutions = defaultStore.Solve(this);
while (solutions.MoveNext())
{
QuerySolution solution = (QuerySolution)solutions.Current;
foreach (PatternTerm term in DescribeTerms)
{
if (term is Variable)
{
ResourceDescription description = defaultStore.GetDescriptionOf(solution[((Variable)term).Name], this.BoundingStrategy);
results.Add(description);
}
}
}
}
foreach (PatternTerm term in DescribeTerms)
{
if (term is UriRef)
{
ResourceDescription description = defaultStore.GetDescriptionOf((UriRef)term, this.BoundingStrategy);
results.Add(description);
}
else
{
if (!HasPatterns)
{
throw new SparqlException("DESCRIBE query has no patterns but requests description of a variable");
}
}
}
return(results);
}
public override IEnumerator GetSolutions(Query query, TripleStore tripleStore, bool explain)
{
return(tripleStore.Solve(query));
}
public void Process(Rule rule, TripleStore store)
{
Query query = new Query();
if (rule.Antecedents.Count == 0)
{
ApplyConsequentStatements(rule, store);
return;
}
foreach (Pattern pattern in rule.Antecedents)
{
query.AddPattern(pattern);
}
foreach (Pattern pattern in rule.Consequents)
{
if (pattern.GetSubject() is Variable)
{
query.AddVariable(((Variable)pattern.GetSubject()));
}
if (pattern.GetPredicate() is Variable)
{
query.AddVariable(((Variable)pattern.GetPredicate()));
}
if (pattern.GetObject() is Variable)
{
query.AddVariable(((Variable)pattern.GetObject()));
}
}
IEnumerator solutions = store.Solve(query);
if (Explain)
{
((BacktrackingQuerySolver)solutions).Explain = true;
}
ArrayList consequentStatements = new ArrayList();
while (solutions.MoveNext())
{
QuerySolution solution = (QuerySolution)solutions.Current;
foreach (Pattern pattern in rule.Consequents)
{
Resource subjectResource;
Resource predicateResource;
Resource objectResource;
if (pattern.GetSubject() is Variable)
{
subjectResource = solution[((Variable)pattern.GetSubject()).Name];
}
else
{
subjectResource = store.GetResourceDenotedBy((GraphMember)pattern.GetSubject());
}
if (pattern.GetPredicate() is Variable)
{
predicateResource = solution[((Variable)pattern.GetPredicate()).Name];
}
else
{
predicateResource = store.GetResourceDenotedBy((GraphMember)pattern.GetPredicate());
}
if (pattern.GetObject() is Variable)
{
objectResource = solution[((Variable)pattern.GetObject()).Name];
}
else
{
objectResource = store.GetResourceDenotedBy((GraphMember)pattern.GetObject());
}
consequentStatements.Add(new ResourceStatement(subjectResource, predicateResource, objectResource));
}
}
foreach (ResourceStatement statement in consequentStatements)
{
store.Add(statement);
}
}
public IEnumerator ExecuteEnumerator(TripleStore defaultStore)
{
return(defaultStore.Solve(this));
}
