Merge pull request #2109 from elastic/fix/2086

gmarz · gmarz · commit 97f20853cca8 · 2016-05-26T11:25:55.000-04:00
Fix compound query conditionless logic
diff --git a/src/CodeGeneration/CodeGeneration.LowLevelClient/CodeGeneration.LowLevelClient.project.lock.json b/src/CodeGeneration/CodeGeneration.LowLevelClient/CodeGeneration.LowLevelClient.project.lock.json
@@ -1,6 +1,6 @@
 {
   "locked": false,
-  "version": 2,
+  "version": 1,
   "targets": {
     ".NETFramework,Version=v4.5": {},
     ".NETFramework,Version=v4.5/win": {}
diff --git a/src/CodeGeneration/Nest.Litterateur/Nest.Litterateur.project.lock.json b/src/CodeGeneration/Nest.Litterateur/Nest.Litterateur.project.lock.json
@@ -1,6 +1,6 @@
 {
   "locked": false,
-  "version": 2,
+  "version": 1,
   "targets": {
     ".NETFramework,Version=v4.5": {},
     ".NETFramework,Version=v4.5/win": {}
diff --git a/src/Elasticsearch.Net/Elasticsearch.Net.project.lock.json b/src/Elasticsearch.Net/Elasticsearch.Net.project.lock.json
@@ -1,6 +1,6 @@
 {
   "locked": false,
-  "version": 2,
+  "version": 1,
   "targets": {
     ".NETFramework,Version=v4.5": {},
     ".NETFramework,Version=v4.5/win": {}
diff --git a/src/Nest/CommonAbstractions/Extensions/Extensions.cs b/src/Nest/CommonAbstractions/Extensions/Extensions.cs
@@ -15,6 +15,10 @@ namespace Nest
 {
 	internal static class Extensions
 	{
+		internal static bool NotWritable(this QueryContainer q) => q == null || !q.IsWritable;
+
+		internal static bool NotWritable(this IEnumerable<QueryContainer> qs) => qs == null || qs.All(q => q.NotWritable());
+
 		internal static TReturn InvokeOrDefault<T, TReturn>(this Func<T, TReturn> func, T @default)
 			where T : class, TReturn where TReturn : class =>
 			func?.Invoke(@default) ?? @default;
diff --git a/src/Nest/QueryDsl/Compound/And/AndQuery.cs b/src/Nest/QueryDsl/Compound/And/AndQuery.cs
@@ -21,10 +21,7 @@ public class AndQuery : QueryBase, IAndQuery
 		public IEnumerable<QueryContainer> Filters { get; set; }
 
 		internal override void InternalWrapInContainer(IQueryContainer c) => c.And = this;
-		internal static bool IsConditionless(IAndQuery q)
-		{
-			return !q.Filters.HasAny() || q.Filters.All(f => f.IsConditionless);
-		}
+		internal static bool IsConditionless(IAndQuery q) => q.Filters.NotWritable();
 	}
 
 	[Obsolete("Use the bool query with a must clause instead. The bool query should not have other clauses to be semantically correct")]
diff --git a/src/Nest/QueryDsl/Compound/Bool/BoolQuery.cs b/src/Nest/QueryDsl/Compound/Bool/BoolQuery.cs
@@ -95,21 +95,8 @@ public class BoolQuery : QueryBase, IBoolQuery
 		internal override void InternalWrapInContainer(IQueryContainer c) => c.Bool = this;
 
 		protected override bool Conditionless => IsConditionless(this);
-		internal static bool IsConditionless(IBoolQuery q)
-		{
-			var musts = q.Must == null || q.Must.All(qq => qq.IsConditionless());
-			if (!musts) return false;
-
-			var shoulds = q.Should == null || q.Should.All(qq => qq.IsConditionless());
-			if (!shoulds) return false;
-
-			var filters = q.Filter == null || q.Filter.All(qq => qq.IsConditionless());
-			if (!filters) return false;
-
-			var mustNots = q.MustNot == null || q.MustNot.All(qq => qq.IsConditionless());
-
-			return mustNots;
-		}
+		internal static bool IsConditionless(IBoolQuery q) =>
+			q.Must.NotWritable() && q.MustNot.NotWritable() && q.Should.NotWritable() && q.Filter.NotWritable();
 	}
 
 	public class BoolQueryDescriptor<T>
diff --git a/src/Nest/QueryDsl/Compound/Boosting/BoostingQuery.cs b/src/Nest/QueryDsl/Compound/Boosting/BoostingQuery.cs
@@ -27,11 +27,10 @@ public class BoostingQuery : QueryBase, IBoostingQuery
 		public double? NegativeBoost { get; set; }
 
 		internal override void InternalWrapInContainer(IQueryContainer c) => c.Boosting = this;
-		internal static bool IsConditionless(IBoostingQuery q) =>
-			q.NegativeQuery.IsConditionless() && q.PositiveQuery.IsConditionless();
+		internal static bool IsConditionless(IBoostingQuery q) => q.NegativeQuery.NotWritable() && q.PositiveQuery.NotWritable();
 	}
 
-	public class BoostingQueryDescriptor<T> 
+	public class BoostingQueryDescriptor<T>
 		: QueryDescriptorBase<BoostingQueryDescriptor<T>, IBoostingQuery>
 		, IBoostingQuery where T : class
 	{
@@ -42,10 +41,10 @@ public class BoostingQueryDescriptor<T>
 
 		public BoostingQueryDescriptor<T> NegativeBoost(double? boost) => Assign(a => a.NegativeBoost = boost);
 
-		public BoostingQueryDescriptor<T> Positive(Func<QueryContainerDescriptor<T>, QueryContainer> selector) => 
+		public BoostingQueryDescriptor<T> Positive(Func<QueryContainerDescriptor<T>, QueryContainer> selector) =>
 			Assign(a => a.PositiveQuery = selector?.Invoke(new QueryContainerDescriptor<T>()));
 
-		public BoostingQueryDescriptor<T> Negative(Func<QueryContainerDescriptor<T>, QueryContainer> selector) => 
+		public BoostingQueryDescriptor<T> Negative(Func<QueryContainerDescriptor<T>, QueryContainer> selector) =>
 			Assign(a => a.NegativeQuery = selector?.Invoke(new QueryContainerDescriptor<T>()));
 	}
 }
diff --git a/src/Nest/QueryDsl/Compound/ConstantScore/ConstantScoreQuery.cs b/src/Nest/QueryDsl/Compound/ConstantScore/ConstantScoreQuery.cs
@@ -21,17 +21,17 @@ public class ConstantScoreQuery : QueryBase, IConstantScoreQuery
 		public QueryContainer Filter { get; set; }
 
 		internal override void InternalWrapInContainer(IQueryContainer c) => c.ConstantScore = this;
-		internal static bool IsConditionless(IConstantScoreQuery q) => q.Filter.IsConditionless();
+		internal static bool IsConditionless(IConstantScoreQuery q) => q.Filter.NotWritable();
 	}
 
-	public class ConstantScoreQueryDescriptor<T> 
+	public class ConstantScoreQueryDescriptor<T>
 		: QueryDescriptorBase<ConstantScoreQueryDescriptor<T>, IConstantScoreQuery>
 		, IConstantScoreQuery where T : class
 	{
 		protected override bool Conditionless => ConstantScoreQuery.IsConditionless(this);
 		QueryContainer IConstantScoreQuery.Filter { get; set; }
 
-		public ConstantScoreQueryDescriptor<T> Filter(Func<QueryContainerDescriptor<T>, QueryContainer> selector) => 
+		public ConstantScoreQueryDescriptor<T> Filter(Func<QueryContainerDescriptor<T>, QueryContainer> selector) =>
 			Assign(a => a.Filter = selector?.Invoke(new QueryContainerDescriptor<T>()));
 	}
 }
diff --git a/src/Nest/QueryDsl/Compound/Dismax/DismaxQuery.cs b/src/Nest/QueryDsl/Compound/Dismax/DismaxQuery.cs
@@ -23,21 +23,21 @@ public class DisMaxQuery : QueryBase, IDisMaxQuery
 		public IEnumerable<QueryContainer> Queries { get; set; }
 
 		internal override void InternalWrapInContainer(IQueryContainer c) => c.DisMax = this;
-		internal static bool IsConditionless(IDisMaxQuery q) => !q.Queries.HasAny() || q.Queries.All(qq => qq.IsConditionless);
+		internal static bool IsConditionless(IDisMaxQuery q) => q.Queries.NotWritable();
 	}
 
-	public class DisMaxQueryDescriptor<T> 
+	public class DisMaxQueryDescriptor<T>
 		: QueryDescriptorBase<DisMaxQueryDescriptor<T>, IDisMaxQuery>
 		, IDisMaxQuery where T : class
 	{
 		protected override bool Conditionless => DisMaxQuery.IsConditionless(this);
 		double? IDisMaxQuery.TieBreaker { get; set; }
 		IEnumerable<QueryContainer> IDisMaxQuery.Queries { get; set; }
 
-		public DisMaxQueryDescriptor<T> Queries(params Func<QueryContainerDescriptor<T>, QueryContainer>[] querySelectors) => 
+		public DisMaxQueryDescriptor<T> Queries(params Func<QueryContainerDescriptor<T>, QueryContainer>[] querySelectors) =>
 			Assign(a => a.Queries = querySelectors.Select(q=>q?.Invoke(new QueryContainerDescriptor<T>())).Where(q => q != null).ToListOrNullIfEmpty());
 
-		public DisMaxQueryDescriptor<T> Queries(IEnumerable<Func<QueryContainerDescriptor<T>, QueryContainer>> querySelectors) => 
+		public DisMaxQueryDescriptor<T> Queries(IEnumerable<Func<QueryContainerDescriptor<T>, QueryContainer>> querySelectors) =>
 			Assign(a => a.Queries = querySelectors.Select(q=>q?.Invoke(new QueryContainerDescriptor<T>())).Where(q => q != null).ToListOrNullIfEmpty());
 
 		public DisMaxQueryDescriptor<T> Queries(params QueryContainer[] queries) => Assign(a => a.Queries = queries.Where(q => q != null).ToListOrNullIfEmpty());
diff --git a/src/Nest/QueryDsl/Compound/Filtered/FilteredQuery.cs b/src/Nest/QueryDsl/Compound/Filtered/FilteredQuery.cs
@@ -24,31 +24,22 @@ public class FilteredQuery : QueryBase, IFilteredQuery
 
 		internal override void InternalWrapInContainer(IQueryContainer c) => c.Filtered = this;
 
-		internal static bool IsConditionless(IFilteredQuery q)
-		{
-			if (q.Query == null && q.Filter == null)
-				return true;
-			if (q.Filter == null && q.Query != null)
-				return q.Query.IsConditionless;
-			if (q.Filter != null && q.Query == null)
-				return q.Filter.IsConditionless;
-			return q.Query.IsConditionless() && q.Filter.IsConditionless();
-		}
+		internal static bool IsConditionless(IFilteredQuery q) => q.Query.NotWritable() && q.Filter.NotWritable();
 	}
 
 	[Obsolete("Use the bool query instead with a must clause for the query and a filter clause for the filter.")]
-	public class FilteredQueryDescriptor<T> 
-		: QueryDescriptorBase<FilteredQueryDescriptor<T>, IFilteredQuery>  
+	public class FilteredQueryDescriptor<T>
+		: QueryDescriptorBase<FilteredQueryDescriptor<T>, IFilteredQuery>
 		, IFilteredQuery where T : class
 	{
 		protected override bool Conditionless => FilteredQuery.IsConditionless(this);
 		QueryContainer IFilteredQuery.Query { get; set; }
 		QueryContainer IFilteredQuery.Filter { get; set; }
 
-		public FilteredQueryDescriptor<T> Query(Func<QueryContainerDescriptor<T>, QueryContainer> selector) => 
+		public FilteredQueryDescriptor<T> Query(Func<QueryContainerDescriptor<T>, QueryContainer> selector) =>
 			Assign(a => a.Query = selector?.Invoke(new QueryContainerDescriptor<T>()));
 
-		public FilteredQueryDescriptor<T> Filter(Func<QueryContainerDescriptor<T>, QueryContainer> selector) => 
+		public FilteredQueryDescriptor<T> Filter(Func<QueryContainerDescriptor<T>, QueryContainer> selector) =>
 			Assign(a => a.Filter = selector?.Invoke(new QueryContainerDescriptor<T>()));
 	}
 }
