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 }))); }