public void Walk(IFilterContainer fd, IQueryVisitor visitor)
{
visitor.Visit(fd);
AcceptFilter(fd.Range, visitor, (v, d) => v.Visit(d));
AcceptFilter(fd.Regexp, visitor, (v, d) => v.Visit(d));
AcceptFilter(fd.Script, visitor, (v, d) => v.Visit(d));
AcceptFilter(fd.Term, visitor, (v, d) => v.Visit(d));
AcceptFilter(fd.Terms, visitor, (v, d) => v.Visit(d));
AcceptFilter(fd.Type, visitor, (v, d) => v.Visit(d));
AcceptFilter(fd.Exists, visitor, (v, d) => v.Visit(d));
AcceptFilter(fd.GeoBoundingBox, visitor, (v, d) => v.Visit(d));
AcceptFilter(fd.GeoDistance, visitor, (v, d) => v.Visit(d));
AcceptFilter(fd.GeoDistanceRange, visitor, (v, d) => v.Visit(d));
AcceptFilter(fd.GeoPolygon, visitor, (v, d) => v.Visit(d));
AcceptFilter(fd.GeoShape, visitor, (v, d) => v.Visit(d));
AcceptFilter(fd.HasChild, visitor, (v, d) => v.Visit(d));
AcceptFilter(fd.Ids, visitor, (v, d) => v.Visit(d));
AcceptFilter(fd.Limit, visitor, (v, d) => v.Visit(d));
AcceptFilter(fd.MatchAll, visitor, (v, d) => v.Visit(d));
AcceptFilter(fd.Missing, visitor, (v, d) => v.Visit(d));
AcceptFilter(fd.Prefix, visitor, (v, d) => v.Visit(d));
AcceptFilter(fd.And, visitor, (v, d) =>
{
v.Visit(d);
this.Accept(v, d.Filters);
});
AcceptFilter(fd.Bool, visitor, (v, d) =>
{
v.Visit(d);
this.Accept(v, d.Must, VisitorScope.Must);
this.Accept(v, d.MustNot, VisitorScope.MustNot);
this.Accept(v, d.Should, VisitorScope.Should);
});
AcceptFilter(fd.HasParent, visitor, (v, d) =>
{
v.Visit(d);
this.Accept(v, d.Query);
});
AcceptFilter(fd.Nested, visitor, (v, d) =>
{
v.Visit(d);
this.Accept(v, d.Query);
this.Accept(v, d.Filter);
});
AcceptFilter(fd.Not, visitor, (v, d) =>
{
v.Visit(d);
this.Accept(v, d.Filter);
});
AcceptFilter(fd.Or, visitor, (v, d) =>
{
v.Visit(d);
this.Accept(v, d.Filters);
});
AcceptFilter(fd.Query, visitor, (v, d) =>
{
v.Visit(d);
this.Accept(v, d.Query);
});
}
internal static bool IsBoolFilterWithOnlyMustNots(this IFilterContainer container)
{
return(container != null && container.Bool != null &&
!container.Bool.Must.HasAny() &&
!container.Bool.Should.HasAny() &&
container.Bool.MustNot.HasAny());
}
internal static FilterContainer MergeMustFilters(this IFilterContainer leftContainer, IFilterContainer rightContainer)
{
if (!leftContainer.CanMergeMustAndMustNots() || !rightContainer.CanMergeMustAndMustNots())
{
if (rightContainer.IsBoolFilterWithOnlyMustNots())
{
return(CreateMustContainer(new [] { leftContainer }, rightContainer.Bool.MustNot));
}
if (leftContainer.IsBoolFilterWithOnlyMustNots())
{
return(CreateMustContainer(new [] { rightContainer }, leftContainer.Bool.MustNot));
}
return(CreateMustContainer(new [] { leftContainer, rightContainer }, null));
}
var mustNots = OrphanMustNots(leftContainer)
.EagerConcat(OrphanMustNots(rightContainer));
var leftClauses = CreateMustClauses(leftContainer);
var rightClauses = CreateMustClauses(rightContainer);
var mustClauses = leftClauses.EagerConcat(rightClauses);
var container = CreateMustContainer(mustClauses, mustNots);
return(container);
}
private static FilterContainer SingleSideAndMerge(IFilterContainer targetFilterDescriptor, IFilterContainer mergeFilterDescriptor)
{
var targetBoolFilter = targetFilterDescriptor.Bool;
var mergeBoolFilter = mergeFilterDescriptor.Bool;
if (targetBoolFilter == null)
{
return(null);
}
var combined = new[] { targetFilterDescriptor, mergeFilterDescriptor };
return(CreateReturnFilter((returnFilter, returnBoolFilter) =>
{
var boolFilter = ((IBoolFilter)returnBoolFilter);
if (!targetBoolFilter.CanMergeMustAndMustNots() || !mergeBoolFilter.CanMergeMustAndMustNots())
{
boolFilter.Must = combined;
return;
}
boolFilter.Must = (targetBoolFilter.Must ?? Empty)
.Concat(mergeBoolFilter != null
? (mergeBoolFilter.Must ?? Empty)
: new[] { mergeFilterDescriptor })
.NullIfEmpty();
boolFilter.MustNot = (targetBoolFilter.MustNot ?? Empty)
.Concat(mergeBoolFilter != null
? (mergeBoolFilter.MustNot ?? Empty)
: Empty
).NullIfEmpty();
}));
}
private static IEnumerable<IFilterContainer> OrphanMustNots(IFilterContainer container)
{
var lBoolFilter = container.Bool;
if (lBoolFilter == null || !lBoolFilter.MustNot.HasAny()) return null;
var mustNotFilters = lBoolFilter.MustNot.ToList();
lBoolFilter.MustNot = null;
return mustNotFilters;
}
private void Accept(IQueryVisitor visitor, IFilterContainer filter, VisitorScope scope = VisitorScope.Filter)
{
if (filter == null)
{
return;
}
visitor.Scope = scope;
filter.Accept(visitor);
}
protected static void AssertIsTermFilter(IFilterContainer f1, IFilterContainer f2)
{
f1.Should().NotBeNull();
f2.Should().NotBeNull();
f1.Term.Should().NotBeNull();
f2.Term.Should().NotBeNull();
f1.Term.Field.Should().Be(f2.Term.Field);
f1.Term.Value.Should().Be(f2.Term.Value);
}
private static IEnumerable<IFilterContainer> CreateMustClauses(IFilterContainer container)
{
var boolFilter = container.Bool;
var hasMustClauses = boolFilter != null && boolFilter.Must.HasAny();
if (hasMustClauses) return boolFilter.Must;
if (boolFilter != null && boolFilter.IsConditionless)
return Enumerable.Empty<IFilterContainer>();
return new[] {container};
}
private static IEnumerable <IFilterContainer> OrphanMustNots(IFilterContainer container)
{
var lBoolFilter = container.Bool;
if (lBoolFilter == null || !lBoolFilter.MustNot.HasAny())
{
return(null);
}
var mustNotFilters = lBoolFilter.MustNot.ToList();
lBoolFilter.MustNot = null;
return(mustNotFilters);
}
public static FilterContainer ToContainer(PlainFilter filter, FilterContainer filterContainer = null)
{
if (filter == null)
{
return(null);
}
var c = filterContainer ?? new FilterContainer();
IFilterContainer fc = c;
filter.WrapInContainer(c);
fc.Cache = filter.Cache;
fc.CacheKey = filter.CacheKey;
fc.FilterName = filter.FilterName;
return(c);
}
internal static IEnumerable <IFilterContainer> MergeShouldFilters(this IFilterContainer lbq, IFilterContainer rbq)
{
var lBoolDescriptor = lbq.Bool;
var lHasShouldFilters = lBoolDescriptor != null &&
((IBoolFilter)lBoolDescriptor).Should.HasAny();
var rBoolDescriptor = rbq.Bool;
var rHasShouldFilters = rBoolDescriptor != null &&
((IBoolFilter)rBoolDescriptor).Should.HasAny();
var lq = lHasShouldFilters ? ((IBoolFilter)lBoolDescriptor).Should : new[] { lbq };
var rq = rHasShouldFilters ? ((IBoolFilter)rBoolDescriptor).Should : new[] { rbq };
return(lq.Concat(rq));
}
private static IEnumerable <IFilterContainer> CreateMustClauses(IFilterContainer container)
{
var boolFilter = container.Bool;
var hasMustClauses = boolFilter != null && boolFilter.Must.HasAny();
if (hasMustClauses)
{
return(boolFilter.Must);
}
if (boolFilter != null && boolFilter.IsConditionless)
{
return(Enumerable.Empty <IFilterContainer>());
}
return(new[] { container });
}
internal static IEnumerable<IFilterContainer> MergeShouldFilters(this IFilterContainer lbq, IFilterContainer rbq)
{
var lBoolDescriptor = lbq.Bool;
var lHasShouldFilters = lBoolDescriptor != null &&
((IBoolFilter)lBoolDescriptor).Should.HasAny();
var rBoolDescriptor = rbq.Bool;
var rHasShouldFilters = rBoolDescriptor != null &&
((IBoolFilter)rBoolDescriptor).Should.HasAny();
var lq = lHasShouldFilters ? ((IBoolFilter)lBoolDescriptor).Should : new[] { lbq };
var rq = rHasShouldFilters ? ((IBoolFilter)rBoolDescriptor).Should : new[] { rbq };
return lq.Concat(rq);
}
protected static void AssertIsTermFilter(FilterContainer filter1, FilterContainer filter2)
{
filter1.Should().NotBeNull();
filter2.Should().NotBeNull();
IFilterContainer f1 = filter1;
IFilterContainer f2 = filter2;
f1.Should().NotBeNull();
f2.Should().NotBeNull();
f1.Term.Should().NotBeNull();
f2.Term.Should().NotBeNull();
f1.Term.Field.Should().Be(f2.Term.Field);
f1.Term.Value.Should().Be(f2.Term.Value);
}
internal static FilterContainer MergeShouldFilters(this IFilterContainer leftContainer, IFilterContainer rightContainer)
{
if (!leftContainer.CanMergeShould() || !leftContainer.CanMergeShould())
return CreateShouldContainer(new List<IFilterContainer> { leftContainer, rightContainer });
var lBoolFilter = leftContainer.Bool;
var rBoolFilter = rightContainer.Bool;
var lHasShouldFilters = lBoolFilter != null && lBoolFilter.Should.HasAny();
var rHasShouldFilters = rBoolFilter != null && rBoolFilter.Should.HasAny();
var lq = lHasShouldFilters ? lBoolFilter.Should : new[] { leftContainer };
var rq = rHasShouldFilters ? rBoolFilter.Should : new[] { rightContainer };
var shouldClauses = lq.EagerConcat(rq);
return CreateShouldContainer(shouldClauses);
}
private static void SetCacheAndName(IFilterContainer filterDescriptor, IFilter filter)
{
filter.IsStrict = filterDescriptor.IsStrict;
filter.IsVerbatim = filterDescriptor.IsVerbatim;
if (filterDescriptor.Cache.HasValue)
{
filter.Cache = filterDescriptor.Cache;
}
if (!string.IsNullOrWhiteSpace(filterDescriptor.FilterName))
{
filter.FilterName = filterDescriptor.FilterName;
}
if (!string.IsNullOrWhiteSpace(filterDescriptor.CacheKey))
{
filter.CacheKey = filterDescriptor.CacheKey;
}
}
private static FilterDescriptor <T> CreateConditionlessFilterDescriptor <T>(FilterDescriptor <T> filterDescriptor, IFilter filter, string type = null) where T : class
{
IFilterContainer self = filterDescriptor;
if (self.IsStrict && !self.IsVerbatim)
{
throw new DslException(
"Filter resulted in a conditionless " +
$"'{type ?? filter.GetType().Name.Replace("Descriptor", "").Replace("`1", "")}' " +
"filter (json by approx):\n" +
$"{JsonConvert.SerializeObject(filterDescriptor, Formatting.Indented, new JsonSerializerSettings {NullValueHandling = NullValueHandling.Ignore})}"
);
}
var f = new FilterDescriptor <T>();
((IFilterContainer)f).IsStrict = self.IsStrict;
((IFilterContainer)f).IsVerbatim = self.IsVerbatim;
((IFilterContainer)f).IsConditionless = true;
return(f);
}
public FilterViewModel(IFilterContainer entity, ModuleFeature feature)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
if (feature == null)
{
throw new ArgumentNullException("feature");
}
Entity = entity;
SelectedFeature = feature;
if (entity.SelectedFilterGroup == null && entity.FilterGroups.Count > 0)
{
entity.SelectedFilterGroup = entity.FilterGroups[0];
}
InitializeCommands();
}
internal static FilterContainer MergeMustFilters(this IFilterContainer leftContainer, IFilterContainer rightContainer)
{
if (!leftContainer.CanMergeMustAndMustNots() || !rightContainer.CanMergeMustAndMustNots())
{
if (rightContainer.IsBoolFilterWithOnlyMustNots())
return CreateMustContainer(new [] { leftContainer }, rightContainer.Bool.MustNot );
if (leftContainer.IsBoolFilterWithOnlyMustNots())
return CreateMustContainer(new [] { rightContainer }, leftContainer.Bool.MustNot );
return CreateMustContainer(new [] { leftContainer, rightContainer }, null);
}
var mustNots = OrphanMustNots(leftContainer)
.EagerConcat(OrphanMustNots(rightContainer));
var leftClauses = CreateMustClauses(leftContainer);
var rightClauses = CreateMustClauses(rightContainer);
var mustClauses = leftClauses.EagerConcat(rightClauses);
var container = CreateMustContainer(mustClauses, mustNots);
return container;
}
private static FilterContainer StrictSingleSideAndMerge(IFilterContainer targetFilterDescriptor, IFilterContainer mergeFilterDescriptor)
{
//if the target is not strict return
if (!targetFilterDescriptor.IsStrict)
{
return(null);
}
var mergeBoolFilter = mergeFilterDescriptor.Bool;
return(CreateReturnFilter((returnFilter, returnBoolFilter) =>
{
if (mergeBoolFilter.MustNot.HasAny())
{
((IBoolFilter)returnBoolFilter).MustNot = mergeBoolFilter.MustNot;
mergeBoolFilter.MustNot = null;
}
((IBoolFilter)returnBoolFilter).Must = new[] { targetFilterDescriptor }.Concat(mergeBoolFilter.Must ?? Empty);
}));
}
internal static FilterContainer MergeShouldFilters(this IFilterContainer leftContainer, IFilterContainer rightContainer)
{
if (!leftContainer.CanMergeShould() || !leftContainer.CanMergeShould())
{
return(CreateShouldContainer(new List <IFilterContainer> {
leftContainer, rightContainer
}));
}
var lBoolFilter = leftContainer.Bool;
var rBoolFilter = rightContainer.Bool;
var lHasShouldFilters = lBoolFilter != null && lBoolFilter.Should.HasAny();
var rHasShouldFilters = rBoolFilter != null && rBoolFilter.Should.HasAny();
var lq = lHasShouldFilters ? lBoolFilter.Should : new[] { leftContainer };
var rq = rHasShouldFilters ? rBoolFilter.Should : new[] { rightContainer };
var shouldClauses = lq.EagerConcat(rq);
return(CreateShouldContainer(shouldClauses));
}
private static FilterContainer CombineIfNoMergeIsNecessary(
IFilterContainer leftFilterDescriptor,
IFilterContainer rightFilterDescriptor,
IEnumerable <FilterContainer> combined)
{
var leftBoolFilter = leftFilterDescriptor.Bool;
var rightBoolFilter = rightFilterDescriptor.Bool;
//if neither side is already a boolfilter
// or if all boolfilters are strict.
// or if one side is strict and the other is null
//no merging is needed just return the combination
if (
(leftBoolFilter == null && rightBoolFilter == null) ||
(leftFilterDescriptor.IsStrict && rightFilterDescriptor.IsStrict) ||
(leftFilterDescriptor.IsStrict && rightBoolFilter == null) ||
(rightFilterDescriptor.IsStrict && leftBoolFilter == null))
{
return(CreateReturnFilter((returnFilter, returnBoolFilter) => ((IBoolFilter)returnBoolFilter).Must = combined));
}
return(null);
}
private static FilterDescriptor <T> New <T>(FilterDescriptor <T> filterDescriptor, IFilter filter, Action <IFilterContainer> fillProperty)
where T : class
{
IFilterContainer self = filterDescriptor;
if (filter.IsConditionless && !self.IsVerbatim)
{
ResetCache(filterDescriptor);
return(CreateConditionlessFilterDescriptor(filterDescriptor, filter));
}
SetCacheAndName(filterDescriptor, filter);
var f = new FilterDescriptor <T>();
((IFilterContainer)f).IsStrict = self.IsStrict;
((IFilterContainer)f).IsVerbatim = self.IsVerbatim;
((IFilterContainer)f).FilterName = self.FilterName;
fillProperty?.Invoke(f);
ResetCache(filterDescriptor);
return(f);
}
internal static bool CanMergeShould(this IFilterContainer container)
{
return(!container.IsStrict && container.Bool.CanMergeShould());
}
protected internal override void WrapInContainer(IFilterContainer container)
{
container.GeoBoundingBox = this;
}
public void GetSingleIndex()
{
var indexName = ElasticsearchConfiguration.NewUniqueIndexName();
var aliasName = ElasticsearchConfiguration.NewUniqueIndexName();
var warmerName = "get_comfy";
var create = this.Client.CreateIndex(s => s
.Index(indexName)
.AddAlias(aliasName, a => a
.IndexRouting("routing")
.SearchRouting("routing")
.Filter <object>(f => f.Term("country", "value"))
)
.AddMapping <ElasticsearchProject>(map => map
.MapFromAttributes()
)
.Similarity(sim => sim
.CustomSimilarities(cs => cs
.Add("my_bm25_similarity", new BM25Similarity
{
K1 = 2.0,
B = 0.75,
Normalization = "h1",
NormalizationH1C = "1.0",
DiscountOverlaps = true
})
)
)
.Analysis(a => a
.Tokenizers(p => p
.Add("myTokenizer", new KeywordTokenizer())
)
.TokenFilters(tf => tf
.Add("myTokenFilter1", new AsciiFoldingTokenFilter())
.Add("myTokenFilter2", new UniqueTokenFilter())
)
.CharFilters(cf => cf
.Add("my_html", new HtmlStripCharFilter())
)
.Analyzers(aa => aa.Add("myCustom", new CustomAnalyzer
{
Tokenizer = "myTokenizer",
Filter = new string[] { "myTokenFilter1", "myTokenFilter2" },
CharFilter = new string[] { "my_html" },
Alias = new string[] { "alias1", "alias2" }
}))
)
.AddWarmer(cw => cw
.WarmerName(warmerName)
.Type <ElasticsearchProject>()
.Search(search => search.Query(q => q.Term("field", "value")))
)
.Settings(settings => settings
.Add("somesetting", 1)
)
);
create.IsValid.Should().BeTrue();
var r = this.Client.GetIndex(f => f.Index(indexName));
r.IsValid.Should().BeTrue();
r.Indices.Should().NotBeEmpty().And.ContainKey(indexName);
var index = r.Indices[indexName];
index.Aliases.Should().NotBeEmpty().And.ContainKey(aliasName);
index.Warmers.Should().NotBeEmpty().And.ContainKey(warmerName);
index.Mappings.Should().NotBeEmpty().And.ContainSingle(p => p.Name.EqualsString("elasticsearchprojects"));
index.Settings.Should().NotBeEmpty().And.ContainKey("somesetting");
index.Analysis.Should().NotBeNull();
index.Similarity.Should().NotBeNull();
var alias = index.Aliases[aliasName];
alias.IndexRouting.Should().Be("routing");
alias.SearchRouting.Should().Be("routing");
IFilterContainer filter = alias.Filter;
filter.Should().NotBeNull();
filter.Term.Should().NotBeNull();
filter.Term.Field.Should().Be("country");
filter.Term.Value.Should().Be("value");
var warmer = index.Warmers[warmerName];
warmer.Should().NotBeNull();
warmer.Types.ShouldBeEquivalentTo(new TypeNameMarker[] { "elasticsearchprojects" });
warmer.Source.Should().NotBeNull();
warmer.Source.Query.Should().NotBeNull();
warmer.Source.Query.Term.Should().NotBeNull();
warmer.Source.Query.Term.Field.Should().Be("field");
warmer.Source.Query.Term.Value.Should().Be("value");
warmer.Name.Should().Be(warmerName);
var mapping = index.Mappings.FirstOrDefault(m => m.Name.EqualsString("elasticsearchprojects"));
mapping.Properties.Should().NotBeEmpty();
var someSetting = index.Settings["somesetting"];
someSetting.Should().NotBeNull();
someSetting.Should().Be("1");
string uuid = index.AsExpando.uuid;
string created = index.AsExpando.version.created;
uuid.Should().NotBeNullOrWhiteSpace();
created.Should().NotBeNullOrWhiteSpace();
index.Analysis.Analyzers.Should().NotBeEmpty().And.ContainKey("myCustom");
var analyzer = index.Analysis.Analyzers["myCustom"] as CustomAnalyzer;
analyzer.Should().NotBeNull();
analyzer.Tokenizer.Should().Be("myTokenizer");
index.Similarity.CustomSimilarities.Should().NotBeEmpty().And.ContainKey("my_bm25_similarity");
var similarity = index.Similarity.CustomSimilarities["my_bm25_similarity"] as BM25Similarity;
similarity.Should().NotBeNull();
}
public virtual void Visit(IFilterContainer filter)
{
this.IsConditionless = filter.IsConditionless;
this.IsStrict = filter.IsStrict;
this.IsVerbatim = filter.IsVerbatim;
}
public virtual void Visit(IFilterContainer filter)
{
this.IsConditionless = filter.IsConditionless;
this.IsStrict = filter.IsStrict;
this.IsVerbatim = filter.IsVerbatim;
}
protected internal override void WrapInContainer(IFilterContainer container)
{
container.GeoHashCell = this;
}
protected internal override void WrapInContainer(IFilterContainer container)
{
container.GeoDistanceRange = this;
}
internal static bool CanMergeMustAndMustNots(this IFilterContainer container)
{
return(!container.IsStrict && container.Bool.CanMergeMustAndMustNots());
}
protected internal abstract void WrapInContainer(IFilterContainer container);
private static void JoinShouldOnSide(IFilterContainer lbq, IFilterContainer rbq, IBoolFilter bq)
{
bq.Should = lbq.MergeShouldFilters(rbq);
}
public virtual void Visit(IFilterContainer customFiltersScore)
{
}
/// <summary> /// Wraps the filter in a <see cref="IFilterContainer"/> /// </summary> /// <param name="container"></param> protected override void WrapInContainer(IFilterContainer container) => container.GeoShape = this;
protected internal override void WrapInContainer(IFilterContainer container)
{
container.GeoBoundingBox = this;
}
public virtual void Visit(IFilterContainer customFiltersScore)
{
}
private static void JoinShouldOnSide(IFilterContainer lbq, IFilterContainer rbq, IBoolFilter bq)
{
bq.Should = lbq.MergeShouldFilters(rbq);
}
protected internal override void WrapInContainer(IFilterContainer container)
{
container.GeoHashCell = this;
}
private static FilterContainer CombineIfNoMergeIsNecessary(
IFilterContainer leftFilterDescriptor,
IFilterContainer rightFilterDescriptor,
IEnumerable<FilterContainer> combined)
{
var leftBoolFilter = leftFilterDescriptor.Bool;
var rightBoolFilter = rightFilterDescriptor.Bool;
//if neither side is already a boolfilter
// or if all boolfilters are strict.
// or if one side is strict and the other is null
//no merging is needed just return the combination
if (
(leftBoolFilter == null && rightBoolFilter == null)
|| (leftFilterDescriptor.IsStrict && rightFilterDescriptor.IsStrict)
|| (leftFilterDescriptor.IsStrict && rightBoolFilter == null)
|| (rightFilterDescriptor.IsStrict && leftBoolFilter == null))
{
return CreateReturnFilter((returnFilter, returnBoolFilter) => ((IBoolFilter)returnBoolFilter).Must = combined);
}
return null;
}
protected internal abstract void WrapInContainer(IFilterContainer container);
private static FilterContainer StrictSingleSideAndMerge(IFilterContainer targetFilterDescriptor, IFilterContainer mergeFilterDescriptor)
{
//if the target is not strict return
if (!targetFilterDescriptor.IsStrict) return null;
var mergeBoolFilter = mergeFilterDescriptor.Bool;
return CreateReturnFilter((returnFilter, returnBoolFilter) =>
{
if (mergeBoolFilter.MustNot.HasAny())
{
((IBoolFilter)returnBoolFilter).MustNot = mergeBoolFilter.MustNot;
mergeBoolFilter.MustNot = null;
}
((IBoolFilter)returnBoolFilter).Must = new[] { targetFilterDescriptor }.Concat(mergeBoolFilter.Must ?? Empty);
});
}
protected internal override void WrapInContainer(IFilterContainer container)
{
container.Or = this;
}
private static FilterContainer SingleSideAndMerge(IFilterContainer targetFilterDescriptor, IFilterContainer mergeFilterDescriptor)
{
var targetBoolFilter = targetFilterDescriptor.Bool;
var mergeBoolFilter = mergeFilterDescriptor.Bool;
if (targetBoolFilter == null) return null;
var combined = new[] { targetFilterDescriptor, mergeFilterDescriptor };
return CreateReturnFilter((returnFilter, returnBoolFilter) =>
{
var boolFilter = ((IBoolFilter)returnBoolFilter);
if (!targetBoolFilter.CanMergeMustAndMustNots() || !mergeBoolFilter.CanMergeMustAndMustNots())
{
boolFilter.Must = combined;
return;
}
boolFilter.Must = (targetBoolFilter.Must ?? Empty)
.Concat(mergeBoolFilter != null
? (mergeBoolFilter.Must ?? Empty)
: new[] {mergeFilterDescriptor})
.NullIfEmpty();
boolFilter.MustNot = (targetBoolFilter.MustNot ?? Empty)
.Concat(mergeBoolFilter != null
? (mergeBoolFilter.MustNot ?? Empty)
: Empty
).NullIfEmpty();
});
}
protected internal override void WrapInContainer(IFilterContainer container)
{
container.Or = this;
}
protected internal override void WrapInContainer(IFilterContainer container)
{
container.GeoDistance = this;
}
