Add support for ignore_unmapped on geo sorts (#3436)

Also add median as sort mode to general sorting

Author: Mpdreamz

src/Nest/Search/Search/Sort/SortGeoDistance.cs

@@ -5,28 +5,47 @@
 
 namespace Nest
 {
+	/// <summary> Allows you to sort based on a proximity to one or more <see cref="GeoLocation"/> </summary>
 	public interface IGeoDistanceSort : ISort
 	{
 		Field Field { get; set; }
 		IEnumerable<GeoLocation> Points { get; set; }
 
+		/// <summary> The unit to use when computing sort values. The default is m (meters) </summary>
 		[JsonProperty("unit")]
 		DistanceUnit? GeoUnit { get; set; }
 
+		/// <summary>
+		/// How to compute the distance. Can either be arc (default), or plane (faster, but
+		/// inaccurate on long distances and close to the poles).
+		/// </summary>
 		[JsonProperty("distance_type")]
 		GeoDistanceType? DistanceType { get; set; }
+
+		/// <summary>
+		/// Indicates if the unmapped field should be treated as a missing value. Setting it to `true` is equivalent to specifying
+		/// an `unmapped_type` in the field sort. The default is `false` (unmapped field are causing the search to fail)
+		/// </summary>
+		[JsonProperty("ignore_unmapped")]
+		bool? IgnoreUnmapped { get; set; }
 	}
 
+	/// <inheritdoc cref="IGeoDistanceSort"/>
 	public class GeoDistanceSort : SortBase, IGeoDistanceSort
 	{
 		protected override Field SortKey => "_geo_distance";
 		public Field Field { get; set; }
 		public IEnumerable<GeoLocation> Points { get; set; }
+		/// <inheritdoc cref="IGeoDistanceSort.GeoUnit"/>
 		public DistanceUnit? GeoUnit { get; set; }
+		/// <inheritdoc cref="IGeoDistanceSort.DistanceType"/>
 		public GeoDistanceType? DistanceType { get; set; }
+		/// <inheritdoc cref="IGeoDistanceSort.IgnoreUnmapped"/>
+		public bool? IgnoreUnmapped { get; set; }
 
 	}
 
+	/// <inheritdoc cref="IGeoDistanceSort"/>
 	public class SortGeoDistanceDescriptor<T> : SortDescriptorBase<SortGeoDistanceDescriptor<T>, IGeoDistanceSort, T>, IGeoDistanceSort
 		where T : class
 	{
@@ -36,18 +55,24 @@ public class SortGeoDistanceDescriptor<T> : SortDescriptorBase<SortGeoDistanceDe
 		IEnumerable<GeoLocation> IGeoDistanceSort.Points { get; set; }
 		DistanceUnit? IGeoDistanceSort.GeoUnit { get; set; }
 		GeoDistanceType? IGeoDistanceSort.DistanceType { get; set; }
+		bool? IGeoDistanceSort.IgnoreUnmapped { get; set; }
 
 		public SortGeoDistanceDescriptor<T> Points(params GeoLocation[] geoLocations) => Assign(a => a.Points = geoLocations);
 
 		public SortGeoDistanceDescriptor<T> Points(IEnumerable<GeoLocation> geoLocations) => Assign(a => a.Points = geoLocations);
 
+		/// <inheritdoc cref="IGeoDistanceSort.GeoUnit"/>
 		public SortGeoDistanceDescriptor<T> Unit(DistanceUnit? unit) => Assign(a => a.GeoUnit = unit);
 
+		/// <inheritdoc cref="IGeoDistanceSort.DistanceType"/>
 		public SortGeoDistanceDescriptor<T> DistanceType(GeoDistanceType? distanceType) => Assign(a => a.DistanceType = distanceType);
 
 		public SortGeoDistanceDescriptor<T> Field(Field field) => Assign(a => a.Field = field);
 
 		public SortGeoDistanceDescriptor<T> Field(Expression<Func<T, object>> objectPath) => Assign(a => a.Field = objectPath);
 
+		/// <inheritdoc cref="IGeoDistanceSort.IgnoreUnmapped"/>
+		public SortGeoDistanceDescriptor<T> IgnoreUnmapped(bool? ignoreUnmapped = true) => Assign(a => a.IgnoreUnmapped = ignoreUnmapped);
+
 	}
 }

src/Nest/Search/Search/Sort/SortMode.cs

@@ -4,16 +4,27 @@
 
 namespace Nest
 {
+	/// <summary>
+	/// Elasticsearch supports sorting by array or multi-valued fields. The mode option controls what array value is picked for
+	/// sorting the document it belongs to.
+	/// </summary>
 	[JsonConverter(typeof(StringEnumConverter))]
 	public enum SortMode
 	{
+		/// <summary> Pick the lowest value. </summary>
 		[EnumMember(Value = "min")]
 		Min,
+		/// <summary> Pick the highest value.</summary>
 		[EnumMember(Value = "max")]
 		Max,
+		/// <summary> Use the sum of all values as sort value. Only applicable for number based array fields. </summary>
 		[EnumMember(Value = "sum")]
 		Sum,
+		/// <summary> Use the average of all values as sort value. Only applicable for number based array fields. </summary>
 		[EnumMember(Value = "avg")]
-		Average
+		Average,
+		/// <summary> Use the median of all values as sort value. Only applicable for number based array fields. </summary>
+		[EnumMember(Value = "median")]
+		Median
 	}
-}
+}

