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);
        }
Пример #3
0
        public void TestNullSubString()
        {
            var function = new StartsWithFunction();

            Assert.That(function.Evaluate("a", null), Is.EqualTo(true));
        }
Пример #4
0
        public void TestNullSource()
        {
            var function = new StartsWithFunction();

            Assert.That(function.Evaluate(null, "a"), Is.EqualTo(false));
        }
Пример #5
0
        public void TestNullBoth()
        {
            var function = new StartsWithFunction();

            Assert.That(function.Evaluate(null, null), Is.EqualTo(true));
        }
Пример #6
0
        public void TestNotContains()
        {
            var function = new StartsWithFunction();

            Assert.That(function.Evaluate("bcdefg", "a"), Is.EqualTo(false));
        }
Пример #7
0
        public void TestNotAtTheEnd()
        {
            var function = new StartsWithFunction();

            Assert.That(function.Evaluate("0abcdefg", "a"), Is.EqualTo(false));
        }