Merge branch 'master' of github.com:elastic/elasticsearch-net

Author: Mpdreamz

src/Nest/IndexModules/IndexSettings/Settings/IndexSettings.cs

@@ -13,7 +13,6 @@ public interface IIndexSettings : IDynamicIndexSettings
 		/// </summary>
 		int? NumberOfShards { get; set; }
 
-
 		//TODO remove pre note with 6.0
 		/// <summary>
 		/// By defaulting, routing resolves to a single shard. Use this settings to have it resolve to a set of shards instead.
@@ -32,6 +31,12 @@ public interface IIndexSettings : IDynamicIndexSettings
 		/// Settings associated with queries.
 		/// </summary>
 		IQueriesSettings Queries { get; set; }
+
+		/// <summary>
+		///  Settings associated with index sorting.
+		/// https://www.elastic.co/guide/en/elasticsearch/reference/6.0/index-modules-index-sorting.html
+		/// </summary>
+		ISortingSettings Sorting { get; set; }
 	}
 
 	/// <inheritdoc />
@@ -51,6 +56,9 @@ public IndexSettings(IDictionary<string, object> container) : base(container) {
 
 		/// <inheritdoc />
 		public IQueriesSettings Queries { get; set; }
+
+		/// <inheritdoc />
+		public ISortingSettings Sorting { get; set; }
 	}
 
 	/// <inheritdoc />
@@ -72,6 +80,8 @@ public IndexSettingsDescriptor FileSystemStorageImplementation(FileSystemStorage
 
 		public IndexSettingsDescriptor Queries(Func<QueriesSettingsDescriptor, IQueriesSettings> selector) =>
 			Assign(a => a.Queries = selector?.Invoke(new QueriesSettingsDescriptor()));
-	}
 
+		public IndexSettingsDescriptor Sorting<T>(Func<SortingSettingsDescriptor<T>, ISortingSettings> selector) where T : class =>
+			Assign(a => a.Sorting = selector?.Invoke(new SortingSettingsDescriptor<T>()));
+	}
 }

src/Nest/IndexModules/IndexSettings/Settings/IndexSettingsConverter.cs

@@ -77,14 +77,33 @@ public override void WriteJson(JsonWriter writer, object value, JsonSerializer s
 			d[UpdatableIndexSettings.Analysis] = ds.Analysis;
 
 			var indexSettings = value as IIndexSettings;
-            d[FixedIndexSettings.NumberOfShards] = indexSettings?.NumberOfShards;
+
+			d[FixedIndexSettings.NumberOfShards] = indexSettings?.NumberOfShards;
             d[FixedIndexSettings.RoutingPartitionSize] = indexSettings?.RoutingPartitionSize;
             d[UpdatableIndexSettings.StoreType] = indexSettings?.FileSystemStorageImplementation;
             d[UpdatableIndexSettings.QueriesCacheEnabled] = indexSettings?.Queries?.Cache?.Enabled;
 
+			if (indexSettings?.Sorting != null)
+			{
+				d[IndexSortSettings.Fields] = AsArrayOrSingleItem(indexSettings.Sorting.Fields);
+				d[IndexSortSettings.Order] = AsArrayOrSingleItem(indexSettings.Sorting.Order);
+				d[IndexSortSettings.Mode] = AsArrayOrSingleItem(indexSettings.Sorting.Mode);
+				d[IndexSortSettings.Missing] = AsArrayOrSingleItem(indexSettings.Sorting.Missing);
+			}
+
 			base.WriteJson(writer, d, serializer);
 		}
 
