public void SparqlAlgebraVariableClassification3()
{
TriplePattern tp = MakeTriplePattern(this._factory.CreateVariableNode("s"), this._rdfType, this._factory.CreateVariableNode("type"));
IBgp lhs = new Bgp(tp);
this.TestClassification(lhs, new String[] { "s", "type" }, this._emptyList);
tp = MakeTriplePattern(this._factory.CreateVariableNode("s"), this._factory.CreateVariableNode("p"), this._factory.CreateVariableNode("o"));
IBgp rhs = new Bgp(tp);
this.TestClassification(rhs, new String[] { "s", "p", "o" }, this._emptyList);
// In a join everything should end up fixed since everything started as fixed
IJoin join = new Join(lhs, rhs);
this.TestClassification(join, new String[] { "s", "type", "p", "o" }, this._emptyList);
// In the left join only the LHS variables should be fixed, others should be floating
ILeftJoin leftJoin = new LeftJoin(lhs, rhs);
this.TestClassification(leftJoin, new String[] { "s", "type" }, new String[] { "p", "o" });
leftJoin = new LeftJoin(rhs, lhs);
this.TestClassification(leftJoin, new String[] { "s", "p", "o" }, new String[] { "type" });
// In the union only fixed variables on both sides are fixed, others should be floating
IUnion union = new Union(lhs, rhs);
this.TestClassification(union, new String[] { "s" }, new String[] { "p", "o", "type" });
}
public void SparqlAlgebraVariableClassification4()
{
TriplePattern tp = MakeTriplePattern(this._factory.CreateVariableNode("s"), this._rdfType, this._factory.CreateVariableNode("type"));
IBgp lhs = new Bgp(tp);
tp = MakeTriplePattern(this._factory.CreateVariableNode("s"), this._factory.CreateVariableNode("p"), this._factory.CreateVariableNode("o"));
IBgp rhs = new Bgp(tp);
// In the left join only the LHS variables should be fixed, others should be floating
ILeftJoin leftJoin = new LeftJoin(lhs, rhs);
this.TestClassification(leftJoin, new String[] { "s", "type" }, new String[] { "p", "o" });
tp = MakeTriplePattern(this._factory.CreateVariableNode("s"), this._factory.CreateUriNode(new Uri(NamespaceMapper.RDFS + "label")), this._factory.CreateVariableNode("label"));
Bgp top = new Bgp(tp);
// Everything in the RHS not fixed on the LHS is floating
ILeftJoin parentJoin = new LeftJoin(top, leftJoin);
this.TestClassification(parentJoin, new String[] { "s", "label" }, new String[] { "p", "o", "type" });
parentJoin = new LeftJoin(leftJoin, top);
this.TestClassification(parentJoin, new String[] { "s", "type" }, new String[] { "p", "o", "label" });
}
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>
/// 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;
}
}
}