Fix #2336 add support for specifying the key type for a terms aggregation

rather than always deserializing to a string, by making KeyedBucket
generic.

One can now do `response.Aggs.Terms<int>("my_terms")`

The non-generic helper `.Terms("my_terms")` still remains for strings as it's
the most common use case, and also so we don't break anyone.

Also removed `HistogramBucket`, as it can now be simplified to
`KeyedBucket<double>`.

Author: gmarz

src/Nest/Aggregations/AggregateJsonConverter.cs

@@ -547,38 +547,35 @@ private IBucket GetDateHistogramBucket(JsonReader reader, JsonSerializer seriali
 
 		private IBucket GetKeyedBucket(JsonReader reader, JsonSerializer serializer)
 		{
-			var key = reader.ReadAsString();
+			reader.Read();
+			var key = reader.Value;
 			reader.Read();
 			var property = reader.Value as string;
 			if (property == "from" || property == "to")
-				return GetRangeBucket(reader, serializer, key);
+				return GetRangeBucket(reader, serializer, key as string);
 
-			var keyItem = new KeyedBucket { Key = key };
+			var bucket = new KeyedBucket<object> { Key = key };
 
 			if (property == "key_as_string")
 			{
-				keyItem.KeyAsString = reader.ReadAsString();
+				bucket.KeyAsString = reader.ReadAsString();
 				reader.Read();
 			}
 
 			reader.Read(); //doc_count;
 			var docCount = reader.Value as long?;
-			keyItem.DocCount = docCount.GetValueOrDefault(0);
+			bucket.DocCount = docCount.GetValueOrDefault(0);
 			reader.Read();
 
 			var nextProperty = reader.Value as string;
 			if (nextProperty == "score")
-			{
-				return GetSignificantTermsBucket(reader, serializer, keyItem);
-			}
-
-
-			keyItem.Aggregations = this.GetSubAggregates(reader, serializer);
-			return keyItem;
+				return GetSignificantTermsBucket(reader, serializer, bucket);
 
+			bucket.Aggregations = this.GetSubAggregates(reader, serializer);
+			return bucket;
 		}
 
-		private IBucket GetSignificantTermsBucket(JsonReader reader, JsonSerializer serializer, KeyedBucket keyItem)
+		private IBucket GetSignificantTermsBucket(JsonReader reader, JsonSerializer serializer, KeyedBucket<object> keyItem)
 		{
 			reader.Read();
 			var score = reader.Value as double?;
@@ -587,7 +584,7 @@ private IBucket GetSignificantTermsBucket(JsonReader reader, JsonSerializer seri
 			var bgCount = reader.Value as long?;
 			var significantTermItem = new SignificantTermsBucket()
 			{
-				Key = keyItem.Key,
+				Key = keyItem.Key as string,
 				DocCount = keyItem.DocCount.GetValueOrDefault(0),
 				BgCount = bgCount.GetValueOrDefault(0),
 				Score = score.GetValueOrDefault(0)

src/Nest/Aggregations/AggregationsHelper.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
@@ -117,55 +118,35 @@ public SignificantTermsAggregate SignificantTerms(string key)
 				};
 		}
 
-		public TermsAggregate Terms(string key)
+		public TermsAggregate<TKey> Terms<TKey>(string key)
 		{
 			var bucket = this.TryGet<BucketAggregate>(key);
 			return bucket == null
 				? null
-				: new TermsAggregate
+				: new TermsAggregate<TKey>
 				{
 					DocCountErrorUpperBound = bucket.DocCountErrorUpperBound,
 					SumOtherDocCount = bucket.SumOtherDocCount,
-					Buckets = bucket.Items.OfType<KeyedBucket>().ToList(),
+					Buckets = GetKeyedBuckets<TKey>(bucket.Items).ToList(),
 					Meta = bucket.Meta
 				};
 		}
 
-		public MultiBucketAggregate<HistogramBucket> Histogram(string key)
-		{
-			var bucket = this.TryGet<BucketAggregate>(key);
-			return bucket == null
-				? null
-				: new MultiBucketAggregate<HistogramBucket>
-				{
-					Buckets = bucket.Items.OfType<HistogramBucket>()
-						.Concat(bucket.Items.OfType<KeyedBucket>()
-							.Select(x =>
-								new HistogramBucket
-								{
-									Key = double.Parse(x.Key, CultureInfo.InvariantCulture),
-									KeyAsString = x.Key,
-									DocCount = x.DocCount.GetValueOrDefault(0),
-									Aggregations = x.Aggregations
-								}
-							)
-						)
-						.ToList(),
-					Meta = bucket.Meta
-				};
-		}
+		public TermsAggregate<string> Terms(string key) => Terms<string>(key);
+
+		public MultiBucketAggregate<KeyedBucket<double>> Histogram(string key) => GetMultiKeyedBucketAggregate<double>(key);
 
-		public MultiBucketAggregate<KeyedBucket> GeoHash(string key) => GetBucket<KeyedBucket>(key);
+		public MultiBucketAggregate<KeyedBucket<string>> GeoHash(string key) => GetMultiKeyedBucketAggregate<string>(key);
 
-		public MultiBucketAggregate<RangeBucket> Range(string key) => GetBucket<RangeBucket>(key);
+		public MultiBucketAggregate<RangeBucket> Range(string key) => GetMultiBucketAggregate<RangeBucket>(key);
 
-		public MultiBucketAggregate<RangeBucket> DateRange(string key) => GetBucket<RangeBucket>(key);
+		public MultiBucketAggregate<RangeBucket> DateRange(string key) => GetMultiBucketAggregate<RangeBucket>(key);
 
-		public MultiBucketAggregate<RangeBucket> IpRange(string key) => GetBucket<RangeBucket>(key);
+		public MultiBucketAggregate<RangeBucket> IpRange(string key) => GetMultiBucketAggregate<RangeBucket>(key);
 
-		public MultiBucketAggregate<RangeBucket> GeoDistance(string key) => GetBucket<RangeBucket>(key);
+		public MultiBucketAggregate<RangeBucket> GeoDistance(string key) => GetMultiBucketAggregate<RangeBucket>(key);
 
-		public MultiBucketAggregate<DateHistogramBucket> DateHistogram(string key) => GetBucket<DateHistogramBucket>(key);
+		public MultiBucketAggregate<DateHistogramBucket> DateHistogram(string key) => GetMultiBucketAggregate<DateHistogramBucket>(key);
 
 		public MatrixStatsAggregate MatrixStats(string key) => this.TryGet<MatrixStatsAggregate>(key);
 
@@ -177,16 +158,43 @@ private TAggregate TryGet<TAggregate>(string key)
 			return this.Aggregations.TryGetValue(key, out agg) ? agg as TAggregate : null;
 		}
 
-		private MultiBucketAggregate<TBucket> GetBucket<TBucket>(string key)
+		private MultiBucketAggregate<TBucket> GetMultiBucketAggregate<TBucket>(string key)
 			where TBucket : IBucket
 		{
 			var bucket = this.TryGet<BucketAggregate>(key);
 			if (bucket == null) return null;
 			return new MultiBucketAggregate<TBucket>
 			{
 				Buckets = bucket.Items.OfType<TBucket>().ToList(),
-				Meta = bucket.Meta
+				Meta = bucket.Meta,
 			};
+		}
+		private MultiBucketAggregate<KeyedBucket<TKey>> GetMultiKeyedBucketAggregate<TKey>(string key)
+		{
+			var bucket = this.TryGet<BucketAggregate>(key);
+			if (bucket == null) return null;
+			return new MultiBucketAggregate<KeyedBucket<TKey>>
+			{
+				Buckets = GetKeyedBuckets<TKey>(bucket.Items).ToList(),
+				Meta = bucket.Meta,
+			};
+		}
+
+
+		private IEnumerable<KeyedBucket<TKey>> GetKeyedBuckets<TKey>(IEnumerable<IBucket> items)
+		{
+			var buckets = items.Cast<KeyedBucket<object>>();
+
+			foreach (var bucket in buckets)
+			{
+				yield return new KeyedBucket<TKey>
+				{
+					Key = (TKey)Convert.ChangeType(bucket.Key, typeof(TKey)),
+					KeyAsString = bucket.KeyAsString,
+					Aggregations = bucket.Aggregations,
+					DocCount = bucket.DocCount
+				};
+			}
 		}
 	}
 }

