public object Clone() { var copy = new AndTreePredicate(); foreach (var expression in _predciates) { copy.Add((ITreePredicate)expression.Clone()); } return(copy); }
public ITreePredicate Expand() { foreach (var predciate in _predciates) { var orPredicate = predciate as OrTreePredicate; if (orPredicate != null) { ITreePredicate orParent = null; foreach (var childPredciate in orPredicate.TreePredicates) { orParent = orParent ?? new OrTreePredicate(); if (orPredicate.TreePredicates.Count > 1) { var andChild = new AndTreePredicate(); foreach (var sibling in _predciates) { if (sibling != orPredicate) { andChild.Add(sibling); } } andChild.Add(childPredciate); ((OrTreePredicate)orParent).Add(andChild); } else { orParent = childPredciate; } } return(orParent); } } foreach (var predciate in _predciates) { var resultPred = predciate.Expand(); if (resultPred != null) { ITreePredicate returnPredciate = new AndTreePredicate(); foreach (var sibling in _predciates) { if (sibling != predciate) { ((AndTreePredicate)returnPredciate).Add((ITreePredicate)sibling.Clone()); } } ((AndTreePredicate)returnPredciate).Add(resultPred); return(returnPredciate); } } return(null); }
public ITreePredicate Contract() { Dictionary <int, ITreePredicate> contractedPreds = new Dictionary <int, ITreePredicate>(); for (int i = 0; i < _predciates.Count; i++) { ITreePredicate contractedPred = _predciates[i].Contract(); if (contractedPred != null) { while (contractedPred.Contract() != null) { contractedPred = contractedPred.Contract(); } contractedPreds[i] = contractedPred; } } if (contractedPreds.Count.Equals(0)) { return(null); } AndTreePredicate returnAnd = new AndTreePredicate(); for (int i = 0; i < _predciates.Count; i++) { if (contractedPreds.ContainsKey(i)) { returnAnd.Add(contractedPreds[i]); } else { returnAnd.Add(_predciates[i]); } } ITreePredicate contractedExpr = returnAnd; while (contractedExpr.Contract() != null) { contractedExpr = contractedExpr.Contract(); } return(contractedExpr); }
public override bool Equals(object obj) { if (!(obj is AndTreePredicate)) { return(false); } AndTreePredicate andObject = (AndTreePredicate)obj; if (!_predciates.Count.Equals(andObject.TreePredicates.Count)) { return(false); } foreach (var expression in andObject.TreePredicates) { if (!_predciates.Contains(expression)) { return(false); } } return(true); }
/// <summary> /// Tries to assign compound indexes to expressions if applicable... /// </summary> private static List <ProxyAndPredicate> AssignCompoundIndices(ProxyAndPredicate set, IEnumerable <IIndex> indexes, IQueryStore queryStore) { var attribExprList = new OrderedList <string, ComparisonPredicate>(); var proxyPredicates = new List <ProxyAndPredicate>(); //For every expression in the set ready for assignment. foreach (var expresson in set.TreePredicates) { var expression = (ComparisonPredicate)expresson; if (expression.IsBinaryExpression) { continue; } attribExprList.Add(expression.AttributeNames[0], expression); } //Each compound index will create a new state of the expression. foreach (var index in indexes) { int matchedNumber = 0; var matchedAttribs = new List <string>(); //If keys (attributes list) does not contain the first prefix of the index //Then the index is not usable. if (attribExprList.ContainsKey(index.Attributes.Name)) { matchedAttribs.Add(index.Attributes.Name); matchedNumber += attribExprList[index.Attributes.Name].Count; } //if matched attributes are < 2 no need of compound assignment. if (matchedAttribs.Count < 2) { continue; } //Assign each of them an index and get them to the predicate, and get the one with the lowest cost. ComparisonPredicate cheapestExpression = attribExprList[matchedAttribs[0]][0]; IPredicate cheapestPredicate = cheapestExpression.AssignIndexPredicate(index, queryStore); for (int i = 1; i < attribExprList[matchedAttribs[0]].Count; i++) { ComparisonPredicate tempExpression = attribExprList[matchedAttribs[0]][i]; IPredicate tempPredicate = tempExpression.AssignIndexPredicate(index, queryStore); if (tempPredicate.Statistics[Statistic.ExpectedIO] < cheapestPredicate.Statistics[Statistic.ExpectedIO]) { cheapestExpression = tempExpression; cheapestPredicate = tempPredicate; } } //For filteration and adding rest of expressions to the index. ITreePredicate assingedExpression = null; if (!matchedNumber.Equals(2)) { AndTreePredicate assingedAnd = new AndTreePredicate(); foreach (var attribute in matchedAttribs) { foreach (var expression in attribExprList[attribute]) { if (expression != cheapestExpression) { assingedAnd.Add(expression); } } } assingedExpression = assingedAnd; } else { foreach (var expression in attribExprList[matchedAttribs[1]]) { assingedExpression = expression; } } FilterPredicate filterPredicate = new FilterPredicate(assingedExpression, index); filterPredicate.AddChildPredicate(cheapestPredicate); ProxyAndPredicate proxyAnd = (ProxyAndPredicate)set.Clone(); //Removing assigned expressions. foreach (var attribute in matchedAttribs) { foreach (var expression in attribExprList[attribute]) { proxyAnd.TreePredicates.Remove(expression); } } proxyAnd.AddChildPredicate(new ProxyPredicate(filterPredicate, null)); proxyPredicates.Add(proxyAnd); } foreach (var proxyAnd in proxyPredicates) { //Recursive call for each ProxyAndPredicate. if (proxyAnd.TreePredicates.Count > 1) { var values = AssignCompoundIndices(proxyAnd, indexes, queryStore); foreach (var value in values) { proxyPredicates.Add(value); } } } return(proxyPredicates); }
/// <summary> /// Assigns a proxy predicate to a single-attributed expressions. /// </summary> private static void AssignSingleAttributesPredicate(ProxyAndPredicate proxyAnd, ICollection <IIndex> indexes, IQueryStore queryStore) { OrderedList <string, ComparisonPredicate> attribExprList = new OrderedList <string, ComparisonPredicate>(); foreach (var value in proxyAnd.TreePredicates) { var expression = (ComparisonPredicate)value; if (expression.IsBinaryExpression) { continue; } attribExprList.Add(expression.AttributeNames[0], expression); } if (attribExprList.Count > 0) { foreach (var attribute in attribExprList.Keys) { IIndex lowestIndex = null; foreach (var index in indexes) { if (attribute.Equals(index.Attributes.Name)) { if (lowestIndex == null) { lowestIndex = index; } else if (lowestIndex.ValueCount > index.ValueCount) { lowestIndex = index; } } } if (lowestIndex != null) { foreach (var expression in attribExprList[attribute]) { proxyAnd.AddChildPredicate( new ProxyPredicate(expression.AssignIndexPredicate(lowestIndex, queryStore), expression)); proxyAnd.TreePredicates.Remove(expression); } } } //For every unassigned expression... if (proxyAnd.TreePredicates.Count > 0) { ITreePredicate assingedExpression; if (proxyAnd.TreePredicates.Count.Equals(1)) { assingedExpression = proxyAnd.TreePredicates[0]; } else { AndTreePredicate assingedAnd = new AndTreePredicate(); foreach (var expression in proxyAnd.TreePredicates) { assingedAnd.Add(expression); } assingedExpression = assingedAnd; } proxyAnd.AddChildPredicate(new ProxyPredicate( new StorePredicate(assingedExpression, queryStore), assingedExpression)); } } }
public ITreePredicate Contract() { if (!IsTerminal) { Dictionary <int, ITreePredicate> contractedPreds = new Dictionary <int, ITreePredicate>(); for (int i = 0; i < _predciates.Count; i++) { ITreePredicate contracted = _predciates[i].Contract(); if (contracted != null) { while (contracted.Contract() != null) { contracted = contracted.Contract(); } contractedPreds[i] = contracted; } } if (contractedPreds.Count.Equals(0)) { return(null); } OrTreePredicate returnOr = new OrTreePredicate(); for (int i = 0; i < _predciates.Count; i++) { if (contractedPreds.ContainsKey(i)) { returnOr.Add(contractedPreds[i]); } else { returnOr.Add(_predciates[i]); } } ITreePredicate contractedPred = returnOr; while (contractedPred.Contract() != null) { contractedPred = contractedPred.Contract(); } return(contractedPred); } List <AndTreePredicate> ands = new List <AndTreePredicate>(); foreach (var predciate in _predciates) { if (!(predciate is AndTreePredicate)) { return(null); } ands.Add((AndTreePredicate)(predciate)); } if (ands.Count < 2) { return(null); } ITreePredicate commonPred = null; foreach (var expression in ands[0].TreePredicates) { commonPred = expression; for (int i = 1; i < ands.Count; i++) { if (ands[i].TreePredicates.Count < 2 || !ands[i].TreePredicates.Contains(expression)) { return(null); } } } AndTreePredicate returnPred = new AndTreePredicate(); returnPred.Add(commonPred); OrTreePredicate orChild = new OrTreePredicate(); foreach (var and in ands) { foreach (var predciate in and.TreePredicates) { if (!predciate.Equals(commonPred)) { orChild.Add(predciate); } } } returnPred.Add(orChild); ITreePredicate contractPred = returnPred; while (contractPred.Contract() != null) { contractPred = contractPred.Contract(); } return(contractPred); }