diff --git a/src/Nest/QueryDsl/Compound/Indices/IndicesQuery.cs b/src/Nest/QueryDsl/Compound/Indices/IndicesQuery.cs
@@ -36,23 +36,23 @@ public class IndicesQuery : QueryBase, IIndicesQuery
 		public Indices Indices { get; set; }
 
 		internal override void InternalWrapInContainer(IQueryContainer c) => c.Indices = this;
-		internal static bool IsConditionless(IIndicesQuery q) => 
-			q.Indices == null || (q.NoMatchQuery.IsConditionless() && q.Query.IsConditionless());
+		internal static bool IsConditionless(IIndicesQuery q) =>
+			q.Indices == null || q.NoMatchQuery.NotWritable() && q.Query.NotWritable();
 	}
 
-	public class IndicesQueryDescriptor<T> 
-		: QueryDescriptorBase<IndicesQueryDescriptor<T>, IIndicesQuery> 
+	public class IndicesQueryDescriptor<T>
+		: QueryDescriptorBase<IndicesQueryDescriptor<T>, IIndicesQuery>
 		, IIndicesQuery where T : class
 	{
 		protected override bool Conditionless => IndicesQuery.IsConditionless(this);
 		QueryContainer IIndicesQuery.Query { get; set; }
 		QueryContainer IIndicesQuery.NoMatchQuery { get; set; }
 		Indices IIndicesQuery.Indices { get; set; }
 
-		public IndicesQueryDescriptor<T> Query(Func<QueryContainerDescriptor<T>, QueryContainer> selector) => 
+		public IndicesQueryDescriptor<T> Query(Func<QueryContainerDescriptor<T>, QueryContainer> selector) =>
 			Assign(a => a.Query = selector?.Invoke(new QueryContainerDescriptor<T>()));
 
-		public IndicesQueryDescriptor<T> Query<TOther>(Func<QueryContainerDescriptor<TOther>, QueryContainer> selector) where TOther : class => 
+		public IndicesQueryDescriptor<T> Query<TOther>(Func<QueryContainerDescriptor<TOther>, QueryContainer> selector) where TOther : class =>
 			Assign(a => a.Query = selector?.Invoke(new QueryContainerDescriptor<TOther>()));
 
 		public IndicesQueryDescriptor<T> NoMatchQuery(NoMatchShortcut shortcut) =>
@@ -61,7 +61,7 @@ public IndicesQueryDescriptor<T> NoMatchQuery(NoMatchShortcut shortcut) =>
 		public IndicesQueryDescriptor<T> NoMatchQuery(Func<QueryContainerDescriptor<T>, QueryContainer> selector) =>
 			Assign(a => a.NoMatchQuery = selector?.Invoke(new QueryContainerDescriptor<T>()));
 
-		public IndicesQueryDescriptor<T> NoMatchQuery<TOther>(Func<QueryContainerDescriptor<TOther>, QueryContainer> selector) where TOther : class => 
+		public IndicesQueryDescriptor<T> NoMatchQuery<TOther>(Func<QueryContainerDescriptor<TOther>, QueryContainer> selector) where TOther : class =>
 			Assign(a => a.NoMatchQuery = selector?.Invoke(new QueryContainerDescriptor<TOther>()));
 
 		public IndicesQueryDescriptor<T> Indices(Indices indices) => Assign(a => a.Indices = indices);
diff --git a/src/Nest/QueryDsl/Compound/Not/NotQuery.cs b/src/Nest/QueryDsl/Compound/Not/NotQuery.cs
@@ -21,10 +21,7 @@ public class NotQuery : QueryBase, INotQuery
 		public IEnumerable<QueryContainer> Filters { get; set; }
 
 		internal override void InternalWrapInContainer(IQueryContainer c) => c.Not = this;
-		internal static bool IsConditionless(INotQuery q)
-		{
-			return !q.Filters.HasAny() || q.Filters.All(f => f.IsConditionless);
-		}
+		internal static bool IsConditionless(INotQuery q) => q.Filters.NotWritable();
 	}
 
 	[Obsolete("Use the bool query with must_not clause instead")]
