public void SparqlBgpEvaluation()
{
//Prepare the Store
TripleStore store = new TripleStore();
Graph g = new Graph();
FileLoader.Load(g, "Turtle.ttl");
store.Add(g);
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromString(@"PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
SELECT * WHERE {?s ?p ?o . ?s rdfs:label ?label}");
Object testResult = store.ExecuteQuery(q);
ISparqlAlgebra testAlgebra = q.ToAlgebra();
if (testResult is SparqlResultSet)
{
SparqlResultSet rset = (SparqlResultSet)testResult;
Console.WriteLine(rset.Count + " Results");
foreach (SparqlResult r in rset)
{
Console.WriteLine(r.ToString());
}
Console.WriteLine();
}
//Create some Triple Patterns
TriplePattern t1 = new TriplePattern(new VariablePattern("?s"), new VariablePattern("?p"), new VariablePattern("?o"));
TriplePattern t2 = new TriplePattern(new VariablePattern("?s"), new NodeMatchPattern(g.CreateUriNode("rdfs:label")), new VariablePattern("?label"));
TriplePattern t3 = new TriplePattern(new VariablePattern("?x"), new VariablePattern("?y"), new VariablePattern("?z"));
TriplePattern t4 = new TriplePattern(new VariablePattern("?s"), new NodeMatchPattern(g.CreateUriNode(":name")), new VariablePattern("?name"));
//Build some BGPs
Bgp selectNothing = new Bgp();
Bgp selectAll = new Bgp(t1);
Bgp selectLabelled = new Bgp(new List<ITriplePattern>() { t1, t2 });
Bgp selectAllDisjoint = new Bgp(new List<ITriplePattern>() { t1, t3 });
Bgp selectLabels = new Bgp(t2);
Bgp selectNames = new Bgp(t4);
//LeftJoin selectOptionalNamed = new LeftJoin(selectAll, new Optional(selectNames));
LeftJoin selectOptionalNamed = new LeftJoin(selectAll, selectNames);
Union selectAllUnion = new Union(selectAll, selectAll);
Union selectAllUnion2 = new Union(selectAllUnion, selectAll);
Filter selectAllUriObjects = new Filter(selectAll, new UnaryExpressionFilter(new IsUriFunction(new VariableExpressionTerm("o"))));
//Test out the BGPs
//Console.WriteLine("{}");
//this.ShowMultiset(selectNothing.Evaluate(new SparqlEvaluationContext(null, store)));
//Console.WriteLine("{?s ?p ?o}");
//this.ShowMultiset(selectAll.Evaluate(new SparqlEvaluationContext(null, store)));
//Console.WriteLine("{?s ?p ?o . ?s rdfs:label ?label}");
//SparqlEvaluationContext context = new SparqlEvaluationContext(null, store);
//this.ShowMultiset(selectLabelled.Evaluate(context));
//SparqlResultSet lvnResult = new SparqlResultSet(context);
//Console.WriteLine("{?s ?p ?o . ?x ?y ?z}");
//this.ShowMultiset(selectAllDisjoint.Evaluate(new SparqlEvaluationContext(null, store)));
//Console.WriteLine("{?s ?p ?o . OPTIONAL {?s :name ?name}}");
//this.ShowMultiset(selectOptionalNamed.Evaluate(new SparqlEvaluationContext(null, store)));
Console.WriteLine("{{?s ?p ?o} UNION {?s ?p ?o}}");
this.ShowMultiset(selectAllUnion.Evaluate(new SparqlEvaluationContext(null, new InMemoryDataset(store))));
Console.WriteLine("{{?s ?p ?o} UNION {?s ?p ?o} UNION {?s ?p ?o}}");
this.ShowMultiset(selectAllUnion2.Evaluate(new SparqlEvaluationContext(null, new InMemoryDataset(store))));
Console.WriteLine("{?s ?p ?o FILTER (ISURI(?o))}");
this.ShowMultiset(selectAllUriObjects.Evaluate(new SparqlEvaluationContext(null, new InMemoryDataset(store))));
}
/// <summary>
/// Converts a Path into its Algebra Form
/// </summary>
/// <param name="context">Path Transformation Context</param>
/// <returns></returns>
public override ISparqlAlgebra ToAlgebra(PathTransformContext context)
{
ISparqlAlgebra complex = null;
int i = this._n;
while (i <= this._m)
{
PathTransformContext tempContext = new PathTransformContext(context);
tempContext.AddTriplePattern(new PropertyPathPattern(context.Subject, new FixedCardinality(this._path, i), context.Object));
if (complex == null)
{
complex = tempContext.ToAlgebra();
}
else
{
complex = new Union(complex, tempContext.ToAlgebra());
}
i++;
}
return complex;
}
/// <summary>
/// Gets the Algebra representation of the Graph Pattern
/// </summary>
/// <returns></returns>
public ISparqlAlgebra ToAlgebra()
{
if (this._isUnion)
{
//If this Graph Pattern represents a UNION of Graph Patterns turn into a series of UNIONs
ISparqlAlgebra union = new Union(this._graphPatterns[0].ToAlgebra(), this._graphPatterns[1].ToAlgebra());
if (this._graphPatterns.Count > 2)
{
for (int i = 2; i < this._graphPatterns.Count; i++)
{
union = new Union(union, this._graphPatterns[i].ToAlgebra());
}
}
//If there's a FILTER apply it over the Union
if (this._isFiltered && (this._filter != null || this._unplacedFilters.Count > 0))
{
return new Filter(union, this.Filter);
}
else
{
return union;
}
}
else if (this._graphPatterns.Count == 0)
{
//If there are no Child Graph Patterns then this is a BGP
ISparqlAlgebra bgp = new Bgp(this._triplePatterns);
if (this._unplacedAssignments.Count > 0)
{
//If we have any unplaced LETs these get Joined onto the BGP
bgp = Join.CreateJoin(bgp, new Bgp(this._unplacedAssignments));
}
if (this._isFiltered && (this._filter != null || this._unplacedFilters.Count > 0))
{
if (this._isOptional && !(this._isExists || this._isNotExists))
{
//If we contain an unplaced FILTER and we're an OPTIONAL then the FILTER
//applies over the LEFT JOIN and will have been added elsewhere in the Algebra transform
return bgp;
}
else
{
ISparqlAlgebra complex = bgp;
//If we contain an unplaced FILTER and we're not an OPTIONAL the FILTER
//applies here
return new Filter(bgp, this.Filter);
}
}
else
{
//We're not filtered (or all FILTERs were placed in the BGP) so we're just a BGP
return bgp;
}
}
else
{
//Create a basic BGP to start with
ISparqlAlgebra complex = new Bgp();
if (this._triplePatterns.Count > 0)
{
complex = new Bgp(this._triplePatterns);
}
//Then Join each of the Graph Patterns as appropriate
foreach (GraphPattern gp in this._graphPatterns)
{
if (gp.IsGraph)
{
//A GRAPH clause means a Join of the current pattern to a Graph clause
complex = Join.CreateJoin(complex, new Algebra.Graph(gp.ToAlgebra(), gp.GraphSpecifier));
}
else if (gp.IsOptional)
{
if (gp.IsExists || gp.IsNotExists)
{
//An EXISTS/NOT EXISTS means an Exists Join of the current pattern to the EXISTS/NOT EXISTS clause
complex = new ExistsJoin(complex, gp.ToAlgebra(), gp.IsExists);
}
else
{
//An OPTIONAL means a Left Join of the current pattern to the OPTIONAL clause
//with a possible FILTER applied over the LeftJoin
if (gp.IsFiltered && gp.Filter != null)
{
//If the OPTIONAL clause has an unplaced FILTER it applies over the Left Join
complex = new LeftJoin(complex, gp.ToAlgebra(), gp.Filter);
}
else
{
complex = new LeftJoin(complex, gp.ToAlgebra());
}
}
}
else if (gp.IsMinus)
{
//Always introduce a Minus here even if the Minus is disjoint since during evaluation we'll choose
//not to execute it if it's disjoint
complex = new Minus(complex, gp.ToAlgebra());
}
else if (gp.IsService)
{
complex = Join.CreateJoin(complex, new Service(gp.GraphSpecifier, gp, gp.IsSilent));
}
else
{
//Otherwise we just join the pattern to the existing pattern
complex = Join.CreateJoin(complex, gp.ToAlgebra());
}
}
if (this._unplacedAssignments.Count > 0)
{
//Unplaced assignments get Joined as a BGP here
complex = Join.CreateJoin(complex, new Bgp(this._unplacedAssignments));
}
if (this._isFiltered && (this._filter != null || this._unplacedFilters.Count > 0))
{
if (this._isOptional && !(this._isExists || this._isNotExists))
{
//If there's an unplaced FILTER and we're an OPTIONAL then the FILTER will
//apply over the LeftJoin and is applied elsewhere in the Algebra transform
return complex;
}
else
{
if (this._filter != null || this._unplacedFilters.Count > 0)
{
//If there's an unplaced FILTER and we're not an OPTIONAL pattern we apply
//the FILTER here
return new Filter(complex, this.Filter);
}
else
{
return complex;
}
}
}
else
{
//If no FILTER just return the transform
return complex;
}
}
}