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;
}
