示例#1
0
        /// <summary>
        /// Formats a Triple Pattern in nicely formatted SPARQL syntax
        /// </summary>
        /// <param name="tp">Triple Pattern</param>
        /// <returns></returns>
        public virtual String Format(ITriplePattern tp)
        {
            StringBuilder output = new StringBuilder();

            switch (tp.PatternType)
            {
            case TriplePatternType.Match:
                IMatchTriplePattern match = (IMatchTriplePattern)tp;
                output.Append(this.Format(match.Subject, TripleSegment.Subject));
                output.Append(' ');
                output.Append(this.Format(match.Predicate, TripleSegment.Predicate));
                output.Append(' ');
                output.Append(this.Format(match.Object, TripleSegment.Object));
                output.Append(" .");
                break;

            case TriplePatternType.Filter:
                IFilterPattern filter = (IFilterPattern)tp;
                output.Append("FILTER(");
                output.Append(this.FormatExpression(filter.Filter.Expression));
                output.Append(")");
                break;

            case TriplePatternType.SubQuery:
                ISubQueryPattern subquery = (ISubQueryPattern)tp;
                output.AppendLine("{");
                output.AppendLineIndented(this.Format(subquery.SubQuery), 2);
                output.AppendLine("}");
                break;

            case TriplePatternType.Path:
                IPropertyPathPattern path = (IPropertyPathPattern)tp;
                output.Append(this.Format(path.Subject, TripleSegment.Subject));
                output.Append(' ');
                output.Append(this.FormatPath(path.Path));
                output.Append(' ');
                output.Append(this.Format(path.Object, TripleSegment.Object));
                output.Append(" .");
                break;

            case TriplePatternType.LetAssignment:
                IAssignmentPattern let = (IAssignmentPattern)tp;
                output.Append("LET(?");
                output.Append(let.VariableName);
                output.Append(" := ");
                output.Append(this.FormatExpression(let.AssignExpression));
                output.Append(")");
                break;

            case TriplePatternType.BindAssignment:
                IAssignmentPattern bind = (IAssignmentPattern)tp;
                output.Append("BIND (");
                output.Append(this.FormatExpression(bind.AssignExpression));
                output.Append(" AS ?");
                output.Append(bind.VariableName);
                output.Append(")");
                break;

            case TriplePatternType.PropertyFunction:
                IPropertyFunctionPattern propFunc = (IPropertyFunctionPattern)tp;
                if (propFunc.SubjectArgs.Count() > 1)
                {
                    output.Append("( ");
                    foreach (PatternItem arg in propFunc.SubjectArgs)
                    {
                        output.Append(this.Format(arg, TripleSegment.Subject));
                        output.Append(' ');
                    }
                    output.Append(')');
                }
                else
                {
                    output.Append(this.Format(propFunc.SubjectArgs.First(), TripleSegment.Subject));
                }
                output.Append(" <");
                output.Append(this.FormatUri(propFunc.PropertyFunction.FunctionUri));
                output.Append("> ");
                if (propFunc.ObjectArgs.Count() > 1)
                {
                    output.Append("( ");
                    foreach (PatternItem arg in propFunc.ObjectArgs)
                    {
                        output.Append(this.Format(arg, TripleSegment.Object));
                        output.Append(' ');
                    }
                    output.Append(')');
                }
                else
                {
                    output.Append(this.Format(propFunc.ObjectArgs.First(), TripleSegment.Object));
                }
                output.Append(" .");
                break;

            default:
                throw new RdfOutputException("Unable to Format an unknown ITriplePattern implementation as a String");
            }

            return(output.ToString());
        }
        /// <summary>
        /// Attempts to do variable substitution within the given algebra
        /// </summary>
        /// <param name="algebra">Algebra</param>
        /// <returns></returns>
        public ISparqlAlgebra Optimise(ISparqlAlgebra algebra)
        {
            // By default we are only safe to replace objects in a scope if we are replacing with a constant
            // Note that if we also make a replace in a subject/predicate position for a variable replace then
            // that makes object replacement safe for that scope only
            bool canReplaceObjects = (this._canReplaceCustom ? this._canReplaceObjects : this._replaceItem is NodeMatchPattern);

            if (algebra is IBgp)
            {
                IBgp bgp = (IBgp)algebra;
                if (bgp.PatternCount == 0)
                {
                    return(bgp);
                }

                // Do variable substitution on the patterns
                List <ITriplePattern> ps = new List <ITriplePattern>();
                foreach (ITriplePattern p in bgp.TriplePatterns)
                {
                    switch (p.PatternType)
                    {
                    case TriplePatternType.Match:
                        IMatchTriplePattern tp   = (IMatchTriplePattern)p;
                        PatternItem         subj = tp.Subject.VariableName != null && tp.Subject.VariableName.Equals(this._findVar) ? this._replaceItem : tp.Subject;
                        if (ReferenceEquals(subj, this._replaceItem))
                        {
                            canReplaceObjects = (this._canReplaceCustom ? this._canReplaceObjects : true);
                        }
                        PatternItem pred = tp.Predicate.VariableName != null && tp.Predicate.VariableName.Equals(this._findVar) ? this._replaceItem : tp.Predicate;
                        if (ReferenceEquals(pred, this._replaceItem))
                        {
                            canReplaceObjects = (this._canReplaceCustom ? this._canReplaceObjects : true);
                        }
                        PatternItem obj = tp.Object.VariableName != null && tp.Object.VariableName.Equals(this._findVar) ? this._replaceItem : tp.Object;
                        if (ReferenceEquals(obj, this._replaceItem) && !canReplaceObjects)
                        {
                            throw new Exception("Unable to substitute a variable into the object position in this scope");
                        }
                        ps.Add(new TriplePattern(subj, pred, obj));
                        break;

                    case TriplePatternType.Filter:
                        IFilterPattern fp = (IFilterPattern)p;
                        ps.Add(new FilterPattern(new UnaryExpressionFilter(this.Transform(fp.Filter.Expression))));
                        break;

                    case TriplePatternType.BindAssignment:
                        IAssignmentPattern bp = (IAssignmentPattern)p;
                        ps.Add(new BindPattern(bp.VariableName, this.Transform(bp.AssignExpression)));
                        break;

                    case TriplePatternType.LetAssignment:
                        IAssignmentPattern lp = (IAssignmentPattern)p;
                        ps.Add(new LetPattern(lp.VariableName, this.Transform(lp.AssignExpression)));
                        break;

                    case TriplePatternType.SubQuery:
                        throw new RdfQueryException("Cannot do variable substitution when a sub-query is present");

                    case TriplePatternType.Path:
                        throw new RdfQueryException("Cannot do variable substitution when a property path is present");

                    case TriplePatternType.PropertyFunction:
                        throw new RdfQueryException("Cannot do variable substituion when a property function is present");

                    default:
                        throw new RdfQueryException("Cannot do variable substitution on unknown triple patterns");
                    }
                }
                return(new Bgp(ps));
            }
            else if (algebra is Service)
            {
                throw new RdfQueryException("Cannot do variable substitution when a SERVICE clause is present");
            }
            else if (algebra is SubQuery)
            {
                throw new RdfQueryException("Cannot do variable substitution when a sub-query is present");
            }
            else if (algebra is IPathOperator)
            {
                throw new RdfQueryException("Cannot do variable substitution when a property path is present");
            }
            else if (algebra is Algebra.Graph)
            {
                Algebra.Graph g = (Algebra.Graph)((IUnaryOperator)algebra).Transform(this);
                if (g.GraphSpecifier is VariableToken && g.GraphSpecifier.Value.Equals("?" + this._findVar))
                {
                    if (this._replaceToken != null)
                    {
                        return(new Algebra.Graph(g.InnerAlgebra, this._replaceToken));
                    }
                    else
                    {
                        throw new RdfQueryException("Cannot do a variable substitution when the variable is used for a GRAPH specifier and the replacement term is not a URI");
                    }
                }
                else
                {
                    return(g);
                }
            }
            else if (algebra is IUnaryOperator)
            {
                return(((IUnaryOperator)algebra).Transform(this));
            }
            else if (algebra is IAbstractJoin)
            {
                return(((IAbstractJoin)algebra).Transform(this));
            }
            else if (algebra is ITerminalOperator)
            {
                return(algebra);
            }
            else
            {
                throw new RdfQueryException("Cannot do variable substitution on unknown algebra");
            }
        }