+		private object AsArrayOrSingleItem<T>(IEnumerable<T> items)
+		{
+			if (items == null || !items.Any())
+				return null;
+
+			if (items.Count() == 1)
+				return items.First();
+
+			return items;
+		}
 
 		public JObject Flatten(JObject original, string prefix = "", JObject newObject = null)
 		{
@@ -184,6 +203,12 @@ private void SetKnownIndexSettings(JsonReader reader, JsonSerializer serializer,
 			Set<int?>(s, settings, FixedIndexSettings.RoutingPartitionSize, v => s.RoutingPartitionSize = v);
 			Set<FileSystemStorageImplementation?>(s, settings, UpdatableIndexSettings.StoreType, v => s.FileSystemStorageImplementation = v, serializer);
 
+			var sorting = s.Sorting = new SortingSettings();
+			SetArray<string[], string>(s, settings, IndexSortSettings.Fields, v => sorting.Fields = v, v => sorting.Fields = new [] { v });
+			SetArray<IndexSortOrder[], IndexSortOrder>(s, settings, IndexSortSettings.Order, v => sorting.Order = v, v => sorting.Order = new [] { v });
+			SetArray<IndexSortMode[], IndexSortMode>(s, settings, IndexSortSettings.Mode, v => sorting.Mode = v, v => sorting.Mode = new [] { v });
+			SetArray<IndexSortMissing[], IndexSortMissing>(s, settings, IndexSortSettings.Missing, v => sorting.Missing = v, v => sorting.Missing = new [] { v });
+
 			var queries = s.Queries = new QueriesSettings();
 			var queriesCache = s.Queries.Cache = new QueriesCacheSettings();
 			Set<bool?>(s, settings, UpdatableIndexSettings.QueriesCacheEnabled, v => queriesCache.Enabled = v);
@@ -205,10 +230,29 @@ private static void Set<T>(IIndexSettings s, IDictionary<string, JProperty> sett
 		{
 			if (!settings.ContainsKey(key)) return;
 			var v = settings[key];
-			T value = serializer == null ? v.Value.ToObject<T>() : v.Value.ToObject<T>(serializer);
+			var value = serializer == null ? v.Value.ToObject<T>() : v.Value.ToObject<T>(serializer);
 			assign(value);
 			s.Add(key, value);
 			settings.Remove(key);
 		}
+
+		private static void SetArray<TArray, TItem>(IIndexSettings s, IDictionary<string, JProperty> settings, string key, Action<TArray> assign, Action<TItem> assign2, JsonSerializer serializer = null)
+		{
+			if (!settings.ContainsKey(key)) return;
+			var v = settings[key];
+			if (v.Value is JArray)
+			{
+				var value = serializer == null ? v.Value.ToObject<TArray>() : v.Value.ToObject<TArray>(serializer);
+				assign(value);
+				s.Add(key, value);
+			}
+			else
+			{
+				var value = serializer == null ? v.Value.ToObject<TItem>() : v.Value.ToObject<TItem>(serializer);
+				assign2(value);
+				s.Add(key, value);
+			}
+			settings.Remove(key);
+		}
 	}
 }

src/Nest/IndexModules/IndexSettings/Sorting/ISortingSettings.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Runtime.Serialization;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace Nest
+{
+	public static class IndexSortSettings
+	{
+		public const string Fields = "index.sort.field";
+		public const string Order = "index.sort.order";
+		public const string Mode = "index.sort.mode";
+		public const string Missing = "index.sort.missing";
+	}
+
+	[JsonConverter(typeof(StringEnumConverter))]
+	public enum IndexSortMode
+	{
+		[EnumMember(Value = "min")]
+		Minimum,
+		[EnumMember(Value = "max")]
+		Maximum
+	}
+
+	[JsonConverter(typeof(StringEnumConverter))]
+	public enum IndexSortMissing
+	{
+		[EnumMember(Value = "_first")]
+		First,
+		[EnumMember(Value = "_last")]
+		Last
+	}
+
+	[JsonConverter(typeof(StringEnumConverter))]
+	public enum IndexSortOrder
+	{
+		[EnumMember(Value = "asc")]
+		Ascending,
+		[EnumMember(Value = "desc")]
+		Descending
+	}
+
+	public interface ISortingSettings
+	{
+		/// <summary>
+		/// The list of fields used to sort the index. Only boolean, numeric, date and keyword fields with doc_values are allowed here.
+		/// </summary>
+		Fields Fields { get; set; }
+
+		/// <summary>
+		/// The sort order to use for each field. The order option can have the following values: <see cref="IndexSortOrder.Ascending"/> and <see cref="IndexSortOrder.Descending"/>.
+		/// </summary>
+		IndexSortOrder[] Order { get; set; }
+
+		/// <summary>
+		/// The mode option controls what value, from a multi-value field, is picked to sort the document.
+		/// The mode option can have the following values:
+		/// <see cref="IndexSortMode.Minimum" />: Pick the lowest value.
+		/// <see cref="IndexSortMode.Maximum" />: Pick the highest value.
+		/// </summary>
+		IndexSortMode[] Mode { get; set; }
+
+		/// <summary>
+		/// The missing parameter specifies how docs which are missing the field should be treated. The missing value can have the following values:
+		/// <see cref="IndexSortMissing.Last"/>: Documents without value for the field are sorted last.
+		/// <see cref="IndexSortMissing.First"/>: Documents without value for the field are sorted first.
+		/// </summary>
+		IndexSortMissing[] Missing { get; set; }
+	}
+
+	public class SortingSettings : ISortingSettings
+	{
+		/// <inheritdoc/>
+		public Fields Fields { get; set; }
+
+		/// <inheritdoc/>
+		public IndexSortOrder[] Order { get; set; }
+
+		/// <inheritdoc/>
+		public IndexSortMode[] Mode { get; set; }
+
+		/// <inheritdoc/>
+		public IndexSortMissing[] Missing { get; set; }
+	}
+
+	public class SortingSettingsDescriptor<T> : DescriptorBase<SortingSettingsDescriptor<T>, ISortingSettings>, ISortingSettings where T : class
+	{
+		Fields ISortingSettings.Fields { get; set; }
+		IndexSortOrder[] ISortingSettings.Order { get; set; }
+		IndexSortMode[] ISortingSettings.Mode { get; set; }
+		IndexSortMissing[] ISortingSettings.Missing { get; set; }
+
+		public SortingSettingsDescriptor<T> Fields(Func<FieldsDescriptor<T>, IPromise<Fields>> fields) => Assign(a => a.Fields = fields?.Invoke(new FieldsDescriptor<T>())?.Value);
+
+		public SortingSettingsDescriptor<T> Fields(Fields fields) => Assign(a => a.Fields = fields);
+
+		public SortingSettingsDescriptor<T> Order(params IndexSortOrder[] order) => Assign(a => a.Order = order);
+
+		public SortingSettingsDescriptor<T> Mode(params IndexSortMode[] mode) => Assign(a => a.Mode = mode);
+
+		public SortingSettingsDescriptor<T> Missing(params IndexSortMissing[] missing) => Assign(a => a.Missing = missing);
+	}
+}

src/Tests/IndexModules/IndexSettings/Sorting/SortingSettingsSingleItem.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using Nest;
+using Tests.Framework;
+
+namespace Tests.IndexModules.IndexSettings.Sorting
+{
+	public class SortingSettingsSingleItem
+	{
+		private class TestClass
+		{
+			public string field1 { get; set; }
+		}
+
+		public class Usage : PromiseUsageTestBase<IIndexSettings, IndexSettingsDescriptor, Nest.IndexSettings>
+		{
+			protected override object ExpectJson => new Dictionary<string, object>
+			{
+				{"index.sort.field", "field1" },
+				{"index.sort.order", "asc" },
+				{"index.sort.mode", "min" },
+				{"index.sort.missing", "_first" },
+			};
+
+			protected override Func<IndexSettingsDescriptor, IPromise<IIndexSettings>> Fluent => s => s
+				.Sorting<TestClass>(sl => sl
+					.Fields("field1")
+					.Order(IndexSortOrder.Ascending)
+					.Mode(IndexSortMode.Minimum)
+					.Missing(IndexSortMissing.First)
+				);
+
+			protected override Nest.IndexSettings Initializer =>
+				new Nest.IndexSettings
+				{
+					Sorting = new Nest.SortingSettings
+					{
+						Fields = new[] { "field1" },
+						Order = new [] { IndexSortOrder.Ascending },
+						Mode = new [] { IndexSortMode.Minimum },
+						Missing = new [] { IndexSortMissing.First }
+					}
+				};
+		}
+	}
+
+	public class SortingSettingsArray
+	{
+		private class TestClass
+		{
+			public string field1 { get; set; }
+			public string field2 { get; set; }
+		}
+
+		public class Usage : PromiseUsageTestBase<IIndexSettings, IndexSettingsDescriptor, Nest.IndexSettings>
+		{
+			protected override object ExpectJson => new Dictionary<string, object>
+			{
+				{"index.sort.field", new[] { "field1", "field2" } },
+				{"index.sort.order", new[] { "asc", "desc" } },
+				{"index.sort.mode", new[] { "min", "max" } },
+				{"index.sort.missing", new[] { "_first", "_last" } },
+			};
+
+			protected override Func<IndexSettingsDescriptor, IPromise<IIndexSettings>> Fluent => s => s
+				.Sorting<TestClass>(sl => sl
+					.Fields(f => f.Field(p => p.field1).Field("field2"))
+					.Order(IndexSortOrder.Ascending, IndexSortOrder.Descending)
+					.Mode(IndexSortMode.Minimum, IndexSortMode.Maximum)
+					.Missing(IndexSortMissing.First,IndexSortMissing.Last)
+				);
+
+			protected override Nest.IndexSettings Initializer =>
+				new Nest.IndexSettings
+				{
+					Sorting = new Nest.SortingSettings
+					{
+						Fields = new[] { "field1", "field2" },
+						Order = new [] { IndexSortOrder.Ascending, IndexSortOrder.Descending },
+						Mode = new [] { IndexSortMode.Minimum, IndexSortMode.Maximum },
+						Missing = new [] { IndexSortMissing.First, IndexSortMissing.Last }
+					}
+				};
+		}
+	}
+}