diff --git a/src/Nest/QueryDsl/Compound/Or/OrQuery.cs b/src/Nest/QueryDsl/Compound/Or/OrQuery.cs
@@ -21,10 +21,7 @@ public class OrQuery : QueryBase, IOrQuery
 		public IEnumerable<QueryContainer> Filters { get; set; }
 
 		internal override void InternalWrapInContainer(IQueryContainer c) => c.Or = this;
-		internal static bool IsConditionless(IOrQuery q)
-		{
-			return !q.Filters.HasAny() || q.Filters.All(f => f.IsConditionless);
-		}
+		internal static bool IsConditionless(IOrQuery q) => q.Filters.NotWritable();
 	}
 
 	[Obsolete("Use the bool query instead with a should clause for the query")]
diff --git a/src/Tests/QueryDsl/Compound/Bool/BoolQueryUsageTests.cs b/src/Tests/QueryDsl/Compound/Bool/BoolQueryUsageTests.cs
@@ -2,6 +2,9 @@
 using Nest;
 using Tests.Framework.Integration;
 using Tests.Framework.MockData;
+using System;
+using Tests.Framework;
+using FluentAssertions;
 
 namespace Tests.QueryDsl.Compound.Bool
 {
@@ -75,5 +78,21 @@ protected override QueryContainer QueryFluent(QueryContainerDescriptor<Project>
 				q.Filter = new [] { ConditionlessQuery };
 			},
 		};