示例#3
0
        private BaseMultiset StreamingEvaluate(SparqlEvaluationContext context, int pattern, out bool halt)
        {
            // Remember to check for Timeouts during Lazy Evaluation
            context.CheckTimeout();

            halt = false;

            // Handle Empty BGPs
            if (pattern == 0 && _triplePatterns.Count == 0)
            {
                context.OutputMultiset = new IdentityMultiset();
                return(context.OutputMultiset);
            }

            BaseMultiset initialInput, localOutput, results = null;

            // Determine whether the Pattern modifies the existing Input rather than joining to it
            bool modifies = (_triplePatterns[pattern].PatternType == TriplePatternType.Filter);
            bool extended = (pattern > 0 && _triplePatterns[pattern - 1].PatternType == TriplePatternType.BindAssignment);
            bool modified = (pattern > 0 && _triplePatterns[pattern - 1].PatternType == TriplePatternType.Filter);

            // Set up the Input and Output Multiset appropriately
            switch (pattern)
            {
            case 0:
                // Input is as given and Output is new empty multiset
                if (!modifies)
                {
                    initialInput = context.InputMultiset;
                }
                else
                {
                    // If the Pattern will modify the Input and is the first thing in the BGP then it actually modifies a new empty input
                    // This takes care of FILTERs being out of scope
                    initialInput = new Multiset();
                }
                localOutput = new Multiset();
                break;

            case 1:
                // Input becomes current Output and Output is new empty multiset
                initialInput = context.OutputMultiset;
                localOutput  = new Multiset();
                break;

            default:
                if (!extended && !modified)
                {
                    // Input is join of previous input and output and Output is new empty multiset
                    if (context.InputMultiset.IsDisjointWith(context.OutputMultiset))
                    {
                        // Disjoint so do a Product
                        initialInput = context.InputMultiset.ProductWithTimeout(context.OutputMultiset, context.RemainingTimeout);
                    }
                    else
                    {
                        // Normal Join
                        initialInput = context.InputMultiset.Join(context.OutputMultiset);
                    }
                }
                else
                {
                    initialInput = context.OutputMultiset;
                }
                localOutput = new Multiset();
                break;
            }
            context.InputMultiset  = initialInput;
            context.OutputMultiset = localOutput;

            // Get the Triple Pattern we're evaluating
            ITriplePattern temp         = _triplePatterns[pattern];
            int            resultsFound = 0;
            int            prevResults  = -1;

            if (temp.PatternType == TriplePatternType.Match)
            {
                // Find the first Triple which matches the Pattern
                IMatchTriplePattern  tp = (IMatchTriplePattern)temp;
                IEnumerable <Triple> ts = tp.GetTriples(context);

                // In the case that we're lazily evaluating an optimisable ORDER BY then
                // we need to apply OrderBy()'s to our enumeration
                // This only applies to the 1st pattern
                if (pattern == 0)
                {
                    if (context.Query != null)
                    {
                        if (context.Query.OrderBy != null && context.Query.IsOptimisableOrderBy)
                        {
                            IComparer <Triple> comparer = context.Query.OrderBy.GetComparer(tp);
                            if (comparer != null)
                            {
                                ts = ts.OrderBy(t => t, comparer);
                            }
                            else
                            {
                                // Can't get a comparer so can't optimise
                                // Thus required results is everything so just use normal evaluation as otherwise
                                // lazy evaluation will significantly impact performance and lead to an apparent infinite loop
                                return(base.Evaluate(context));
                            }
                        }
                    }
                }

                foreach (Triple t in ts)
                {
                    if (tp.Accepts(context, t))
                    {
                        resultsFound++;
                        if (tp.IndexType == TripleIndexType.NoVariables)
                        {
                            localOutput            = new IdentityMultiset();
                            context.OutputMultiset = localOutput;
                        }
                        else
                        {
                            context.OutputMultiset.Add(tp.CreateResult(t));
                        }
                    }
                }
                // Recurse unless we're the last pattern
                if (pattern < _triplePatterns.Count - 1)
                {
                    results = StreamingEvaluate(context, pattern + 1, out halt);

                    // If recursion leads to a halt then we halt and return immediately
                    if (halt && results.Count >= _requiredResults && _requiredResults != -1)
                    {
                        return(results);
                    }
                    else if (halt)
                    {
                        if (results.Count == 0)
                        {
                            // If recursing leads to no results then eliminate all outputs
                            // Also reset to prevResults to -1
                            resultsFound = 0;
                            localOutput  = new Multiset();
                            prevResults  = -1;
                        }
                        else if (prevResults > -1)
                        {
                            if (results.Count == prevResults)
                            {
                                // If the amount of results found hasn't increased then this match does not
                                // generate any further solutions further down the recursion so we can eliminate
                                // this from the results
                                localOutput.Remove(localOutput.SetIDs.Max());
                            }
                        }
                        prevResults = results.Count;

                        // If we're supposed to halt but not reached the number of required results then continue
                        context.InputMultiset  = initialInput;
                        context.OutputMultiset = localOutput;
                    }
                    else
                    {
                        // Otherwise we need to keep going here
                        // So must reset our input and outputs before continuing
                        context.InputMultiset  = initialInput;
                        context.OutputMultiset = new Multiset();
                        resultsFound--;
                    }
                }
                else
                {
                    // If we're at the last pattern and we've found a match then we can halt
                    halt = true;

                    // Generate the final output and return it
                    if (context.InputMultiset.IsDisjointWith(context.OutputMultiset))
                    {
                        // Disjoint so do a Product
                        results = context.InputMultiset.ProductWithTimeout(context.OutputMultiset,
                                                                           context.RemainingTimeout);
                    }
                    else
                    {
                        // Normal Join
                        results = context.InputMultiset.Join(context.OutputMultiset);
                    }

                    // If not reached required number of results continue
                    if (results.Count >= _requiredResults && _requiredResults != -1)
                    {
                        context.OutputMultiset = results;
                        return(context.OutputMultiset);
                    }
                }
                context.InputMultiset = results;
            }
            else if (temp.PatternType == TriplePatternType.Filter)
            {
                IFilterPattern    filter     = (IFilterPattern)temp;
                ISparqlExpression filterExpr = filter.Filter.Expression;

                if (filter.Variables.IsDisjoint(context.InputMultiset.Variables))
                {
                    // Filter is Disjoint so determine whether it has any affect or not
                    if (filter.Variables.Any())
                    {
                        // Has Variables but disjoint from input => not in scope so gets ignored

                        // Do we recurse or not?
                        if (pattern < _triplePatterns.Count - 1)
                        {
                            // Recurse and return
                            results = StreamingEvaluate(context, pattern + 1, out halt);
                            return(results);
                        }
                        else
                        {
                            // We don't affect the input in any way so just return it
                            return(context.InputMultiset);
                        }
                    }
                    else
                    {
                        // No Variables so have to evaluate it to see if it gives true otherwise
                        try
                        {
                            if (filterExpr.Evaluate(context, 0).AsSafeBoolean())
                            {
                                if (pattern < _triplePatterns.Count - 1)
                                {
                                    // Recurse and return
                                    results = StreamingEvaluate(context, pattern + 1, out halt);
                                    return(results);
                                }
                                else
                                {
                                    // Last Pattern and we evaluate to true so can return the input as-is
                                    halt = true;
                                    return(context.InputMultiset);
                                }
                            }
                        }
                        catch (RdfQueryException)
                        {
                            // Evaluates to false so eliminates all solutions (use an empty Multiset)
                            return(new Multiset());
                        }
                    }
                }
                else
                {
                    // Test each solution found so far against the Filter and eliminate those that evalute to false/error
                    foreach (int id in context.InputMultiset.SetIDs.ToList())
                    {
                        try
                        {
                            if (filterExpr.Evaluate(context, id).AsSafeBoolean())
                            {
                                // If evaluates to true then add to output
                                context.OutputMultiset.Add(context.InputMultiset[id].Copy());
                            }
                        }
                        catch (RdfQueryException)
                        {
                            // Error means we ignore the solution
                        }
                    }

                    // Remember to check for Timeouts during Lazy Evaluation
                    context.CheckTimeout();

                    // Decide whether to recurse or not
                    resultsFound = context.OutputMultiset.Count;
                    if (pattern < _triplePatterns.Count - 1)
                    {
                        // Recurse then return
                        // We can never decide whether to recurse again at this point as we are not capable of deciding
                        // which solutions should be dumped (that is the job of an earlier pattern in the BGP)
                        results = StreamingEvaluate(context, pattern + 1, out halt);

                        return(results);
                    }
                    else
                    {
                        halt = true;

                        // However many results we need we'll halt - previous patterns can call us again if they find more potential solutions
                        // for us to filter
                        return(context.OutputMultiset);
                    }
                }
            }
            else if (temp is BindPattern)
            {
                BindPattern       bind     = (BindPattern)temp;
                ISparqlExpression bindExpr = bind.AssignExpression;
                String            bindVar  = bind.VariableName;

                if (context.InputMultiset.ContainsVariable(bindVar))
                {
                    throw new RdfQueryException(
                              "Cannot use a BIND assigment to BIND to a variable that has previously been used in the Query");
                }
                else
                {
                    // Compute the Binding for every value
                    context.OutputMultiset.AddVariable(bindVar);
                    foreach (ISet s in context.InputMultiset.Sets)
                    {
                        ISet x = s.Copy();
                        try
                        {
                            INode val = bindExpr.Evaluate(context, s.ID);
                            x.Add(bindVar, val);
                        }
                        catch (RdfQueryException)
                        {
                            // Equivalent to no assignment but the solution is preserved
                        }
                        context.OutputMultiset.Add(x.Copy());
                    }

                    // Remember to check for Timeouts during Lazy Evaluation
                    context.CheckTimeout();

                    // Decide whether to recurse or not
                    resultsFound = context.OutputMultiset.Count;
                    if (pattern < _triplePatterns.Count - 1)
                    {
                        // Recurse then return
                        results = StreamingEvaluate(context, pattern + 1, out halt);
                        return(results);
                    }
                    else
                    {
                        halt = true;

                        // However many results we need we'll halt - previous patterns can call us again if they find more potential solutions
                        // for us to extend
                        return(context.OutputMultiset);
                    }
                }
            }
            else
            {
                throw new RdfQueryException("Encountered a " + temp.GetType().FullName +
                                            " which is not a lazily evaluable Pattern");
            }

            // If we found no possibles we return the null multiset
            if (resultsFound == 0)
            {
                return(new NullMultiset());
            }
            else
            {
                // Remember to check for Timeouts during Lazy Evaluation
                context.CheckTimeout();

                // Generate the final output and return it
                if (!modifies)
                {
                    if (context.InputMultiset.IsDisjointWith(context.OutputMultiset))
                    {
                        // Disjoint so do a Product
                        results = context.InputMultiset.ProductWithTimeout(context.OutputMultiset, context.RemainingTimeout);
                    }
                    else
                    {
                        // Normal Join
                        results = context.InputMultiset.Join(context.OutputMultiset);
                    }
                    context.OutputMultiset = results;
                }
                return(context.OutputMultiset);
            }
        }
