public static IQueryBuilder TraverseNodeToSparql(this QueryNode node, IQueryBuilder queryBuilder,
QueryGraph graph)
{
var incomingEdges = node.GetIncomingEdges(graph);
foreach (var incomingEdge in incomingEdges)
{
if (incomingEdge.Traversed)
{
continue;
}
var sourceNode = incomingEdge.GetSourceNode(graph);
queryBuilder.Where(x => {
x.ToSubject(sourceNode)
.ToPredicate(incomingEdge)
.ToObject(node);
});
if (!sourceNode.IsConstant)
{
var literal = new NodeFactory().CreateLiteralNode($"{Constants.EntityIRI}{Constants.EntityPrefix}");
var expr = new StartsWithFunction(new StrFunction(new VariableTerm(sourceNode.name)),
new ConstantTerm(literal));
queryBuilder.Filter(expr);
}
if (!incomingEdge.IsConstant)
{
var literal =
new NodeFactory().CreateLiteralNode($"{Constants.PropertyIRI}{Constants.PropertyPrefix}");
var expr = new StartsWithFunction(new StrFunction(new VariableTerm(incomingEdge.name)),
new ConstantTerm(literal));
queryBuilder.Filter(expr);
}
if (!node.IsConstant)
{
var literal = new NodeFactory().CreateLiteralNode($"{Constants.EntityIRI}{Constants.EntityPrefix}");
var expr = new StartsWithFunction(new StrFunction(new VariableTerm(node.name)),
new ConstantTerm(literal));
queryBuilder.Filter(expr);
}
incomingEdge.Traversed = true;
sourceNode.TraverseNodeToSparql(queryBuilder, graph);
}
var outgoingEdges = node.GetOutgoingEdges(graph);
foreach (var outgoingEdge in outgoingEdges)
{
if (outgoingEdge.Traversed)
{
continue;
}
var targetNode = outgoingEdge.GetTargetNode(graph);
queryBuilder.Where(x => {
x.ToSubject(node)
.ToPredicate(outgoingEdge)
.ToObject(targetNode);
});
if (!targetNode.IsConstant)
{
var literal = new NodeFactory().CreateLiteralNode($"{Constants.EntityIRI}{Constants.EntityPrefix}");
var expr = new StartsWithFunction(new StrFunction(new VariableTerm(targetNode.name)),
new ConstantTerm(literal));
queryBuilder.Filter(expr);
}
if (!outgoingEdge.IsConstant)
{
var literal =
new NodeFactory().CreateLiteralNode($"{Constants.PropertyIRI}{Constants.PropertyPrefix}");
var expr = new StartsWithFunction(new StrFunction(new VariableTerm(outgoingEdge.name)),
new ConstantTerm(literal));
queryBuilder.Filter(expr);
}
if (!node.IsConstant)
{
var literal = new NodeFactory().CreateLiteralNode($"{Constants.EntityIRI}{Constants.EntityPrefix}");
var expr = new StartsWithFunction(new StrFunction(new VariableTerm(node.name)),
new ConstantTerm(literal));
queryBuilder.Filter(expr);
}
outgoingEdge.Traversed = true;
targetNode.TraverseNodeToSparql(queryBuilder, graph);
}
return(queryBuilder);
}
/// <summary>
/// Tries to create an XPath Function expression if the function Uri correseponds to a supported XPath Function.
/// </summary>
/// <param name="u">Function Uri.</param>
/// <param name="args">Function Arguments.</param>
/// <param name="scalarArgs">Scalar Arguments.</param>
/// <param name="expr">Generated Expression.</param>
/// <returns>Whether an expression was successfully generated.</returns>
public bool TryCreateExpression(Uri u, List <ISparqlExpression> args, Dictionary <String, ISparqlExpression> scalarArgs, out ISparqlExpression expr)
{
// If any Scalar Arguments are present then can't possibly be an XPath Function
if (scalarArgs.Count > 0)
{
expr = null;
return(false);
}
String func = u.AbsoluteUri;
if (func.StartsWith(XPathFunctionsNamespace))
{
func = func.Substring(XPathFunctionsNamespace.Length);
ISparqlExpression xpathFunc = null;
switch (func)
{
case Absolute:
if (args.Count == 1)
{
xpathFunc = new AbsFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath abs() function");
}
break;
case AdjustDateTimeToTimezone:
throw new NotSupportedException("XPath adjust-dateTime-to-timezone() function is not supported");
case Boolean:
if (args.Count == 1)
{
xpathFunc = new BooleanFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath boolean() function");
}
throw new NotSupportedException("XPath boolean() function is not supported");
case Ceiling:
if (args.Count == 1)
{
xpathFunc = new CeilingFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath ceiling() function");
}
break;
case Compare:
if (args.Count == 2)
{
xpathFunc = new CompareFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath compare() function");
}
break;
case Concat:
if (args.Count == 2)
{
xpathFunc = new ConcatFunction(args.First(), args.Last());
}
else if (args.Count > 2)
{
xpathFunc = new ConcatFunction(args);
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath concat() function");
}
break;
case Contains:
if (args.Count == 2)
{
xpathFunc = new ContainsFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath contains() function");
}
break;
case DayFromDateTime:
if (args.Count == 1)
{
xpathFunc = new DayFromDateTimeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath day-from-dateTime() function");
}
break;
case EncodeForURI:
if (args.Count == 1)
{
xpathFunc = new EncodeForUriFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath encode-for-uri() function");
}
break;
case EndsWith:
if (args.Count == 2)
{
xpathFunc = new EndsWithFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath ends-with() function");
}
break;
case EscapeHtmlURI:
if (args.Count == 1)
{
xpathFunc = new EscapeHtmlUriFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath escape-html-uri() function");
}
break;
case False:
if (args.Count == 0)
{
xpathFunc = new ConstantTerm(new BooleanNode(null, false));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath false() function");
}
break;
case Floor:
if (args.Count == 1)
{
xpathFunc = new FloorFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath floor() function");
}
break;
case HoursFromDateTime:
if (args.Count == 1)
{
xpathFunc = new HoursFromDateTimeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath hours-from-dateTime() function");
}
break;
case LowerCase:
if (args.Count == 1)
{
xpathFunc = new LowerCaseFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath lower-case() function");
}
break;
case Matches:
if (args.Count == 2)
{
xpathFunc = new Functions.Sparql.Boolean.RegexFunction(args.First(), args.Last());
}
else if (args.Count == 3)
{
xpathFunc = new Functions.Sparql.Boolean.RegexFunction(args.First(), args[1], args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath matches() function");
}
break;
case MinutesFromDateTime:
if (args.Count == 1)
{
xpathFunc = new MinutesFromDateTimeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath minutes-from-dateTime() function");
}
break;
case MonthFromDateTime:
if (args.Count == 1)
{
xpathFunc = new MonthFromDateTimeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath month-from-dateTime() function");
}
break;
case NormalizeSpace:
if (args.Count == 1)
{
xpathFunc = new NormalizeSpaceFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath normalize-space() function");
}
break;
case NormalizeUnicode:
if (args.Count == 1)
{
xpathFunc = new NormalizeUnicodeFunction(args.First());
}
else if (args.Count == 2)
{
xpathFunc = new NormalizeUnicodeFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath normalize-space() function");
}
break;
case Not:
if (args.Count == 1)
{
xpathFunc = new NotExpression(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath not() function");
}
break;
case Replace:
if (args.Count == 3)
{
xpathFunc = new ReplaceFunction(args.First(), args[1], args.Last());
}
else if (args.Count == 4)
{
xpathFunc = new ReplaceFunction(args.First(), args[1], args[2], args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath replace() function");
}
break;
case Round:
if (args.Count == 1)
{
xpathFunc = new RoundFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath round() function");
}
break;
case RoundHalfToEven:
if (args.Count == 1)
{
xpathFunc = new RoundHalfToEvenFunction(args.First());
}
else if (args.Count == 2)
{
xpathFunc = new RoundHalfToEvenFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath round-half-to-even() function");
}
break;
case SecondsFromDateTime:
if (args.Count == 1)
{
xpathFunc = new SecondsFromDateTimeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath seconds-from-dateTime() function");
}
break;
case StartsWith:
if (args.Count == 2)
{
xpathFunc = new StartsWithFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath starts-with() function");
}
break;
case StringJoin:
if (args.Count == 1)
{
xpathFunc = new AggregateTerm(new StringJoinAggregate(args.First()));
}
else if (args.Count == 2)
{
xpathFunc = new AggregateTerm(new StringJoinAggregate(args.First(), args.Last()));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath string-join() function");
}
break;
case StringLength:
if (args.Count == 1)
{
xpathFunc = new StringLengthFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath string-length() function");
}
break;
case Substring:
if (args.Count == 2)
{
xpathFunc = new SubstringFunction(args.First(), args.Last());
}
else if (args.Count == 3)
{
xpathFunc = new SubstringFunction(args.First(), args[1], args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath substring() function");
}
break;
case SubstringAfter:
if (args.Count == 2)
{
xpathFunc = new SubstringAfterFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath substring-after() function");
}
break;
case SubstringBefore:
if (args.Count == 2)
{
xpathFunc = new SubstringBeforeFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath substring-before() function");
}
break;
case TimezoneFromDateTime:
if (args.Count == 1)
{
xpathFunc = new TimezoneFromDateTimeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath timezone-from-dateTime() function");
}
break;
case Translate:
throw new NotSupportedException("XPath translate() function is not supported");
case True:
if (args.Count == 0)
{
xpathFunc = new ConstantTerm(new BooleanNode(null, true));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath true() function");
}
break;
case UpperCase:
if (args.Count == 1)
{
xpathFunc = new UpperCaseFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath upper-case() function");
}
break;
case YearFromDateTime:
if (args.Count == 1)
{
xpathFunc = new YearFromDateTimeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the XPath year-from-dateTime() function");
}
break;
}
if (xpathFunc != null)
{
expr = xpathFunc;
return(true);
}
}
expr = null;
return(false);
}
public void TestNullSubString()
{
var function = new StartsWithFunction();
Assert.That(function.Evaluate("a", null), Is.EqualTo(true));
}
public void TestNullSource()
{
var function = new StartsWithFunction();
Assert.That(function.Evaluate(null, "a"), Is.EqualTo(false));
}
public void TestNullBoth()
{
var function = new StartsWithFunction();
Assert.That(function.Evaluate(null, null), Is.EqualTo(true));
}
public void TestNotContains()
{
var function = new StartsWithFunction();
Assert.That(function.Evaluate("bcdefg", "a"), Is.EqualTo(false));
}
public void TestNotAtTheEnd()
{
var function = new StartsWithFunction();
Assert.That(function.Evaluate("0abcdefg", "a"), Is.EqualTo(false));
}