+
+		[U]
+		public void NullQueryDoesNotCauseANullReferenceException()
+		{
+			Action query = () => this.Client.Search<Project>(s => s
+					.Query(q => q
+						.Bool(b => b
+							.Filter(f => f
+								.Term(t => t.Name, null)
+							)
+						)
+					)
+				);
+
+			query.ShouldNotThrow();
+		}
 	}
 }
diff --git a/src/Tests/QueryDsl/Compound/Dismax/DismaxQueryUsageTests.cs b/src/Tests/QueryDsl/Compound/Dismax/DismaxQueryUsageTests.cs
@@ -2,6 +2,9 @@
 using Nest;
 using Tests.Framework.Integration;
 using Tests.Framework.MockData;
+using Tests.Framework;
+using System;
+using FluentAssertions;
 
 #pragma warning disable 618 //Testing an obsolete method
 
@@ -53,5 +56,21 @@ protected override QueryContainer QueryFluent(QueryContainerDescriptor<Project>
 			q => q.Queries = Enumerable.Empty<QueryContainer>(),
 			q => q.Queries = new [] { ConditionlessQuery },
 		};
+
+		[U]
+		public void NullQueryDoesNotCauseANullReferenceException()
+		{
+			Action query = () => this.Client.Search<Project>(s => s
+				.Query(q => q
+					.DisMax(dm => dm
+						.Queries(
+							dmq => dmq.Term(t => t.Name, null)
+						)
+					)
+				)
+			);
+
+			query.ShouldNotThrow();
+		}
 	}
 }
