private void RunTest(ISparqlPath path, IEnumerable<String> expectedOperators)
{
VariablePattern x = new VariablePattern("?x");
VariablePattern y = new VariablePattern("?y");
PathTransformContext context = new PathTransformContext(x, y);
Console.WriteLine("Path: " + path.ToString());
ISparqlAlgebra algebra = path.ToAlgebra(context);
String result = algebra.ToString();
Console.WriteLine("Algebra: " + result);
try
{
GraphPattern gp = algebra.ToGraphPattern();
Console.WriteLine("GraphPattern:");
Console.WriteLine(this._formatter.Format(gp));
Console.WriteLine();
}
catch
{
Console.WriteLine("Algebra not translatable to a GraphPattern");
}
foreach (String op in expectedOperators)
{
if (!result.Contains(op))
{
Console.WriteLine("Expected Operator '" + op + "' missing");
Assert.Fail("Expected Operator '" + op + "' missing");
}
}
}
private ISparqlAlgebra GetAlgebraUntransformed(ISparqlPath path, INode start, INode end)
{
PatternItem x, y;
if (start == null)
{
x = new VariablePattern("?x");
}
else
{
x = new NodeMatchPattern(start);
}
if (end == null)
{
y = new VariablePattern("?y");
}
else
{
y = new NodeMatchPattern(end);
}
return new Bgp(new PropertyPathPattern(x, path, y));
}
private ISparqlAlgebra GetAlgebra(ISparqlPath path, INode start, INode end)
{
PatternItem x, y;
if (start == null)
{
x = new VariablePattern("?x");
}
else
{
x = new NodeMatchPattern(start);
}
if (end == null)
{
y = new VariablePattern("?y");
}
else
{
y = new NodeMatchPattern(end);
}
PathTransformContext context = new PathTransformContext(x, y);
return path.ToAlgebra(context);
}
/// <summary>
/// Helper method which converts a SemWeb resource into a PatternItem for use in a SPARQL Triple Pattern
/// </summary>
/// <param name="r">Resource</param>
/// <param name="mapping">Mapping of Variables & Blank Nodes to Pattern Items</param>
/// <param name="g">Graph</param>
/// <returns></returns>
private PatternItem FromSemWeb(Resource r, IGraph g, Dictionary<String, PatternItem> mapping)
{
if (r is Variable)
{
if (mapping.ContainsKey(r.ToString()))
{
return mapping[r.ToString()];
}
else
{
PatternItem temp = new VariablePattern(r.ToString());
mapping.Add(r.ToString(), temp);
return temp;
}
}
else if (r is BNode)
{
if (mapping.ContainsKey(r.ToString()))
{
return mapping[r.ToString()];
}
else
{
PatternItem temp = new BlankNodePattern(r.ToString().Substring(2));
mapping.Add(r.ToString(), temp);
return temp;
}
}
else
{
return new NodeMatchPattern(SemWebConverter.FromSemWeb(r, this.GetMapping(g)));
}
}
/// <summary>
/// Evaluates a setp of the Path
/// </summary>
/// <param name="context">Context</param>
/// <param name="path">Paths</param>
/// <param name="reverse">Whether to evaluate Paths in reverse</param>
/// <returns></returns>
protected List<INode> EvaluateStep(SparqlEvaluationContext context, List<INode> path, bool reverse)
{
if (this.Path is Property)
{
HashSet<INode> nodes = new HashSet<INode>();
INode predicate = ((Property)this.Path).Predicate;
IEnumerable<Triple> ts = (reverse ? context.Data.GetTriplesWithPredicateObject(predicate, path[path.Count - 1]) : context.Data.GetTriplesWithSubjectPredicate(path[path.Count - 1], predicate));
foreach (Triple t in ts)
{
if (reverse)
{
if (!path.Contains(t.Subject))
{
nodes.Add(t.Subject);
}
}
else
{
if (!path.Contains(t.Object))
{
nodes.Add(t.Object);
}
}
}
return nodes.ToList();
}
else
{
List<INode> nodes = new List<INode>();
BaseMultiset initialInput = context.InputMultiset;
Multiset currInput = new Multiset();
VariablePattern x = new VariablePattern("?x");
VariablePattern y = new VariablePattern("?y");
Set temp = new Set();
if (reverse)
{
temp.Add("y", path[path.Count - 1]);
}
else
{
temp.Add("x", path[path.Count - 1]);
}
currInput.Add(temp);
context.InputMultiset = currInput;
Bgp bgp = new Bgp(new PropertyPathPattern(x, this.Path, y));
BaseMultiset results = context.Evaluate(bgp);//bgp.Evaluate(context);
context.InputMultiset = initialInput;
if (!results.IsEmpty)
{
foreach (Set s in results.Sets)
{
if (reverse)
{
if (s["x"] != null)
{
if (!path.Contains(s["x"]))
{
nodes.Add(s["x"]);
}
}
}
else
{
if (s["y"] != null)
{
if (!path.Contains(s["y"]))
{
nodes.Add(s["y"]);
}
}
}
}
}
return nodes;
}
}
/// <summary>
/// Determines the starting points for Path evaluation
/// </summary>
/// <param name="context">Evaluation Context</param>
/// <param name="paths">Paths</param>
/// <param name="reverse">Whether to evaluate Paths in reverse</param>
protected void GetPathStarts(SparqlEvaluationContext context, List<List<INode>> paths, bool reverse)
{
HashSet<KeyValuePair<INode, INode>> nodes = new HashSet<KeyValuePair<INode, INode>>();
if (this.Path is Property)
{
INode predicate = ((Property)this.Path).Predicate;
foreach (Triple t in context.Data.GetTriplesWithPredicate(predicate))
{
if (reverse)
{
nodes.Add(new KeyValuePair<INode, INode>(t.Object, t.Subject));
}
else
{
nodes.Add(new KeyValuePair<INode, INode>(t.Subject, t.Object));
}
}
}
else
{
BaseMultiset initialInput = context.InputMultiset;
context.InputMultiset = new IdentityMultiset();
VariablePattern x = new VariablePattern("?x");
VariablePattern y = new VariablePattern("?y");
Bgp bgp = new Bgp(new PropertyPathPattern(x, this.Path, y));
BaseMultiset results = context.Evaluate(bgp);//bgp.Evaluate(context);
context.InputMultiset = initialInput;
if (!results.IsEmpty)
{
foreach (Set s in results.Sets)
{
if (s["x"] != null && s["y"] != null)
{
if (reverse)
{
nodes.Add(new KeyValuePair<INode, INode>(s["y"], s["x"]));
}
else
{
nodes.Add(new KeyValuePair<INode, INode>(s["x"], s["y"]));
}
}
}
}
}
paths.AddRange(nodes.Select(kvp => new List<INode>(new INode[] { kvp.Key, kvp.Value })));
}
