/// <summary> /// AND's two BaseFilters /// </summary> /// <returns>A new basefilter that represents the AND of the two</returns> public static FilterContainer operator &(FilterContainer leftFilterDescriptor, FilterContainer rightFilterDescriptor) { var defaultFilter = new FilterContainer() { IsConditionless = true }; leftFilterDescriptor = leftFilterDescriptor ?? defaultFilter; rightFilterDescriptor = rightFilterDescriptor ?? defaultFilter; var combined = new[] { leftFilterDescriptor, rightFilterDescriptor }; //if any of the queries is conditionless return the first one that is not //or return the defaultQuery if (combined.Any(bf => bf.IsConditionless)) { return(combined.FirstOrDefault(bf => !bf.IsConditionless) ?? defaultFilter); } //return simple combination of the two if merging is not possible/necessary var noMergeFilter = CombineIfNoMergeIsNecessary(leftFilterDescriptor, rightFilterDescriptor, combined); if (noMergeFilter != null) { return(noMergeFilter); } //if the left is a strict bool try to merge right on left first var joinStrictLeft = StrictSingleSideAndMerge(leftFilterDescriptor, rightFilterDescriptor); if (joinStrictLeft != null) { return(joinStrictLeft); } // if the right side is a strict bool try to merge left on right var joinStrictRight = StrictSingleSideAndMerge(rightFilterDescriptor, leftFilterDescriptor); if (joinStrictRight != null) { return(joinStrictRight); } // if the left side is a normal bool try to merge right on left var joinLeft = SingleSideAndMerge(leftFilterDescriptor, rightFilterDescriptor); if (joinLeft != null) { return(joinLeft); } // if the right side is a normal bool try to merge lefft on right var joinRight = SingleSideAndMerge(rightFilterDescriptor, leftFilterDescriptor); return(joinRight ?? defaultFilter); }
public static FilterContainer CreateReturnFilter(Action <FilterContainer, BoolBaseFilterDescriptor> modify = null) { var returnFilter = new FilterContainer(); var returnBoolFilter = new BoolBaseFilterDescriptor() { }; ((IFilterContainer)returnFilter).Bool = returnBoolFilter; if (modify != null) { modify(returnFilter, returnBoolFilter); } return(returnFilter); }
/// <summary> /// A filter that filters out matched documents using a query. /// This filter is more performant then bool filter. /// </summary> public FilterContainer Not(Func <FilterDescriptor <T>, FilterContainer> selector) { var notFilter = new NotFilterDescriptor(); var filter = new FilterDescriptor <T>() { IsConditionless = true }; FilterContainer bf = filter; if (selector != null) { bf = selector(filter); } ((INotFilter)notFilter).Filter = bf; return(this.New(notFilter, f => f.Not = notFilter)); }
public static FilterContainer operator !(FilterContainer lbq) { if (lbq == null || lbq.IsConditionless) { return new FilterContainer { IsConditionless = true } } ; var f = new FilterContainer(); var fq = new BoolBaseFilterDescriptor(); ((IBoolFilter)fq).MustNot = new[] { lbq }; ((IFilterContainer)f).Bool = fq; return(f); }
public static FilterContainer CreateReturnFilter(Action<FilterContainer, BoolBaseFilterDescriptor> modify = null) { var returnFilter = new FilterContainer(); var returnBoolFilter = new BoolBaseFilterDescriptor() { }; ((IFilterContainer)returnFilter).Bool = returnBoolFilter; if (modify != null) { modify(returnFilter, returnBoolFilter); } return returnFilter; }
public static FilterContainer operator !(FilterContainer lbq) { if (lbq == null || lbq.IsConditionless) return new FilterContainer { IsConditionless = true }; var f = new FilterContainer(); var fq = new BoolBaseFilterDescriptor(); ((IBoolFilter)fq).MustNot = new[] { lbq }; ((IFilterContainer)f).Bool = fq; return f; }
public static FilterContainer operator |(FilterContainer leftFilterDescriptor, FilterContainer rightFilterDescriptor) { var defaultFilter = new FilterContainer() { IsConditionless = true }; leftFilterDescriptor = leftFilterDescriptor ?? defaultFilter; rightFilterDescriptor = rightFilterDescriptor ?? defaultFilter; var combined = new[] { leftFilterDescriptor, rightFilterDescriptor }; if (combined.Any(bf => bf.IsConditionless)) return combined.FirstOrDefault(bf => !bf.IsConditionless) ?? defaultFilter; var leftDescriptor = ((IFilterContainer)leftFilterDescriptor); var leftBoolFilter = leftDescriptor.Bool; var rightDescriptor = ((IFilterContainer)rightFilterDescriptor); var rightBoolFilter = rightDescriptor.Bool; var f = new FilterContainer(); var fq = new BoolBaseFilterDescriptor(); var bfq = (IBoolFilter)fq; bfq.Should = new[] { leftFilterDescriptor, rightFilterDescriptor }; ((IFilterContainer)f).Bool = fq; //if neither the left nor the right side represent a bool filter join them if (leftDescriptor.Bool == null && rightDescriptor.Bool == null) { bfq.Should = leftFilterDescriptor.MergeShouldFilters(rightFilterDescriptor); return f; } //if the left or right sight already is a bool filter determine join the non bool query side of the //of the operation onto the other. if (leftDescriptor.Bool != null && rightDescriptor.Bool == null && !leftDescriptor.IsStrict) { JoinShouldOnSide(leftFilterDescriptor, rightFilterDescriptor, fq); } else if (rightDescriptor.Bool != null && leftDescriptor.Bool == null && !rightDescriptor.IsStrict) { JoinShouldOnSide(rightFilterDescriptor, leftFilterDescriptor, fq); } //both sides already represent a bool filter else { //both sides report that we may merge the shoulds if (!leftDescriptor.IsStrict && !rightDescriptor.IsStrict && leftBoolFilter.CanJoinShould() && rightBoolFilter.CanJoinShould()) bfq.Should = leftFilterDescriptor.MergeShouldFilters(rightFilterDescriptor); else //create a new nested bool with two separate should bool sections bfq.Should = new[] { leftFilterDescriptor, rightFilterDescriptor }; } return f; }
/// <summary> /// AND's two BaseFilters /// </summary> /// <returns>A new basefilter that represents the AND of the two</returns> public static FilterContainer operator &(FilterContainer leftFilterDescriptor, FilterContainer rightFilterDescriptor) { var defaultFilter = new FilterContainer() { IsConditionless = true }; leftFilterDescriptor = leftFilterDescriptor ?? defaultFilter; rightFilterDescriptor = rightFilterDescriptor ?? defaultFilter; var combined = new[] { leftFilterDescriptor, rightFilterDescriptor }; //if any of the queries is conditionless return the first one that is not //or return the defaultQuery if (combined.Any(bf => bf.IsConditionless)) return combined.FirstOrDefault(bf=>!bf.IsConditionless) ?? defaultFilter; //return simple combination of the two if merging is not possible/necessary var noMergeFilter = CombineIfNoMergeIsNecessary(leftFilterDescriptor, rightFilterDescriptor, combined); if (noMergeFilter != null) return noMergeFilter; //if the left is a strict bool try to merge right on left first var joinStrictLeft = StrictSingleSideAndMerge(leftFilterDescriptor, rightFilterDescriptor); if (joinStrictLeft != null) return joinStrictLeft; // if the right side is a strict bool try to merge left on right var joinStrictRight = StrictSingleSideAndMerge(rightFilterDescriptor, leftFilterDescriptor); if (joinStrictRight != null) return joinStrictRight; // if the left side is a normal bool try to merge right on left var joinLeft = SingleSideAndMerge(leftFilterDescriptor, rightFilterDescriptor); if (joinLeft != null) return joinLeft; // if the right side is a normal bool try to merge lefft on right var joinRight = SingleSideAndMerge(rightFilterDescriptor, leftFilterDescriptor); return joinRight ?? defaultFilter; }
public static FilterContainer operator |(FilterContainer leftFilterDescriptor, FilterContainer rightFilterDescriptor) { var defaultFilter = new FilterContainer() { IsConditionless = true }; leftFilterDescriptor = leftFilterDescriptor ?? defaultFilter; rightFilterDescriptor = rightFilterDescriptor ?? defaultFilter; var combined = new[] { leftFilterDescriptor, rightFilterDescriptor }; if (combined.Any(bf => bf.IsConditionless)) { return(combined.FirstOrDefault(bf => !bf.IsConditionless) ?? defaultFilter); } var leftDescriptor = ((IFilterContainer)leftFilterDescriptor); var leftBoolFilter = leftDescriptor.Bool; var rightDescriptor = ((IFilterContainer)rightFilterDescriptor); var rightBoolFilter = rightDescriptor.Bool; var f = new FilterContainer(); var fq = new BoolBaseFilterDescriptor(); var bfq = (IBoolFilter)fq; bfq.Should = new[] { leftFilterDescriptor, rightFilterDescriptor }; ((IFilterContainer)f).Bool = fq; //if neither the left nor the right side represent a bool filter join them if (leftDescriptor.Bool == null && rightDescriptor.Bool == null) { bfq.Should = leftFilterDescriptor.MergeShouldFilters(rightFilterDescriptor); return(f); } //if the left or right sight already is a bool filter determine join the non bool query side of the //of the operation onto the other. if (leftDescriptor.Bool != null && rightDescriptor.Bool == null && !leftDescriptor.IsStrict) { JoinShouldOnSide(leftFilterDescriptor, rightFilterDescriptor, fq); } else if (rightDescriptor.Bool != null && leftDescriptor.Bool == null && !rightDescriptor.IsStrict) { JoinShouldOnSide(rightFilterDescriptor, leftFilterDescriptor, fq); } //both sides already represent a bool filter else { //both sides report that we may merge the shoulds if (!leftDescriptor.IsStrict && !rightDescriptor.IsStrict && leftBoolFilter.CanJoinShould() && rightBoolFilter.CanJoinShould()) { bfq.Should = leftFilterDescriptor.MergeShouldFilters(rightFilterDescriptor); } else { //create a new nested bool with two separate should bool sections bfq.Should = new[] { leftFilterDescriptor, rightFilterDescriptor } }; } return(f); }