示例#4
0
        private BaseMultiset StreamingEvaluate(SparqlEvaluationContext context, int pattern, out bool halt)
        {
            halt = false;

            //Handle Empty BGPs
            if (pattern == 0 && this._triplePatterns.Count == 0)
            {
                context.OutputMultiset = new IdentityMultiset();
                return(context.OutputMultiset);
            }

            BaseMultiset initialInput, localOutput, results;

            //Set up the Input and Output Multiset appropriately
            switch (pattern)
            {
            case 0:
                //Input is as given and Output is new empty multiset
                initialInput = context.InputMultiset;
                localOutput  = new Multiset();
                break;

            case 1:
                //Input becomes current Output and Output is new empty multiset
                initialInput = context.OutputMultiset;
                localOutput  = new Multiset();
                break;

            default:
                //Input is join of previous input and ouput and Output is new empty multiset
                if (context.InputMultiset.IsDisjointWith(context.OutputMultiset))
                {
                    //Disjoint so do a Product
                    initialInput = context.InputMultiset.Product(context.OutputMultiset);
                }
                else
                {
                    //Normal Join
                    initialInput = context.InputMultiset.Join(context.OutputMultiset);
                }
                localOutput = new Multiset();
                break;
            }
            context.InputMultiset  = initialInput;
            context.OutputMultiset = localOutput;

            //Get the Triple Pattern we're evaluating
            ITriplePattern temp         = this._triplePatterns[pattern];
            int            resultsFound = 0;

            if (temp.PatternType == TriplePatternType.Match)
            {
                //Find the first Triple which matches the Pattern
                IMatchTriplePattern tp = (IMatchTriplePattern)temp;
                foreach (Triple t in tp.GetTriples(context))
                {
                    //Remember to check for Timeout during lazy evaluation
                    context.CheckTimeout();

                    if (tp.Accepts(context, t))
                    {
                        resultsFound++;
                        context.OutputMultiset.Add(tp.CreateResult(t));

                        //Recurse unless we're the last pattern
                        if (pattern < this._triplePatterns.Count - 1)
                        {
                            results = this.StreamingEvaluate(context, pattern + 1, out halt);

                            //If recursion leads to a halt then we halt and return immediately
                            if (halt)
                            {
                                return(results);
                            }

                            //Otherwise we need to keep going here
                            //So must reset our input and outputs before continuing
                            context.InputMultiset  = initialInput;
                            context.OutputMultiset = new Multiset();
                            resultsFound--;
                        }
                        else
                        {
                            //If we're at the last pattern and we've found a match then we can halt
                            halt = true;

                            //Generate the final output and return it
                            if (context.InputMultiset.IsDisjointWith(context.OutputMultiset))
                            {
                                //Disjoint so do a Product
                                context.OutputMultiset = context.InputMultiset.ProductWithTimeout(context.OutputMultiset, context.QueryTimeout - context.QueryTime);
                            }
                            else
                            {
                                //Normal Join
                                context.OutputMultiset = context.InputMultiset.Join(context.OutputMultiset);
                            }
                            return(context.OutputMultiset);
                        }
                    }
                }
            }
            else if (temp.PatternType == TriplePatternType.Filter)
            {
                IFilterPattern    fp     = (IFilterPattern)temp;
                ISparqlFilter     filter = fp.Filter;
                ISparqlExpression expr   = filter.Expression;

                //Find the first result of those we've got so far that matches
                if (context.InputMultiset is IdentityMultiset || context.InputMultiset.IsEmpty)
                {
                    try
                    {
                        //If the Input is the Identity Multiset then the Output is either
                        //the Identity/Null Multiset depending on whether the Expression evaluates to true
                        if (expr.Evaluate(context, 0).AsSafeBoolean())
                        {
                            context.OutputMultiset = new IdentityMultiset();
                        }
                        else
                        {
                            context.OutputMultiset = new NullMultiset();
                        }
                    }
                    catch
                    {
                        //If Expression fails to evaluate then result is NullMultiset
                        context.OutputMultiset = new NullMultiset();
                    }
                }
                else
                {
                    foreach (int id in context.InputMultiset.SetIDs)
                    {
                        //Remember to check for Timeout during lazy evaluation
                        context.CheckTimeout();

                        try
                        {
                            if (expr.Evaluate(context, id).AsSafeBoolean())
                            {
                                resultsFound++;
                                context.OutputMultiset.Add(context.InputMultiset[id].Copy());

                                //Recurse unless we're the last pattern
                                if (pattern < this._triplePatterns.Count - 1)
                                {
                                    results = this.StreamingEvaluate(context, pattern + 1, out halt);

                                    //If recursion leads to a halt then we halt and return immediately
                                    if (halt)
                                    {
                                        return(results);
                                    }

                                    //Otherwise we need to keep going here
                                    //So must reset our input and outputs before continuing
                                    context.InputMultiset  = initialInput;
                                    context.OutputMultiset = new Multiset();
                                    resultsFound--;
                                }
                                else
                                {
                                    //If we're at the last pattern and we've found a match then we can halt
                                    halt = true;

                                    //Generate the final output and return it
                                    if (context.InputMultiset.IsDisjointWith(context.OutputMultiset))
                                    {
                                        //Disjoint so do a Product
                                        context.OutputMultiset = context.InputMultiset.ProductWithTimeout(context.OutputMultiset, context.RemainingTimeout);
                                    }
                                    else
                                    {
                                        //Normal Join
                                        context.OutputMultiset = context.InputMultiset.Join(context.OutputMultiset);
                                    }
                                    return(context.OutputMultiset);
                                }
                            }
                        }
                        catch
                        {
                            //Ignore expression evaluation errors
                        }
                    }
                }
            }

            //If we found no possibles we return the null multiset
            if (resultsFound == 0)
            {
                return(new NullMultiset());
            }

            //We should never reach here so throw an error to that effect
            //The reason we'll never reach here is that this method should always return earlier
            throw new RdfQueryException("Unexpected control flow in evaluating a Streamed BGP for an ASK query");
        }
示例#5
0
 /// <summary>
 /// Compares a filter pattern to another
 /// </summary>
 /// <param name="other">Pattern</param>
 /// <returns></returns>
 public int CompareTo(IFilterPattern other)
 {
     return(base.CompareTo(other));
 }