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