Add auto-interval Date Histogram

See
https://www.elastic.co/guide/en/elasticsearch/reference/7.3/search-aggregations-bucket-autodatehistogram-aggregation.html.

Close #911
Close #1150

Author: olivere

README.md

@@ -197,6 +197,7 @@ Here are a few tips on how to get used to Elastic:
 - Bucket Aggregations
   - [x] Adjacency Matrix
   - [x] Children
+  - [x] Auto-interval Date Histogram
   - [x] Date Histogram
   - [x] Date Range
   - [x] Diversified Sampler

ingest_get_pipeline_test.go

@@ -6,8 +6,6 @@ package elastic
 
 import (
 	"context"
-	"log"
-	"os"
 	"testing"
 )
 
@@ -48,7 +46,7 @@ func TestIngestGetPipelineURL(t *testing.T) {
 }
 
 func TestIngestLifecycle(t *testing.T) {
-	client := setupTestClientAndCreateIndexAndAddDocs(t, SetTraceLog(log.New(os.Stdout, "", 0)))
+	client := setupTestClientAndCreateIndexAndAddDocs(t) //, SetTraceLog(log.New(os.Stdout, "", 0)))
 
 	// With the new ES Docker images, XPack is already installed and returns a pipeline. So we cannot test for "no pipelines". Skipping for now.
 	/*

search_aggs.go

@@ -473,6 +473,21 @@ func (a Aggregations) Histogram(name string) (*AggregationBucketHistogramItems,
 	return nil, false
 }
 
+// AutoDateHistogram returns auto date histogram aggregation results.
+// See: https://www.elastic.co/guide/en/elasticsearch/reference/7.0/search-aggregations-bucket-datehistogram-aggregation.html
+func (a Aggregations) AutoDateHistogram(name string) (*AggregationBucketHistogramItems, bool) {
+	if raw, found := a[name]; found {
+		agg := new(AggregationBucketHistogramItems)
+		if raw == nil {
+			return agg, true
+		}
+		if err := json.Unmarshal(raw, agg); err == nil {
+			return agg, true
+		}
+	}
+	return nil, false
+}
+
 // DateHistogram returns date histogram aggregation results.
 // See: https://www.elastic.co/guide/en/elasticsearch/reference/7.0/search-aggregations-bucket-datehistogram-aggregation.html
 func (a Aggregations) DateHistogram(name string) (*AggregationBucketHistogramItems, bool) {
@@ -1391,8 +1406,9 @@ func (a *AggregationBucketAdjacencyMatrix) UnmarshalJSON(data []byte) error {
 type AggregationBucketHistogramItems struct {
 	Aggregations
 
-	Buckets []*AggregationBucketHistogramItem //`json:"buckets"`
-	Meta    map[string]interface{}            // `json:"meta,omitempty"`
+	Buckets  []*AggregationBucketHistogramItem //`json:"buckets"`
+	Interval interface{}                       // `json:"interval"` // can be numeric or a string
+	Meta     map[string]interface{}            // `json:"meta,omitempty"`
 }
 
 // UnmarshalJSON decodes JSON data and initializes an AggregationBucketHistogramItems structure.
@@ -1404,6 +1420,9 @@ func (a *AggregationBucketHistogramItems) UnmarshalJSON(data []byte) error {
 	if v, ok := aggs["buckets"]; ok && v != nil {
 		json.Unmarshal(v, &a.Buckets)
 	}
+	if v, ok := aggs["interval"]; ok && v != nil {
+		json.Unmarshal(v, &a.Interval)
+	}
 	if v, ok := aggs["meta"]; ok && v != nil {
 		json.Unmarshal(v, &a.Meta)
 	}

search_aggs_bucket_auto_date_histogram.go

@@ -0,0 +1,165 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+// AutoDateHistogramAggregation is a multi-bucket aggregation similar to the
+// histogram except it can only be applied on date values, and the buckets num can bin pointed.
+// See: https://www.elastic.co/guide/en/elasticsearch/reference/7.3/search-aggregations-bucket-autodatehistogram-aggregation.html
+type AutoDateHistogramAggregation struct {
+	field           string
+	script          *Script
+	missing         interface{}
+	subAggregations map[string]Aggregation
+	meta            map[string]interface{}
+
+	buckets         int
+	minDocCount     *int64
+	timeZone        string
+	format          string
+	minimumInterval string
+}
+
+// NewAutoDateHistogramAggregation creates a new AutoDateHistogramAggregation.
+func NewAutoDateHistogramAggregation() *AutoDateHistogramAggregation {
+	return &AutoDateHistogramAggregation{
+		subAggregations: make(map[string]Aggregation),
+	}
+}
+
+// Field on which the aggregation is processed.
+func (a *AutoDateHistogramAggregation) Field(field string) *AutoDateHistogramAggregation {
+	a.field = field
+	return a
+}
+
+// Script on which th
+func (a *AutoDateHistogramAggregation) Script(script *Script) *AutoDateHistogramAggregation {
+	a.script = script
+	return a
+}
+
+// Missing configures the value to use when documents miss a value.
+func (a *AutoDateHistogramAggregation) Missing(missing interface{}) *AutoDateHistogramAggregation {
+	a.missing = missing
+	return a
+}
+
+// SubAggregation sub aggregation
+func (a *AutoDateHistogramAggregation) SubAggregation(name string, subAggregation Aggregation) *AutoDateHistogramAggregation {
+	a.subAggregations[name] = subAggregation
+	return a
+}
+
+// Meta sets the meta data to be included in the aggregation response.
+func (a *AutoDateHistogramAggregation) Meta(metaData map[string]interface{}) *AutoDateHistogramAggregation {
+	a.meta = metaData
+	return a
+}
+
+// Buckets buckets num by which the aggregation gets processed.
+func (a *AutoDateHistogramAggregation) Buckets(buckets int) *AutoDateHistogramAggregation {
+	a.buckets = buckets
+	return a
+}
+
+// MinDocCount sets the minimum document count per bucket.
+// Buckets with less documents than this min value will not be returned.
+func (a *AutoDateHistogramAggregation) MinDocCount(minDocCount int64) *AutoDateHistogramAggregation {
+	a.minDocCount = &minDocCount
+	return a
+}
+
+// TimeZone sets the timezone in which to translate dates before computing buckets.
+func (a *AutoDateHistogramAggregation) TimeZone(timeZone string) *AutoDateHistogramAggregation {
+	a.timeZone = timeZone
+	return a
+}
+
+// Format sets the format to use for dates.
+func (a *AutoDateHistogramAggregation) Format(format string) *AutoDateHistogramAggregation {
+	a.format = format
+	return a
+}
+
+// MinimumInterval accepted units for minimum_interval are: year/month/day/hour/minute/second
+func (a *AutoDateHistogramAggregation) MinimumInterval(interval string) *AutoDateHistogramAggregation {
+	a.minimumInterval = interval
+	return a
+}
+
+// Source source for AutoDateHistogramAggregation
+func (a *AutoDateHistogramAggregation) Source() (interface{}, error) {
+	// Example:
+	// {
+	//     "aggs" : {
+	//         "articles_over_time" : {
+	//             "auto_date_histogram" : {
+	//                 "field" : "date",
+	//                 "buckets" : 10
+	//             }
+	//         }
+	//     }
+	// }
+	//
+	// This method returns only the { "auto_date_histogram" : { ... } } part.
+
+	source := make(map[string]interface{})
+	opts := make(map[string]interface{})
+	source["auto_date_histogram"] = opts
+
+	// ValuesSourceAggregationBuilder
+	if a.field != "" {
+		opts["field"] = a.field
+	}
+	if a.script != nil {
+		src, err := a.script.Source()
+		if err != nil {
+			return nil, err
+		}
+		opts["script"] = src
+	}
+	if a.missing != nil {
+		opts["missing"] = a.missing
+	}
+
+	if a.buckets > 0 {
+		opts["buckets"] = a.buckets
+	} else {
+		opts["buckets"] = 10
+	}
+
+	if a.minDocCount != nil {
+		opts["min_doc_count"] = *a.minDocCount
+	}
+	if a.timeZone != "" {
+		opts["time_zone"] = a.timeZone
+	}
+	if a.format != "" {
+		opts["format"] = a.format
+	}
+	if a.minimumInterval != "" {
+		opts["minimum_interval"] = a.minimumInterval
+	}
+
+	// AggregationBuilder (SubAggregations)
+	if len(a.subAggregations) > 0 {
+		aggsMap := make(map[string]interface{})
+		source["aggregations"] = aggsMap
+		for name, aggregate := range a.subAggregations {
+			src, err := aggregate.Source()
+			if err != nil {
+				return nil, err
+			}
+			aggsMap[name] = src
+		}
+	}
+
+	// Add Meta data if available
+	if len(a.meta) > 0 {
+		source["meta"] = a.meta
+	}
+
+	return source, nil
+}

search_aggs_bucket_auto_date_histogram_test.go

@@ -0,0 +1,63 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func TestAutoDateHistogramAggregation(t *testing.T) {
+	agg := NewAutoDateHistogramAggregation().
+		Field("date").
+		Buckets(10)
+	src, err := agg.Source()
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, err := json.Marshal(src)
+	if err != nil {
+		t.Fatalf("marshaling to JSON failed: %v", err)
+	}
+	got := string(data)
+	expected := `{"auto_date_histogram":{"buckets":10,"field":"date"}}`
+	if got != expected {
+		t.Errorf("expected\n%s\n,got:\n%s", expected, got)
+	}
+}
+
+func TestAutoDateHistogramAggregationWithFormat(t *testing.T) {
+	agg := NewAutoDateHistogramAggregation().Field("date").Format("yyyy-MM-dd").Buckets(5)
+	src, err := agg.Source()
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, err := json.Marshal(src)
+	if err != nil {
+		t.Fatalf("marshaling to JSON failed: %v", err)
+	}
+	got := string(data)
+	expected := `{"auto_date_histogram":{"buckets":5,"field":"date","format":"yyyy-MM-dd"}}`
+	if got != expected {
+		t.Errorf("expected\n%s\n,got:\n%s", expected, got)
+	}
+}
+
+func TestAutoDateHistogramAggregationWithMissing(t *testing.T) {
+	agg := NewAutoDateHistogramAggregation().Field("date").Missing("1900")
+	src, err := agg.Source()
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, err := json.Marshal(src)
+	if err != nil {
+		t.Fatalf("marshaling to JSON failed: %v", err)
+	}
+	got := string(data)
+	expected := `{"auto_date_histogram":{"field":"date","missing":"1900"}}`
+	if got != expected {
+		t.Errorf("expected\n%s\n,got:\n%s", expected, got)
+	}
+}

search_aggs_test.go

@@ -15,8 +15,7 @@ import (
 
 // TestAggs is an integration test for most aggregation types.
 func TestAggs(t *testing.T) {
-	//client := setupTestClientAndCreateIndex(t, SetTraceLog(log.New(os.Stdout, "", log.LstdFlags)))
-	client := setupTestClientAndCreateIndex(t)
+	client := setupTestClientAndCreateIndex(t) //, SetTraceLog(log.New(os.Stdout, "", log.LstdFlags)))
 
 	tweet1 := tweet{
 		User:     "olivere",
@@ -102,6 +101,7 @@ func TestAggs(t *testing.T) {
 	dateRangeAgg := NewDateRangeAggregation().Field("created").Lt("2012-01-01").Between("2012-01-01", "2013-01-01").Gt("2013-01-01")
 	missingTagsAgg := NewMissingAggregation().Field("tags")
 	retweetsHistoAgg := NewHistogramAggregation().Field("retweets").Interval(100)
+	autoDateHistoAgg := NewAutoDateHistogramAggregation().Field("created").Buckets(2).Missing("1900-01-01").Format("yyyy-MM-dd")
 	dateHistoAgg := NewDateHistogramAggregation().Field("created").Interval("year")
 	dateHistoKeyedAgg := NewDateHistogramAggregation().Field("created").Interval("year").Keyed(true)
 	retweetsFilterAgg := NewFilterAggregation().Filter(
@@ -139,6 +139,7 @@ func TestAggs(t *testing.T) {
 	builder = builder.Aggregation("dateRange", dateRangeAgg)
 	builder = builder.Aggregation("missingTags", missingTagsAgg)
 	builder = builder.Aggregation("retweetsHisto", retweetsHistoAgg)
+	builder = builder.Aggregation("autoDateHisto", autoDateHistoAgg)
 	builder = builder.Aggregation("dateHisto", dateHistoAgg)
 	builder = builder.Aggregation("dateHistoKeyed", dateHistoKeyedAgg)
 	builder = builder.Aggregation("retweetsFilter", retweetsFilterAgg)
@@ -832,6 +833,21 @@ func TestAggs(t *testing.T) {
 		t.Errorf("expected %v; got: %+v", 100.0, histoRes.Buckets[1].Key)
 	}
 
+	// autoDateHisto
+	autoDateHistoRes, found := agg.DateHistogram("autoDateHisto")
+	if !found {
+		t.Errorf("expected %v; got: %v", true, found)
+	}
+	if autoDateHistoRes == nil {
+		t.Fatal("expected != nil; got: nil")
+	}
+	if len(autoDateHistoRes.Buckets) != 2 {
+		t.Fatalf("expected %d; got: %d", 2, len(autoDateHistoRes.Buckets))
+	}
+	if autoDateHistoRes.Interval == nil {
+		t.Fatalf("expected an interval; got: %v", autoDateHistoRes.Interval)
+	}
+
 	// dateHisto
 	dateHistoRes, found := agg.DateHistogram("dateHisto")
 	if !found {