public MetaTabDetailViewModel()
{
// タブ名
TabName = MetaItemGroup
.Select(x => x.Name)
.ToReadOnlyReactiveProperty();
// MetaItemの文字列フィルタリング
MetaItemGroup
.CombineLatest(FilterPattern, IsFilterFavorite,
(MetaGroup, Pattern, IsFav) => (MetaGroup, Pattern, IsFav))
.Subscribe(x => UpdateFilterMetaItems(x.MetaGroup.Items, GetFilterPredicate(x.Pattern, x.IsFav)));
// MetaItemのフィルタ文字列の削除
ClearFilterPatternCommand = FilterPattern
.Select(x => !string.IsNullOrEmpty(x))
.ToReactiveCommand();
ClearFilterPatternCommand.Subscribe(x_ => FilterPattern.Value = "");
// お気に入りのみ表示
SwitchFavoriteFilterCommand = new DelegateCommand(() => IsFilterFavorite.Value = !IsFilterFavorite.Value);
// カラム選択で色付け
SelectedItem.Subscribe(x => x?.SwitchMark());
IsActiveChanged += ViewIsActiveChanged;
}
public IFunction AddLogGroupTriggerToLambda(string id, IFunction lambdaFunction, ILogGroup logGroup)
{
logGroup.AddSubscriptionFilter(id, new SubscriptionFilterOptions
{
Destination = new LambdaDestination(lambdaFunction),
FilterPattern = FilterPattern.AllEvents()
});
return(lambdaFunction);
}
public override bool CanMap(IFilter filter)
{
var filterName = GetFilterName(filter);
var result = filterName != null;
if (result)
{
result = FilterPattern.Match(filterName).Success;
}
return(result);
}
/// <summary>
/// DataTableにデータを投入する
/// </summary>
/// <param name="list"></param>
public void SetPatterns(List <FilterPattern> list)
{
foreach (FilterPattern ptn in list)
{
FilterPattern fp = (FilterPattern)ptn;
DataRow dr = this.DataSource.NewRow();
dr[0] = this.DataSource.Rows.Count + 1;
dr[1] = fp.Enable;
dr[2] = fp.RegularExp;
dr[3] = fp.Comment;
this.DataSource.Rows.Add(dr);
}
}
public override List <Token> ApplyFilter(List <Token> tokens)
{
var from = 0;
var patternRes = FilterPattern.GetMatch(tokens, from);
while (patternRes.IsFullMatch)
{
tokens.RemoveRange(patternRes.Start, patternRes.Length);
from = patternRes.Start;
patternRes = FilterPattern.GetMatch(tokens, from);
}
return(tokens);
}
public override List <Token> ApplyFilter(List <Token> tokens)
{
var matchResult = FilterPattern.GetMatch(tokens);
while (matchResult.IsPartMatch)
{
var tokensToApplyRule = TokenUtils.GetMatchResultTokens(tokens, matchResult);
tokensToApplyRule = EditFunc(tokensToApplyRule);
tokens.RemoveRange(matchResult.Start, matchResult.Length);
tokens.InsertRange(matchResult.Start, tokensToApplyRule);
matchResult = FilterPattern.GetMatch(tokens, matchResult.Start + tokensToApplyRule.Count);
}
return(tokens);
}
/// <summary>
/// DataTableからデータを取り出す
/// </summary>
/// <returns></returns>
public new List <FilterPattern> GetPatterns()
{
List <FilterPattern> list = new List <FilterPattern>();
foreach (DataRow dr in this.DataSource.Rows)
{
string[] strs = new string[3];
strs[0] = dr[1].ToString(); // フラグ
strs[1] = dr[2].ToString().Trim(); // 正規表現
strs[2] = dr[3].ToString().Trim(); // コメント
// 正規表現が設定されていないものは無視
if (string.IsNullOrEmpty(strs[1]))
{
continue;
}
FilterPattern ptn = new FilterPattern(strs);
list.Add(ptn);
}
return(list);
}
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 = null;
//Determine whether the Pattern modifies the existing Input rather than joining to it
bool modifies = (this._triplePatterns[pattern] is FilterPattern);
bool extended = (pattern > 0 && this._triplePatterns[pattern - 1] is BindPattern);
bool modified = (pattern > 0 && this._triplePatterns[pattern - 1] is FilterPattern);
//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 = this._triplePatterns[pattern];
int resultsFound = 0;
int prevResults = -1;
if (temp is TriplePattern)
{
//Find the first Triple which matches the Pattern
TriplePattern tp = (TriplePattern)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
this._requiredResults = -1;
}
}
}
}
foreach (Triple t in ts)
{
//Remember to check for Timeouts during Lazy Evaluation
context.CheckTimeout();
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 < 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 && results.Count >= this._requiredResults && this._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 >= this._requiredResults && this._requiredResults != -1)
{
context.OutputMultiset = results;
return(context.OutputMultiset);
}
}
}
}
}
else if (temp is FilterPattern)
{
FilterPattern filter = (FilterPattern)temp;
ISparqlExpression filterExpr = filter.Filter.Expression;
if (filter.Variables.IsDisjoint(context.InputMultiset.Variables))
{
//Remember to check for Timeouts during Lazy Evaluation
context.CheckTimeout();
//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 < this._triplePatterns.Count - 1)
{
//Recurse and return
results = this.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.EffectiveBooleanValue(context, 0))
{
if (pattern < this._triplePatterns.Count - 1)
{
//Recurse and return
results = this.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
{
//Remember to check for Timeouts during Lazy Evaluation
context.CheckTimeout();
//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.EffectiveBooleanValue(context, id))
{
//If evaluates to true then add to output
context.OutputMultiset.Add(context.InputMultiset[id]);
}
}
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 < this._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 = this.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
{
//Remember to check for Timeouts during Lazy Evaluation
context.CheckTimeout();
//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.Value(context, s.ID);
x.Add(bindVar, val);
}
catch (RdfQueryException)
{
//Equivalent to no assignment but the solution is preserved
}
context.OutputMultiset.Add(x);
}
//Remember to check for Timeouts during Lazy Evaluation
context.CheckTimeout();
//Decide whether to recurse or not
resultsFound = context.OutputMultiset.Count;
if (pattern < this._triplePatterns.Count - 1)
{
//Recurse then return
results = this.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
{
//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);
}
}
public void SparqlStreamingBgpSelectEvaluation()
{
//Get the Data we want to query
TripleStore store = new TripleStore();
Graph g = new Graph();
FileLoader.Load(g, "resources\\InferenceTest.ttl");
store.Add(g);
//g = new Graph();
//g.LoadFromFile("noise.ttl");
//store.Add(g);
Console.WriteLine(store.Triples.Count() + " Triples in Store");
//Create the Triple Pattern we want to query with
IUriNode fordFiesta = g.CreateUriNode(new Uri("http://example.org/vehicles/FordFiesta"));
IUriNode rdfType = g.CreateUriNode(new Uri(RdfSpecsHelper.RdfType));
IUriNode rdfsLabel = g.CreateUriNode(new Uri(NamespaceMapper.RDFS + "label"));
IUriNode speed = g.CreateUriNode(new Uri("http://example.org/vehicles/Speed"));
IUriNode carClass = g.CreateUriNode(new Uri("http://example.org/vehicles/Car"));
TriplePattern allTriples = new TriplePattern(new VariablePattern("?s"), new VariablePattern("?p"), new VariablePattern("?o"));
TriplePattern allTriples2 = new TriplePattern(new VariablePattern("?x"), new VariablePattern("?y"), new VariablePattern("?z"));
TriplePattern tp1 = new TriplePattern(new VariablePattern("?s"), new NodeMatchPattern(rdfType), new NodeMatchPattern(carClass));
TriplePattern tp2 = new TriplePattern(new VariablePattern("?s"), new NodeMatchPattern(speed), new VariablePattern("?speed"));
TriplePattern tp3 = new TriplePattern(new VariablePattern("?s"), new NodeMatchPattern(rdfsLabel), new VariablePattern("?label"));
TriplePattern novars = new TriplePattern(new NodeMatchPattern(fordFiesta), new NodeMatchPattern(rdfType), new NodeMatchPattern(carClass));
TriplePattern novars2 = new TriplePattern(new NodeMatchPattern(fordFiesta), new NodeMatchPattern(rdfsLabel), new NodeMatchPattern(carClass));
FilterPattern blankSubject = new FilterPattern(new UnaryExpressionFilter(new IsBlankFunction(new VariableTerm("?s"))));
List <List <ITriplePattern> > tests = new List <List <ITriplePattern> >()
{
new List <ITriplePattern>()
{
},
new List <ITriplePattern>()
{
allTriples
},
new List <ITriplePattern>()
{
allTriples, allTriples2
},
new List <ITriplePattern>()
{
tp1
},
new List <ITriplePattern>()
{
tp1, tp2
},
new List <ITriplePattern>()
{
tp1, tp3
},
new List <ITriplePattern>()
{
novars
},
new List <ITriplePattern>()
{
novars, tp1
},
new List <ITriplePattern>()
{
novars, tp1, tp2
},
new List <ITriplePattern>()
{
novars2
},
new List <ITriplePattern>()
{
tp1, blankSubject
}
};
foreach (List <ITriplePattern> tps in tests)
{
Console.WriteLine(tps.Count + " Triple Patterns in the Query");
foreach (ITriplePattern tp in tps)
{
Console.WriteLine(tp.ToString());
}
Console.WriteLine();
ISparqlAlgebra select = new Bgp(tps);
ISparqlAlgebra selectOptimised = new LazyBgp(tps, 10);
//Evaluate with timings
Stopwatch timer = new Stopwatch();
TimeSpan unopt, opt;
timer.Start();
BaseMultiset results1 = select.Evaluate(new SparqlEvaluationContext(null, new InMemoryDataset(store)));
timer.Stop();
unopt = timer.Elapsed;
timer.Reset();
timer.Start();
BaseMultiset results2 = selectOptimised.Evaluate(new SparqlEvaluationContext(null, new InMemoryDataset(store)));
timer.Stop();
opt = timer.Elapsed;
Console.WriteLine("SELECT = " + results1.GetType().ToString() + " (" + results1.Count + " Results) in " + unopt.ToString());
Console.WriteLine("SELECT Optimised = " + results2.GetType().ToString() + " (" + results2.Count + " Results) in " + opt.ToString());
Console.WriteLine();
Console.WriteLine("Optimised Results");
foreach (ISet s in results2.Sets)
{
Console.WriteLine(s.ToString());
}
Assert.IsTrue(results1.Count >= results2.Count, "Optimised Select should have produced as many/fewer results than Unoptimised Select");
Console.WriteLine();
}
}
/// <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();
if (tp is TriplePattern)
{
TriplePattern match = (TriplePattern)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(" .");
}
else if (tp is FilterPattern)
{
FilterPattern filter = (FilterPattern)tp;
output.Append("FILTER(");
output.Append(this.FormatExpression(filter.Filter.Expression));
output.Append(")");
}
else if (tp is SubQueryPattern)
{
SubQueryPattern subquery = (SubQueryPattern)tp;
output.AppendLine("{");
output.AppendLineIndented(this.Format(subquery.SubQuery), 2);
output.AppendLine("}");
}
else if (tp is PropertyPathPattern)
{
PropertyPathPattern path = (PropertyPathPattern)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(" .");
}
else if (tp is LetPattern)
{
LetPattern let = (LetPattern)tp;
output.Append("LET(?");
output.Append(let.VariableName);
output.Append(" := ");
output.Append(this.FormatExpression(let.AssignExpression));
output.Append(")");
}
else if (tp is BindPattern)
{
BindPattern bind = (BindPattern)tp;
output.Append("BIND (");
output.Append(this.FormatExpression(bind.AssignExpression));
output.Append(" AS ?");
output.Append(bind.VariableName);
output.Append(")");
}
else
{
throw new RdfOutputException("Unable to Format an unknown ITriplePattern implementation as a String");
}
return(output.ToString());
}
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 is TriplePattern)
{
//Find the first Triple which matches the Pattern
TriplePattern tp = (TriplePattern)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 is FilterPattern)
{
FilterPattern fp = (FilterPattern)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.EffectiveBooleanValue(context, 0))
{
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.EffectiveBooleanValue(context, id))
{
resultsFound++;
context.OutputMultiset.Add(context.InputMultiset[id]);
//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");
}
public void TestMatch(string fileName, string filterPattern, bool match)
{
var filter = FilterPattern.Parse(filterPattern);
Assert.Equal(match, filter.Match(fileName));
}
public override IFilter Map(IFilter filter)
{
var newFilterName = FilterPattern.Replace(GetFilterName(filter), IndexPattern);
return(SetFilterName(filter, newFilterName));
}
/// <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)
{
if (p is TriplePattern)
{
TriplePattern tp = (TriplePattern)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));
}
else if (p is FilterPattern)
{
FilterPattern fp = (FilterPattern)p;
ps.Add(new FilterPattern(new UnaryExpressionFilter(this.Transform(fp.Filter.Expression))));
}
else if (p is BindPattern)
{
BindPattern bp = (BindPattern)p;
ps.Add(new BindPattern(bp.VariableName, this.Transform(bp.AssignExpression)));
}
else if (p is LetPattern)
{
LetPattern lp = (LetPattern)p;
ps.Add(new LetPattern(lp.VariableName, this.Transform(lp.AssignExpression)));
}
else if (p is SubQueryPattern)
{
throw new RdfQueryException("Cannot do variable substitution when a sub-query is present");
}
else if (p is PropertyPathPattern)
{
throw new RdfQueryException("Cannot do variable substitution when a property path is present");
}
else
{
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");
}
}
