public static IEnumerable <K> GetGroupBy <T, K>(this AggregationsHelper aggs, Expression <Func <T, Object> > fieldGetter, Func <KeyedBucket, K> objectTransformer) { var aggName = fieldGetter.GetAggName(AggType.GroupBy); var itemsTerms = aggs.Terms(aggName); return(itemsTerms.Buckets.Select(objectTransformer)); }
public static IList <HistogramItem> GetDateHistogram <T>(this AggregationsHelper aggs, Expression <Func <T, Object> > fieldGetter) { var histogramItem = aggs.DateHistogram(GetName(fieldGetter)); return(histogramItem.Items); }
public static IDictionary <String, K> GetDictionary <T, K>(this AggregationsHelper aggs, Expression <Func <T, Object> > fieldGetter, Func <KeyItem, K> objectTransformer) { var aggName = fieldGetter.GetAggName(AggType.GroupBy); var itemsTerms = aggs.Terms(aggName); return(itemsTerms.Items.ToDictionary(x => x.Key, objectTransformer)); }
public static int?GetCount <T>(this AggregationsHelper aggs, Expression <Func <T, object> > fieldGetter, Expression <Func <T, object> > filterRule = null) { var aggName = fieldGetter.GetAggName(AggType.Count); if (filterRule == null) { var itemsTerms = aggs.ValueCount(aggName); if (!itemsTerms.Value.HasValue) { return(null); } return((int)itemsTerms.Value); } else { var condAggName = filterRule.GenerateFilterName(); var filterAgg = aggs.Filter(condAggName); var sumAgg = filterAgg.Sum(aggName); if (!sumAgg.Value.HasValue) { return(null); } return((int)sumAgg.Value); } }
public static K GetMax <T, K>(this AggregationsHelper aggs, Expression <Func <T, K> > fieldGetter) { var aggName = fieldGetter.GetAggName(AggType.Max); var maxAgg = aggs.Max(aggName); return(ValueAsUndType <K>(maxAgg)); }
public static IList <PercentileItem> GetPercentile <T>(this AggregationsHelper aggs, Expression <Func <T, object> > fieldGetter) { var aggName = fieldGetter.GetAggName(AggType.Percentile); var itemsTerms = aggs.Percentiles(aggName); return(itemsTerms.Items); }
public static IEnumerable <KeyItem> GetGroupBy <T>(this AggregationsHelper aggs, Expression <Func <T, Object> > fieldGetter) { var aggName = fieldGetter.GetAggName(AggType.GroupBy); var itemsTerms = aggs.Terms(aggName); return(itemsTerms.Items); }
public static K GetAverage <T, K>(this AggregationsHelper aggs, Expression <Func <T, K> > fieldGetter) { var aggName = fieldGetter.GetAggName(AggType.Average); var avgAgg = aggs.Average(aggName); return(ValueAsUndType <K>(avgAgg)); }
public static IReadOnlyCollection <DateHistogramBucket> GetDateHistogram <T>(this AggregationsHelper aggs, Expression <Func <T, Object> > fieldGetter) { var histogramItem = aggs.DateHistogram(GetName(fieldGetter)); return(histogramItem.Buckets); }
/// <summary> /// Retrieves the terms aggregation just by it's name /// </summary> public static IReadOnlyCollection <KeyedBucket <string> > GetGroupBy(this AggregationsHelper aggs, string aggName) { aggs.CheckForAggregationInResult(aggName); var itemsTerms = aggs.Terms(aggName); return(itemsTerms.Buckets); }
public static IEnumerable <T> GetSortedTopHits <T>(this AggregationsHelper aggs, Expression <Func <T, object> > sorter, SortType sortType) where T : class { var aggName = sortType + sorter.GetAggName(AggType.TopHits); var topHits = aggs.TopHits(aggName); return(topHits.Hits <T>().Select(x => x.Source)); }
public void TermsAggregation_RangeAggregation_FromHelper() { var agg = AggregationsHelper.RangeAggregation <Event, double?>(x => x.Duration, new RangeAggrValue <double?> { From = 2 * 60, Key = "Above120" }); agg.Aggregations = new Dictionary <string, IAggregation>(); agg.CardinalityAggregation <Event>(ci => ci.AssetGuid).TopHitsAggregation(ParameterHelper.Sort( new KeyValuePair <Expression <Func <Event, object> >, AggsOrderDirection>(ic => ic.Start, AggsOrderDirection.Desc)), ParameterHelper.Excludes <Event>(ic => ic.StSrid)); var termsAgg = AggregationsHelper.TermsAggregation <Event>(x => x.AssetGuid, 1000, null, agg, AggregationsHelper.BucketSelector("count", "nested._bucket_count", "params.count > 0")); var q2 = new Query <Event>().Match("EarthFault", e => e.Type) .DateHistogramAggregation(x => x.Start, "week", 1, termsAgg) .SetSize(0); var nested = q2.Aggregations.FirstOrDefault().Value.Aggregations.FirstOrDefault().Value.Aggregations.FirstOrDefault().Key; var n = q2.Aggregations.FirstOrDefault().Value.Aggregations.FirstOrDefault().Key; Assert.AreEqual("nested", nested); Assert.AreEqual("nested", n); }
public void Aggregations_Nested_Terms_Range() { var q1 = new Query <IndexedClass>().NestedAggregation( ic => ic.Children, AggregationsHelper.TermsAggregation <IndexedClass>(x => x.Children.PropertyName(p => p.AString), 10, new AggsOrder(AggsOrderBy.Key, AggsOrderDirection.Desc), AggregationsHelper.SumAggregation <IndexedClass>(sum => sum.SomeNumber)), AggregationsHelper.RangeAggregation <IndexedClass, int?>( x => x.Children.PropertyName(p => p.SomeNumber), new RangeAggrValue <int?> { Key = "SomeKey", To = 24 }), AggregationsHelper.RangeAggregation <IndexedClass, int?>( x => x.Children.PropertyName(p => p.SomeNumber), new RangeAggrValue <int?> { Key = "SomeKey1", To = 12, }, new RangeAggrValue <int?> { Key = "SomeKey2", From = 31, }) ); var json = q1.ToJson(); Assert.AreEqual( "{\"query\":{\"bool\":{\"should\":[{\"type\":{\"value\":\"h73.Elastic.Search.Tests.IndexedClass\"}},{\"type\":{\"value\":\"h73.Elastic.Search.Tests.InheritedGenericIndexedClass`1\"}},{\"type\":{\"value\":\"h73.Elastic.Search.Tests.InheritedIndexedClass\"}}],\"minimum_should_match\":1}},\"aggs\":{\"nested_Children_0\":{\"nested\":{\"path\":\"Children\"},\"aggs\":{\"nested\":{\"terms\":{\"field\":\"Children.AString\",\"size\":10,\"order\":{\"_key\":\"desc\"}},\"aggs\":{\"Sum\":{\"sum\":{\"field\":\"SomeNumber\"}},\"nested\":{\"range\":{\"ranges\":[{\"key\":\"SomeKey\",\"to\":24}],\"field\":\"Children.SomeNumber\"},\"aggs\":{\"nested\":{\"range\":{\"ranges\":[{\"key\":\"SomeKey1\",\"to\":12},{\"key\":\"SomeKey2\",\"from\":31}],\"field\":\"Children.SomeNumber\"}}}}}}}}}}", json); }
public static StatsMetric GetStats <T>(this AggregationsHelper aggs, Expression <Func <T, object> > fieldGetter) { var aggName = fieldGetter.GetAggName(AggType.Stats); var itemsTerms = aggs.Stats(aggName); return(itemsTerms); }
protected virtual IEnumerable <BaseFacet> GlobalFacets(IReadOnlyDictionary <string, IAggregate> facets, string facetName) { var aggregations = new AggregationsHelper(facets); var globalAggregations = new AggregationsHelper(aggregations.Global(facetName).Aggregations); var globalFilter = globalAggregations.Filter(SearchConstants.SearchFacetNames.GlobalFilter); var items = globalFilter.Terms(facetName).Buckets.Select(bucket => new BaseFacet { Name = bucket.Key, Count = bucket.DocCount ?? default });
private static IEnumerable <AggregationResult> GetAggregationResultsFrom(AggregationsHelper aggregations) { return (aggregations.Terms(FrameworkAggregationName) .Items.Select(bucket => new AggregationResult { Code = bucket.Key, Count = bucket.DocCount })); }
public void AddCardinalityAggregation_FromHelper() { var term = AggregationsHelper.TermsAggregation <IndexedClass>(ic => ic.AString); Assert.IsNull(term.Aggregations); term.AddCardinalityAggregation <IndexedClass>(ic => ic.AString); Assert.IsNotNull(term.Aggregations); }
public void BucketSort_From_Size() { var q = new Query <EarthFaultEvent>() .TermsAggregation(x => x.Type, null, AggregationsHelper.BucketSortAggregation("bucket_sort", null, 1, 23)); var qJson = q.ToJson(); Assert.AreEqual("{\"query\":{\"bool\":{\"should\":[{\"type\":{\"value\":\"h73.Elastic.Search.Tests.Support.EarthFaultEvent\"}}]," + "\"minimum_should_match\":1}},\"aggs\":{\"terms_Type\":{\"terms\":{\"field\":\"Type\"},\"aggs\":{\"BucketSort\":{\"bucket_sort\":{\"size\":1,\"from\":23}}}}}}", qJson); }
public static IList <PercentileItem> GetPercentile <T>(this AggregationsHelper aggs, Expression <Func <T, object> > fieldGetter, Expression <Func <T, object> > filterRule = null) { var aggWithResult = GetAggregationContainingResult(aggs, filterRule); var aggName = fieldGetter.GetAggName(AggType.Percentile); aggWithResult.CheckForAggregationInResult(aggName); var itemsTerms = aggWithResult.Percentiles(aggName); return(itemsTerms.Items); }
public static int GetCardinality <T>(this AggregationsHelper aggs, Expression <Func <T, object> > fieldGetter, Expression <Func <T, object> > filterRule = null) { var aggWithResult = GetAggregationContainingResult(aggs, filterRule); var aggName = fieldGetter.GetAggName(AggType.Cardinality); aggWithResult.CheckForAggregationInResult(aggName); var itemsTerms = aggWithResult.Cardinality(aggName); return((int)itemsTerms.Value.Value); }
public static TK GetMin <T, TK>(this AggregationsHelper aggs, Expression <Func <T, TK> > fieldGetter, Expression <Func <T, object> > filterRule = null) { var aggWithResult = GetAggregationContainingResult(aggs, filterRule); var aggName = fieldGetter.GetAggName(AggType.Min); aggWithResult.CheckForAggregationInResult(aggName); var minAgg = aggWithResult.Min(aggName); return(ValueAsUndType <TK>(minAgg)); }
public static TK GetFirstBy <T, TK>(this AggregationsHelper aggs, Expression <Func <T, TK> > fieldGetter, Expression <Func <T, object> > filterRule = null) { var aggWithResult = GetAggregationContainingResult(aggs, filterRule); var aggName = fieldGetter.GetAggName(AggType.First); aggWithResult.CheckForAggregationInResult(aggName); var termsAgg = aggWithResult.Terms(aggName); return(Filters.StringToAnything <TK>(termsAgg.Buckets.First().Key)); }
public static StatsAggregate GetStats <T>(this AggregationsHelper aggs, Expression <Func <T, object> > fieldGetter, Expression <Func <T, object> > filterRule = null) { var aggWithResult = GetAggregationContainingResult(aggs, filterRule); var aggName = fieldGetter.GetAggName(AggType.Stats); aggWithResult.CheckForAggregationInResult(aggName); var itemsTerms = aggWithResult.Stats(aggName); return(itemsTerms); }
public static IDictionary <V, KeyedBucket> GetDictionary <T, V>(this AggregationsHelper aggs, Expression <Func <T, Object> > fieldGetter) where V : struct, IConvertible { var aggName = fieldGetter.GetAggName(AggType.GroupBy); var itemsTerms = aggs.Terms(aggName); if ((typeof(V).IsEnum)) { return(itemsTerms.Buckets.ToDictionary(x => Filters.Parse <V>(x.Key))); } return(itemsTerms.Buckets.ToDictionary(x => (V)Convert.ChangeType(x.Key, typeof(V)))); }
public void Aggregations_Sum() { var q1 = new Query <IndexedClass>().TermsAggregation(x => x.AString, 5, AggregationsHelper.SumAggregation <IndexedClass>(sum => sum.SomeNumber)); var json = q1.ToJson(); const string r1 = "{\"query\":{\"bool\":{\"should\":[{\"type\":{\"value\":\"h73.Elastic.Search.Tests.IndexedClass\"}}," + "{\"type\":{\"value\":\"h73.Elastic.Search.Tests.InheritedGenericIndexedClass`1\"}}," + "{\"type\":{\"value\":\"h73.Elastic.Search.Tests.InheritedIndexedClass\"}}],\"minimum_should_match\":1}}," + "\"aggs\":{\"terms_AString\":{\"terms\":{\"field\":\"AString\",\"size\":5},\"aggs\":{\"Sum\":{\"sum\":{\"field\":\"SomeNumber\"}}}}}}"; Assert.AreEqual(r1, json); }
public void BucketSelector_Multiple() { var q = new Query <EarthFaultEvent>() .TermsAggregation(x => x.Type, null, AggregationsHelper.BucketSelector("max", "Max", $"params.max < 99"), AggregationsHelper.BucketSelector("max", "Max", $"params.max > 0")); var qJson = q.ToJson(); var matches = Regex.Matches(qJson, "BucketSelector_").Count; Assert.AreEqual(2, matches); }
public void CardinalityAggregation_FromHelper() { var q = new Query <IndexedClass>(true).NestedAggregation(x => x.Children, AggregationsHelper.CardinalityAggregation <IndexedClass>(ic => ic.Children.PropertyName(c => c.SomeNumber))) .SetSize(0); var json = q.ToJson(); Assert.AreEqual( "{\"query\":{\"bool\":{}},\"aggs\":{\"nested_Children_0\":{\"nested\":{\"path\":\"Children\"}," + "\"aggs\":{\"nested\":{\"cardinality\":{\"field\":\"Children.SomeNumber\"}}}}},\"size\":0}", json); }
/// <summary> /// Checks if aggregation with given name is available on the result and throws if not /// </summary> public static void CheckForAggregationInResult(this AggregationsHelper aggs, string aggName) { if (aggs.Aggregations == null || aggs.Aggregations.Count == 0) { throw new InvalidOperationException("No aggregations available on the result"); } if (!aggs.Aggregations.ContainsKey(aggName)) { var availableAggregations = aggs.Aggregations.Select(x => x.Key).Aggregate((agg, x) => agg + "m" + x); throw new InvalidOperationException($"Aggregation {aggName} not in the result. Available aggregations: {availableAggregations}"); } }
public static AggregationsHelper GetAggregationContainingResult <T>(this AggregationsHelper aggs, Expression <Func <T, object> > filterRule = null) { if (filterRule == null) { return(aggs); } var filterName = filterRule.GenerateFilterName(); aggs.CheckForAggregationInResult(filterName); return(aggs.Filter(filterName)); }
public static int?GetCount <T>(this AggregationsHelper aggs, Expression <Func <T, object> > fieldGetter, Expression <Func <T, object> > filterRule = null) { var aggWithResult = GetAggregationContainingResult(aggs, filterRule); var aggName = fieldGetter.GetAggName(AggType.Count); aggWithResult.CheckForAggregationInResult(aggName); var itemsTerms = aggWithResult.ValueCount(aggName); if (!itemsTerms.Value.HasValue) { return(null); } return((int)itemsTerms.Value); }
private double[] GetNumbers(AggregationsHelper aggregations, IEnumerable<FieldAggregation> fields) { var results = new List<double>(); foreach (var field in fields) { switch (field.Type) { case FieldAggregationType.Average: results.Add(aggregations.Average(field.Key)?.Value.GetValueOrDefault() ?? 0); break; case FieldAggregationType.Distinct: results.Add(aggregations.Cardinality(field.Key)?.Value.GetValueOrDefault() ?? 0); break; case FieldAggregationType.Sum: results.Add(aggregations.Sum(field.Key)?.Value.GetValueOrDefault() ?? 0); break; case FieldAggregationType.Min: results.Add(aggregations.Min(field.Key)?.Value.GetValueOrDefault() ?? 0); break; case FieldAggregationType.Max: results.Add(aggregations.Max(field.Key)?.Value.GetValueOrDefault() ?? 0); break; case FieldAggregationType.Last: // TODO: Populate with the last value. break; case FieldAggregationType.Term: var termResult = aggregations.Terms(field.Key); results.Add(termResult?.Items.Count > 0 ? termResult.Items[0].DocCount : 0); break; default: throw new InvalidOperationException($"Unknown FieldAggregation type: {field.Type}"); } } return results.ToArray(); }
private IAggregation GetBucketAggregation(JsonReader reader, JsonSerializer serializer) { var bucket = new Bucket(); var property = reader.Value as string; if (property == "doc_count_error_upper_bound") { reader.Read(); bucket.DocCountErrorUpperBound = reader.Value as long?; reader.Read(); } property = reader.Value as string; if (property == "sum_other_doc_count") { reader.Read(); bucket.SumOtherDocCount = reader.Value as long?; reader.Read(); } var aggregations = new List<IAggregation>(); reader.Read(); if (reader.TokenType == JsonToken.StartObject) { reader.Read(); var temp = new Dictionary<string, IAggregation>(); do { var name = reader.Value.ToString(); reader.Read(); var innerAgg = this.ReadAggregation(reader, serializer); temp.Add(name, innerAgg); reader.Read(); } while (reader.TokenType != JsonToken.EndObject); var agg = new AggregationsHelper(temp); reader.Read(); return new FiltersBucket(agg); } if (reader.TokenType != JsonToken.StartArray) return null; reader.Read(); //move from start array to start object if (reader.TokenType == JsonToken.EndArray) { reader.Read(); bucket.Items = Enumerable.Empty<IAggregation>(); return bucket; } do { var agg = this.ReadAggregation(reader, serializer); aggregations.Add(agg); reader.Read(); } while (reader.TokenType != JsonToken.EndArray); bucket.Items = aggregations; reader.Read(); return bucket; }
public FiltersBucket(AggregationsHelper helper) { Aggregations = helper; }