src/Tests/Tests/Search/Request/SortUsageTests.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Linq.Expressions;
 using Elastic.Xunit.XunitPlumbing;
 using Nest;
 using Tests.Core.ManagedElasticsearch.Clusters;
@@ -270,4 +271,66 @@ public NestedSortUsageTests(ReadOnlyCluster cluster, EndpointUsage usage) : base
 				}
 			};
 	}
+
+	//hide
+	[SkipVersion("<6.4.0", "IgnoreUnmapped introduced in 6.4.0 on geo distance sort")]
+	public class GeoDistanceIgnoreUnmappedUsageTests : SearchUsageTestBase
+	{
+		public GeoDistanceIgnoreUnmappedUsageTests(ReadOnlyCluster cluster, EndpointUsage usage) : base(cluster, usage) { }
+
+		protected override object ExpectJson =>
+			new
+			{
+				sort = new object[]
+				{
+					new
+					{
+						_geo_distance = new
+						{
+							location = new[]
+							{
+								new { lat = 70.0, lon = -70.0 },
+								new { lat = -12.0, lon = 12.0 }
+							},
+							order = "asc",
+							mode = "min",
+							distance_type = "arc",
+							ignore_unmapped = true,
+							unit = "cm"
+						}
+					}
+				}
+			};
+
+		protected override Func<SearchDescriptor<Project>, ISearchRequest> Fluent => s => s
+			.Sort(ss => ss
+				.GeoDistance(g => g
+					.Field(p => p.Location)
+					.IgnoreUnmapped()
+					.DistanceType(GeoDistanceType.Arc)
+					.Order(SortOrder.Ascending)
+					.Unit(DistanceUnit.Centimeters)
+					.Mode(SortMode.Min)
+					.Points(new GeoLocation(70, -70), new GeoLocation(-12, 12))
+				)
+			);
+
+		protected override SearchRequest<Project> Initializer =>
+			new SearchRequest<Project>
+			{
+				Sort = new List<ISort>
+				{
+					new GeoDistanceSort
+					{
+						Field = "location",
+						IgnoreUnmapped = true,
+						Order = SortOrder.Ascending,
+						DistanceType = GeoDistanceType.Arc,
+						GeoUnit = DistanceUnit.Centimeters,
+						Mode = SortMode.Min,
+						Points = new[] {new GeoLocation(70, -70), new GeoLocation(-12, 12)}
+					},
+				}
+			};
+	}
 }