src/Nest/Aggregations/Bucket/DateHistogram/DateHistogramBucket.cs

@@ -6,7 +6,7 @@
 
 namespace Nest
 {
-	public class DateHistogramBucket : HistogramBucket
+	public class DateHistogramBucket : KeyedBucket<double>
 	{
 		// Get a DateTime form of the returned key
 		public DateTime Date => DateTime.SpecifyKind(new DateTime(1970, 1, 1).AddMilliseconds(0 + this.Key), DateTimeKind.Utc);

src/Nest/Aggregations/Bucket/Histogram/HistogramBucket.cs

@@ -5,12 +5,12 @@
 
 namespace Nest
 {
-	public class KeyedBucket : BucketBase
+	public class KeyedBucket<TKey> : BucketBase
 	{
 		public KeyedBucket() { }
 		public KeyedBucket(IDictionary<string, IAggregate> aggregations) : base(aggregations) { }
 
-		public string Key { get; set; }
+		public TKey Key { get; set; }
 		public string KeyAsString { get; set; }
 		public long? DocCount { get; set; }
 	}

src/Nest/Aggregations/Bucket/KeyedBucket.cs

@@ -5,7 +5,7 @@
 
 namespace Nest
 {
-    public class TermsAggregate : MultiBucketAggregate<KeyedBucket>
+    public class TermsAggregate<TKey> : MultiBucketAggregate<KeyedBucket<TKey>>
     {
 		public long? DocCountErrorUpperBound { get; set; }
 		public long? SumOtherDocCount { get; set; }

src/Nest/Aggregations/Bucket/Terms/TermsAggregate.cs

@@ -82,7 +82,6 @@
     <Compile Include="Aggregations\Bucket\Global\GlobalAggregation.cs" />
     <Compile Include="Aggregations\Bucket\Histogram\ExtendedBounds.cs" />
     <Compile Include="Aggregations\Bucket\Histogram\HistogramAggregation.cs" />
-    <Compile Include="Aggregations\Bucket\Histogram\HistogramBucket.cs" />
     <Compile Include="Aggregations\Bucket\Histogram\HistogramOrder.cs" />
     <Compile Include="Aggregations\Bucket\IpRange\IpRange.cs" />
     <Compile Include="Aggregations\Bucket\IpRange\IpRangeAggregation.cs" />

src/Nest/Nest.csproj

@@ -128,6 +128,8 @@ protected override void ExpectResponse(ISearchResponse<Project> response)
 			dateHistogram.Should().NotBeNull();
 			dateHistogram.Buckets.Should().NotBeNull();
 			dateHistogram.Buckets.Count.Should().BeGreaterThan(10);
+			dateHistogram.Buckets.Should().NotBeNull();
+			dateHistogram.Buckets.Count.Should().BeGreaterThan(0);
 			foreach (var item in dateHistogram.Buckets)
 			{
 				item.Date.Should().NotBe(default(DateTime));

src/Tests/Aggregations/Bucket/DateHistogram/DateHistogramAggregationUsageTests.cs

@@ -59,6 +59,8 @@ protected override void ExpectResponse(ISearchResponse<Project> response)
 			response.ShouldBeValid();
 			var commits = response.Aggs.Histogram("commits");
 			commits.Should().NotBeNull();
+			commits.Buckets.Should().NotBeNull();
+			commits.Buckets.Count.Should().BeGreaterThan(0);
 			foreach (var item in commits.Buckets)
 				item.DocCount.Should().BeGreaterThan(0);
 		}

src/Tests/Aggregations/Bucket/Histogram/HistogramAggregationUsageTests.cs

@@ -94,6 +94,8 @@ protected override void ExpectResponse(ISearchResponse<Project> response)
 			states.Should().NotBeNull();
 			states.DocCountErrorUpperBound.Should().HaveValue();
 			states.SumOtherDocCount.Should().HaveValue();
+			states.Buckets.Should().NotBeNull();
+			states.Buckets.Count.Should().BeGreaterThan(0);
 			foreach (var item in states.Buckets)
 			{
 				item.Key.Should().NotBeNullOrEmpty();
@@ -103,4 +105,56 @@ protected override void ExpectResponse(ISearchResponse<Project> response)
 			states.Meta["foo"].Should().Be("bar");
 		}
 	}
+
+	public class NumericTermsAggregationUsageTests : AggregationUsageTestBase
+	{
+		public NumericTermsAggregationUsageTests(ReadOnlyCluster i, EndpointUsage usage) : base(i, usage) { }
+
+		protected override object ExpectJson => new
+		{
+			aggs = new
+			{
+				commits = new
+				{
+				
+					terms = new
+					{
+						field = "numberOfCommits"
+					}
+				}
+			}
+		};
+
+		protected override Func<SearchDescriptor<Project>, ISearchRequest> Fluent => s => s
+			.Aggregations(a => a
+				.Terms("commits", st => st
+					.Field(p => p.NumberOfCommits)
+				)
+			);
+
+		protected override SearchRequest<Project> Initializer =>
+			new SearchRequest<Project>
+			{
+				Aggregations = new TermsAggregation("commits")
+				{
+					Field = Field<Project>(p => p.NumberOfCommits),
+				}
+			};
+
+		protected override void ExpectResponse(ISearchResponse<Project> response)
+		{
+			response.IsValid.Should().BeTrue();
+			var commits = response.Aggs.Terms<int>("commits");
+			commits.Should().NotBeNull();
+			commits.DocCountErrorUpperBound.Should().HaveValue();
+			commits.SumOtherDocCount.Should().HaveValue();
+			commits.Buckets.Should().NotBeNull();
+			commits.Buckets.Count.Should().BeGreaterThan(0);
+			foreach (var item in commits.Buckets)
+			{
+				item.Key.Should().BeGreaterThan(0);
+				item.DocCount.Should().BeGreaterOrEqualTo(1);
+			}
+		}
+	}
 }