File: search_aggs_percentiles.go

package info (click to toggle)
golang-gopkg-olivere-elastic.v2 2.0.12-2
  • links: PTS, VCS
  • area: main
  • in suites: bookworm, bullseye, buster, sid, trixie
  • size: 1,964 kB
  • sloc: makefile: 17
file content (140 lines) | stat: -rw-r--r-- 3,490 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
// Copyright 2012-2015 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

// PercentilesAggregation
// See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-percentile-aggregation.html
type PercentilesAggregation struct {
	field           string
	script          string
	scriptFile      string
	lang            string
	format          string
	params          map[string]interface{}
	subAggregations map[string]Aggregation
	percentiles     []float64
	compression     *float64
	estimator       string
}

func NewPercentilesAggregation() PercentilesAggregation {
	a := PercentilesAggregation{
		params:          make(map[string]interface{}),
		subAggregations: make(map[string]Aggregation),
		percentiles:     make([]float64, 0),
	}
	return a
}

func (a PercentilesAggregation) Field(field string) PercentilesAggregation {
	a.field = field
	return a
}

func (a PercentilesAggregation) Script(script string) PercentilesAggregation {
	a.script = script
	return a
}

func (a PercentilesAggregation) ScriptFile(scriptFile string) PercentilesAggregation {
	a.scriptFile = scriptFile
	return a
}

func (a PercentilesAggregation) Lang(lang string) PercentilesAggregation {
	a.lang = lang
	return a
}

func (a PercentilesAggregation) Format(format string) PercentilesAggregation {
	a.format = format
	return a
}

func (a PercentilesAggregation) Param(name string, value interface{}) PercentilesAggregation {
	a.params[name] = value
	return a
}

func (a PercentilesAggregation) SubAggregation(name string, subAggregation Aggregation) PercentilesAggregation {
	a.subAggregations[name] = subAggregation
	return a
}

func (a PercentilesAggregation) Percentiles(percentiles ...float64) PercentilesAggregation {
	a.percentiles = make([]float64, 0)
	a.percentiles = append(a.percentiles, percentiles...)
	return a
}

func (a PercentilesAggregation) Compression(compression float64) PercentilesAggregation {
	a.compression = &compression
	return a
}

func (a PercentilesAggregation) Estimator(estimator string) PercentilesAggregation {
	a.estimator = estimator
	return a
}

func (a PercentilesAggregation) Source() interface{} {
	// Example:
	//	{
	//    "aggs" : {
	//      "load_time_outlier" : {
	//           "percentiles" : {
	//               "field" : "load_time"
	//           }
	//       }
	//    }
	//	}
	// This method returns only the
	//   { "percentiles" : { "field" : "load_time" } }
	// part.

	source := make(map[string]interface{})
	opts := make(map[string]interface{})
	source["percentiles"] = opts

	// ValuesSourceAggregationBuilder
	if a.field != "" {
		opts["field"] = a.field
	}
	if a.script != "" {
		opts["script"] = a.script
	}
	if a.scriptFile != "" {
		opts["script_file"] = a.scriptFile
	}
	if a.lang != "" {
		opts["lang"] = a.lang
	}
	if a.format != "" {
		opts["format"] = a.format
	}
	if len(a.params) > 0 {
		opts["params"] = a.params
	}
	if len(a.percentiles) > 0 {
		opts["percents"] = a.percentiles
	}
	if a.compression != nil {
		opts["compression"] = *a.compression
	}
	if a.estimator != "" {
		opts["estimator"] = a.estimator
	}

	// AggregationBuilder (SubAggregations)
	if len(a.subAggregations) > 0 {
		aggsMap := make(map[string]interface{})
		source["aggregations"] = aggsMap
		for name, aggregate := range a.subAggregations {
			aggsMap[name] = aggregate.Source()
		}
	}

	return source
}