/// <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>
/// <returns></returns>
private PatternItem FromSemWeb(Resource r, 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._mapping)));
}
}
public void SparqlOptimiserQueryFilterPlacement5()
{
// given
var query = new SparqlQuery {
QueryType = SparqlQueryType.Select
};
query.AddVariable(new SparqlVariable("s", true));
query.RootGraphPattern = new GraphPattern();
var subj = new VariablePattern("s");
var rdfType = new NodeMatchPattern(new UriNode(null, new Uri(RdfSpecsHelper.RdfType)));
var type = new VariablePattern("type");
var triplePattern = new TriplePattern(subj, rdfType, type);
query.RootGraphPattern.AddTriplePattern(triplePattern);
query.RootGraphPattern.AddFilter(new UnaryExpressionFilter(new InFunction(new VariableTerm("type"), new[]
{
new ConstantTerm(new UriNode(null, new Uri("http://example.com/Type1"))),
new ConstantTerm(new UriNode(null, new Uri("http://example.com/Type2"))),
new ConstantTerm(new UriNode(null, new Uri("http://example.com/Type3")))
})));
// when
var algebra = query.ToAlgebra();
// then
Assert.IsType <Select>(algebra);
Assert.IsType <Filter>(((Select)algebra).InnerAlgebra);
}
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))
{
continue;
}
Console.WriteLine("Expected Operator '" + op + "' missing");
Assert.True(false, "Expected Operator '" + op + "' missing");
}
}
private void ProcessSelectExpandItem(SelectExpandClause clause, EdmNode edmNode, CustomNavigationProperty parentCustomNavProp, NavigationPropertySegment parentSegment)
{
if (edmNode == null)
{
var entityType = parentSegment.EdmType.AsElementType() as EdmEntityType;
var RdfNode = new VariablePattern($"{parentSegment.NavigationProperty.Name}");
edmNode = new EdmNode()
{
Name = parentSegment.NavigationProperty.Name,
ItemEdmType = entityType,
RdfNode = RdfNode,
//StructProperties = entityType.StructuralProperties().ToList(),
NavProperties = new List <CustomNavigationProperty>()
};
parentCustomNavProp.NestedEdmNodes.Add(edmNode);
}
List <IEdmStructuralProperty> structPropList = new List <IEdmStructuralProperty>();
foreach (var item in clause.SelectedItems)
{
var selectItem = item as PathSelectItem;
if (selectItem != null && selectItem.SelectedPath != null)
{
var segment = selectItem.SelectedPath.FirstSegment as PropertySegment;
if (segment != null)
{
structPropList.Add(segment.Property);
}
}
var expandItem = item as ExpandedNavigationSelectItem;
if (expandItem != null)
{
var segment = expandItem.PathToNavigationProperty.FirstSegment as NavigationPropertySegment;
if (segment != null && expandItem.SelectAndExpand != null)
{
CustomNavigationProperty customNavProp = new CustomNavigationProperty();
edmNode.NavProperties.Add(customNavProp);
customNavProp.NestedEdmNodes = new List <EdmNode>();
customNavProp.NavigationProperty = segment.NavigationProperty;
customNavProp.Filters = expandItem.FilterOption != null ? expandItem.FilterOption.Expression : null;
customNavProp.Top = expandItem.TopOption.GetValueOrDefault();
customNavProp.Skip = expandItem.SkipOption.GetValueOrDefault();
customNavProp.OrderBy = expandItem.OrderByOption;
ProcessSelectExpandItem(expandItem.SelectAndExpand, null, customNavProp, segment);
}
}
}
if (structPropList.Count > 0)
{
//edmNode.StructProperties = structPropList;
if (parentCustomNavProp != null)
{
parentCustomNavProp.StructProperties = structPropList;
}
}
}
/// <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 (ISet 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 })));
}
public override Tree Evaluate(Tree tree, TregexMatcher tregex)
{
Tree nodeToRelabel = ChildMatcher[0].Evaluate(tree, tregex);
switch (node.mode)
{
case RelabelMode.Fixed:
{
nodeToRelabel.Label().SetValue(node.newLabel);
break;
}
case RelabelMode.Regex:
{
var label = new StringBuilder();
foreach (string chunk in node.replacementPieces)
{
if (VariablePattern.IsMatch(chunk))
{
//String name = chunk.Substring(2, chunk.Length - 1);
string name = chunk.Substring(2, chunk.Length - 3);
//label.Append(Matcher.quoteReplacement(tregex.getVariableString(name)));
label.Append(tregex.GetVariableString(name).Replace("'", "").Replace("\"", ""));
}
else if (NodePattern.IsMatch(chunk))
{
//String name = chunk.Substring(2, chunk.Length - 1);
string name = chunk.Substring(2, chunk.Length - 3);
//label.Append(Matcher.quoteReplacement(tregex.getNode(name).value()));
label.Append(tregex.GetNode(name).Value().Replace("'", "").Replace("\"", ""));
}
else
{
label.Append(chunk);
}
}
//var m = node.labelRegex.Match(nodeToRelabel.label().value());
//nodeToRelabel.label().setValue(m.replaceAll(label.ToString()));
var newS = node.labelRegex.Replace(nodeToRelabel.Label().Value(), label.ToString());
nodeToRelabel.Label().SetValue(/*m.replaceAll(label.ToString())*/ newS);
break;
}
default:
throw new ArgumentException("Unsupported relabel mode " + node.mode);
}
return(tree);
}
public void CanCreateTriplePatternsUsingActualPatternItems()
{
// given
PatternItem s = new VariablePattern("s");
PatternItem p = new VariablePattern("p");
PatternItem o = new VariablePattern("o");
// when
_builder.Subject(s).Predicate(p).Object(o);
// then
Assert.Single(_builder.Patterns);
IMatchTriplePattern pattern = (IMatchTriplePattern)_builder.Patterns.Single();
Assert.Same(s, pattern.Subject);
Assert.Same(p, pattern.Predicate);
Assert.Same(o, pattern.Object);
}
public void SparqlVarNames()
{
List <String> names = new List <String>
{
"?var",
"$var",
"var"
};
foreach (String name in names)
{
SparqlVariable var = new SparqlVariable(name);
Assert.AreEqual("var", var.Name);
VariablePattern varPat = new VariablePattern(name);
Assert.AreEqual("var", varPat.VariableName);
VariableTerm varTerm = new VariableTerm(name);
Assert.AreEqual("var", varTerm.Variables.First());
}
}
public void SparqlVarNames()
{
var names = new List <string>
{
"?var",
"$var",
"var"
};
foreach (var name in names)
{
var var = new SparqlVariable(name);
Assert.Equal("var", var.Name);
var varPat = new VariablePattern(name);
Assert.Equal("var", varPat.VariableName);
var varTerm = new VariableTerm(name);
Assert.Equal("var", varTerm.Variables.First());
}
}
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)));
}
public (SyntaxNode, EnvironmentVariable[]) Interpolate()
{
var captured = new HashSet <EnvironmentVariable>();
var literal = node.Token.ValueText;
var inlined = VariablePattern.Replace(literal, match =>
{
var name = match.Groups["variable"].Value;
if (name == NakeScriptDirectoryVariable)
{
return(Path.GetDirectoryName(filePath));
}
var value = Environment.GetEnvironmentVariable(name) ?? "";
captured.Add(new EnvironmentVariable(name, value));
return(value);
});
var interpolated = node.WithToken(SyntaxFactory.Literal(Unescape(inlined)));
return(interpolated, captured.ToArray());
}
public static Summand Parse(string input)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
if (!SummandPattern.IsMatch(input))
{
throw new FormatException("Invalid format.");
}
string sFactor = FactorPattern.Match(input).Value;
sFactor = AddImplicitOneAsNeeded(sFactor);
var factor = float.Parse(sFactor);
var variables = VariablePattern.Matches(input)
.Cast <Match>().Select(m => Variable.Parse(m.Value));
return(new Summand(factor, variables));
}
public static Variable Parse(string input)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
if (!VariablePattern.IsMatch(input))
{
throw new FormatException("Invalid format.");
}
var parts = input.Split(new[] { '^' }, StringSplitOptions.RemoveEmptyEntries);
char name = parts[0].Single();
if (parts.Length == 2)
{
int power = int.Parse(parts[1]);
return(new Variable(name, power));
}
return(new Variable(name));
}
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));
}
private void ProcessOdataPath()
{
foreach (var seg in QueryOptions.Context.Path.Segments)
{
if (seg is EntitySetSegment)
{
var setSeg = seg as EntitySetSegment;
var entityType = setSeg.EdmType.AsElementType() as EdmEntityType;
var rdfNode = new VariablePattern($"{setSeg.EntitySet.Name}");
EdmNodeList.Add(new EdmNode()
{
Name = setSeg.EntitySet.Name,
ItemEdmType = entityType,
RdfNode = rdfNode,
StructProperties = entityType.StructuralProperties().ToList(),
NavProperties = new List <CustomNavigationProperty>()
});
}
else if (seg is KeySegment)
{
var keys = (seg as KeySegment).Keys.ToList();
Uri keyUri = null;
var edmNode = EdmNodeList[EdmNodeList.Count - 1];
if (keys.Count() > 0)
{
edmNode.IdKey = keys[0].Value.ToString();
if (keys[0].Value.ToString().StartsWith(NamespaceUri.AbsoluteUri))
{
keyUri = new Uri(keys[0].Value.ToString());
}
else
{
keyUri = new Uri(NamespaceUri, keys[0].Value.ToString());
}
}
NodeFactory nodeFactory = new NodeFactory();
edmNode.RdfNode = new NodeMatchPattern(nodeFactory.CreateUriNode(keyUri));
}
else if (seg is NavigationPropertySegment || seg is NavigationPropertyLinkSegment)
{
var propSeg = seg as NavigationPropertySegment;
var propSegLink = seg as NavigationPropertyLinkSegment;
EdmEntityType entityType;
CustomNavigationProperty navProp = new CustomNavigationProperty();
if (propSeg != null)
{
entityType = propSeg.EdmType.AsElementType() as EdmEntityType;
navProp.NavigationProperty = propSeg.NavigationProperty;
}
else
{
entityType = propSegLink.EdmType.AsElementType() as EdmEntityType;
navProp.NavigationProperty = propSegLink.NavigationProperty;
}
var edmNode = EdmNodeList[EdmNodeList.Count - 1];
edmNode.NavProperties.Add(navProp);
EdmNodeList.Add(new EdmNode()
{
Name = navProp.NavigationProperty.Name,
ItemEdmType = entityType,
RdfNode = new VariablePattern($"{navProp.NavigationProperty.Name}"),
StructProperties = entityType.StructuralProperties().ToList(),
NavProperties = new List <CustomNavigationProperty>()
});
}
else if (seg is PropertySegment)
{
var propSeg = seg as PropertySegment;
var edmNode = EdmNodeList[EdmNodeList.Count - 1];
edmNode.StructProperties.Clear();
edmNode.StructProperties.Add(propSeg.Property);
}
else if (seg is CountSegment)
{
}
else if (seg is ValueSegment)
{
}
else
{
throw new Exception($"Error with {seg.ToString()}");
}
}
}
private MatchExpression match()
{
// switch expression {
// case pattern1: result1
// case pattern2 when extr: result2
// }
Expression expr = expression();
consume(TokenType.LBRACE);
List <Pattern> patterns = new List <Pattern>();
do
{
Pattern pattern = null;
Token current = null;
consume(TokenType.CASE);
current = get(0);
if (match(TokenType.NUMBER))
{
// case 0.5:
pattern = new ConstantPattern(new NumberValue(Double.Parse(current.getText(), CultureInfo.InvariantCulture)));
}
else if (match(TokenType.HEX_NUMBER))
{
// case #FF:
pattern = new ConstantPattern(new NumberValue(Convert.ToInt64(current.getText(), 16)));
}
else if (match(TokenType.BIN_NUMBER))
{
// case #FF:
pattern = new ConstantPattern(new NumberValue(Convert.ToInt64(current.getText(), 2)));
}
else if (match(TokenType.OCT_NUMBER))
{
// case #FF:
pattern = new ConstantPattern(new NumberValue(Convert.ToInt64(current.getText(), 8)));
}
else if (match(TokenType.TEXT))
{
// case "text":
pattern = new ConstantPattern(new StringValue(current.getText()));
}
else if (match(TokenType.WORD))
{
// case value:
pattern = new VariablePattern(current.getText());
}
if (pattern == null)
{
throw new Exception("Wrong pattern in match expression: " + current);
}
if (match(TokenType.WHEN))
{
// case e when e > 0:
pattern.optCondition = expression();
}
consume(TokenType.COLON);
if (match(TokenType.LBRACE))
{
pattern.result = block();
}
else
{
pattern.result = new ReturnStatement(expression());
}
patterns.Add(pattern);
} while (!match(TokenType.RBRACE));
return(new MatchExpression(expr, patterns));
}
/// <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
{
HashSet <INode> nodes = new HashSet <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 (ISet 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.ToList());
}
}
static bool Qualifies(string text) => VariablePattern.IsMatch(text) || EscapePattern.IsMatch(text);