diff --git a/src/Tests/QueryDsl/QueryDslUsageTestsBase.cs b/src/Tests/QueryDsl/QueryDslUsageTestsBase.cs
@@ -84,36 +84,7 @@ public void ConditionlessWhenExpectedToBe()
 			((IQueryContainer)this.QueryInitializer).IsConditionless.Should().BeFalse();
 		}
 
-		[U]
-		public void NullQueryDoesNotCauseANullReferenceException()
-		{
-			Action query = () => this.Client.Search<Project>(s => s
-					.Query(q => q
-						.Bool(b => b
-							.Filter(f => f
-								.Term(t => t.Name, null)
-							)
-						)
-					)
-				);
-
-			query.ShouldNotThrow();
-
-			query = () => this.Client.Search<Project>(s => s
-				.Query(q => q
-					.DisMax(dm => dm
-						.Queries(
-							dmq => dmq.Term(t => t.Name, null)
-						)
-					)
-				)
-			);
-
-			query.ShouldNotThrow();
-		}
-
 		private void IsConditionless(IQueryContainer q, bool be) => q.IsConditionless.Should().Be(be);
-
 	}
 
 	public abstract class ConditionlessWhen : List<Action<QueryContainer>>
diff --git a/src/Tests/QueryDsl/Verbatim/VerbatimAndStrictQueryUsageTests.cs b/src/Tests/QueryDsl/Verbatim/VerbatimAndStrictQueryUsageTests.cs

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"locked": false,`
`3`		`- "version": 2,`
	`3`	`+ "version": 1,`
`4`	`4`	`"targets": {`
`5`	`5`	`".NETFramework,Version=v4.5": {},`
`6`	`6`	`".NETFramework,Version=v4.5/win": {}`
Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,10 @@ namespace Nest`
`15`	`15`	`{`
`16`	`16`	`internal static class Extensions`
`17`	`17`	`{`
	`18`	`+ internal static bool NotWritable(this QueryContainer q) => q == null \|\| !q.IsWritable;`
	`19`	`+`
	`20`	`+ internal static bool NotWritable(this IEnumerable<QueryContainer> qs) => qs == null \|\| qs.All(q => q.NotWritable());`
	`21`	`+`
`18`	`22`	`internal static TReturn InvokeOrDefault<T, TReturn>(this Func<T, TReturn> func, T @default)`
`19`	`23`	`where T : class, TReturn where TReturn : class =>`
`20`	`24`	`func?.Invoke(@default) ?? @default;`
Original file line number	Diff line number	Diff line change
`@@ -27,11 +27,10 @@ public class BoostingQuery : QueryBase, IBoostingQuery`
`27`	`27`	`public double? NegativeBoost { get; set; }`
`28`	`28`
`29`	`29`	`internal override void InternalWrapInContainer(IQueryContainer c) => c.Boosting = this;`
`30`		`- internal static bool IsConditionless(IBoostingQuery q) =>`
`31`		`- q.NegativeQuery.IsConditionless() && q.PositiveQuery.IsConditionless();`
	`30`	`+ internal static bool IsConditionless(IBoostingQuery q) => q.NegativeQuery.NotWritable() && q.PositiveQuery.NotWritable();`
`32`	`31`	`}`
`33`	`32`
`34`		`- public class BoostingQueryDescriptor<T>`
	`33`	`+ public class BoostingQueryDescriptor<T>`
`35`	`34`	`: QueryDescriptorBase<BoostingQueryDescriptor<T>, IBoostingQuery>`
`36`	`35`	`, IBoostingQuery where T : class`
`37`	`36`	`{`
`@@ -42,10 +41,10 @@ public class BoostingQueryDescriptor<T>`
`42`	`41`
`43`	`42`	`public BoostingQueryDescriptor<T> NegativeBoost(double? boost) => Assign(a => a.NegativeBoost = boost);`
`44`	`43`
`45`		`- public BoostingQueryDescriptor<T> Positive(Func<QueryContainerDescriptor<T>, QueryContainer> selector) =>`
	`44`	`+ public BoostingQueryDescriptor<T> Positive(Func<QueryContainerDescriptor<T>, QueryContainer> selector) =>`
`46`	`45`	`Assign(a => a.PositiveQuery = selector?.Invoke(new QueryContainerDescriptor<T>()));`
`47`	`46`
`48`		`- public BoostingQueryDescriptor<T> Negative(Func<QueryContainerDescriptor<T>, QueryContainer> selector) =>`
	`47`	`+ public BoostingQueryDescriptor<T> Negative(Func<QueryContainerDescriptor<T>, QueryContainer> selector) =>`
`49`	`48`	`Assign(a => a.NegativeQuery = selector?.Invoke(new QueryContainerDescriptor<T>()));`
`50`	`49`	`}`
`51`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,17 +21,17 @@ public class ConstantScoreQuery : QueryBase, IConstantScoreQuery`
`21`	`21`	`public QueryContainer Filter { get; set; }`
`22`	`22`
`23`	`23`	`internal override void InternalWrapInContainer(IQueryContainer c) => c.ConstantScore = this;`
`24`		`- internal static bool IsConditionless(IConstantScoreQuery q) => q.Filter.IsConditionless();`
	`24`	`+ internal static bool IsConditionless(IConstantScoreQuery q) => q.Filter.NotWritable();`
`25`	`25`	`}`
`26`	`26`
`27`		`- public class ConstantScoreQueryDescriptor<T>`
	`27`	`+ public class ConstantScoreQueryDescriptor<T>`
`28`	`28`	`: QueryDescriptorBase<ConstantScoreQueryDescriptor<T>, IConstantScoreQuery>`
`29`	`29`	`, IConstantScoreQuery where T : class`
`30`	`30`	`{`
`31`	`31`	`protected override bool Conditionless => ConstantScoreQuery.IsConditionless(this);`
`32`	`32`	`QueryContainer IConstantScoreQuery.Filter { get; set; }`
`33`	`33`
`34`		`- public ConstantScoreQueryDescriptor<T> Filter(Func<QueryContainerDescriptor<T>, QueryContainer> selector) =>`
	`34`	`+ public ConstantScoreQueryDescriptor<T> Filter(Func<QueryContainerDescriptor<T>, QueryContainer> selector) =>`
`35`	`35`	`Assign(a => a.Filter = selector?.Invoke(new QueryContainerDescriptor<T>()));`
`36`	`36`	`}`
`37`	`37`	`}`