Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
- API
  
  Reference documentation for the pkg.go.dev API
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

esquery

package module

Go to main page

Versions in this module

v0

v0.1.10

Jun 10, 2021

v0.1.9

Jun 10, 2021

v0.1.8

Jun 10, 2021

v0.1.7

Jun 10, 2021

Changes in this version

type SearchRequest

+ func (req *SearchRequest) Collapse(field string) *SearchRequest

v0.1.6

Jun 10, 2021

Changes in this version

+ const TypeMatch

+ const TypeMatchBoolPrefix

+ const TypeMatchPhrase

+ const TypeMatchPhrasePrefix

+ type Aggregation interface

+ Name func() string

+ type AvgAgg struct

+ func Avg(name, field string) *AvgAgg

+ func (agg *AvgAgg) Missing(val interface{}) *AvgAgg

+ type BaseAgg struct

+ func (agg *BaseAgg) Map() map[string]interface{}

+ func (agg *BaseAgg) Name() string

+ type BaseAggParams struct

+ Field string

+ Miss interface{}

+ type BoolQuery struct

+ func Bool() *BoolQuery

+ func (q *BoolQuery) Boost(val float32) *BoolQuery

+ func (q *BoolQuery) Filter(filter ...Mappable) *BoolQuery

+ func (q *BoolQuery) Map() map[string]interface{}

+ func (q *BoolQuery) MinimumShouldMatch(val int16) *BoolQuery

+ func (q *BoolQuery) Must(must ...Mappable) *BoolQuery

+ func (q *BoolQuery) MustNot(mustnot ...Mappable) *BoolQuery

+ func (q *BoolQuery) Should(should ...Mappable) *BoolQuery

+ type BoostingQuery struct

+ Neg Mappable

+ NegBoost float32

+ Pos Mappable

+ func Boosting() *BoostingQuery

+ func (q *BoostingQuery) Map() map[string]interface{}

+ func (q *BoostingQuery) Negative(p Mappable) *BoostingQuery

+ func (q *BoostingQuery) NegativeBoost(b float32) *BoostingQuery

+ func (q *BoostingQuery) Positive(p Mappable) *BoostingQuery

+ type CardinalityAgg struct

+ PrecisionThr uint16

+ func Cardinality(name, field string) *CardinalityAgg

+ func (agg *CardinalityAgg) Map() map[string]interface{}

+ func (agg *CardinalityAgg) Missing(val interface{}) *CardinalityAgg

+ func (agg *CardinalityAgg) PrecisionThreshold(val uint16) *CardinalityAgg

+ type CollapseQuery struct

+ func Collapse(field string) *CollapseQuery

+ func (c *CollapseQuery) Map() map[string]interface{}

+ type ConstantScoreQuery struct

+ func ConstantScore(filter Mappable) *ConstantScoreQuery

+ func (q *ConstantScoreQuery) Boost(b float32) *ConstantScoreQuery

+ func (q *ConstantScoreQuery) Map() map[string]interface{}

+ type CountRequest struct

+ func Count(q Mappable) *CountRequest

+ func (req *CountRequest) Map() map[string]interface{}

+ func (req *CountRequest) Run(api *elasticsearch.Client, o ...func(*esapi.CountRequest)) (res *esapi.Response, err error)

+ func (req *CountRequest) RunCount(count esapi.Count, o ...func(*esapi.CountRequest)) (res *esapi.Response, err error)

+ type CustomAggMap struct

+ func CustomAgg(name string, m map[string]interface{}) *CustomAggMap

+ func (agg *CustomAggMap) Map() map[string]interface{}

+ func (agg *CustomAggMap) Name() string

+ type CustomQueryMap map[string]interface

+ func (m *CustomQueryMap) Map() map[string]interface{}

+ func (m *CustomQueryMap) Run(api *elasticsearch.Client, o ...func(*esapi.SearchRequest)) (res *esapi.Response, err error)

+ func CustomQuery(m map[string]interface{}) *CustomQueryMap

+ type DeleteRequest struct

+ func Delete() *DeleteRequest

+ func (req *DeleteRequest) Index(index ...string) *DeleteRequest

+ func (req *DeleteRequest) Query(q Mappable) *DeleteRequest

+ func (req *DeleteRequest) Run(api *elasticsearch.Client, o ...func(*esapi.DeleteByQueryRequest)) (res *esapi.Response, err error)

+ func (req *DeleteRequest) RunDelete(del esapi.DeleteByQuery, o ...func(*esapi.DeleteByQueryRequest)) (res *esapi.Response, err error)

+ type DisMaxQuery struct

+ func DisMax(queries ...Mappable) *DisMaxQuery

+ func (q *DisMaxQuery) Map() map[string]interface{}

+ func (q *DisMaxQuery) TieBreaker(b float32) *DisMaxQuery

+ type ExistsQuery struct

+ Field string

+ func Exists(field string) *ExistsQuery

+ func (q *ExistsQuery) Map() map[string]interface{}

+ type FilterAggregation struct

+ func FilterAgg(name string, filter Mappable) *FilterAggregation

+ func (agg *FilterAggregation) Aggs(aggs ...Aggregation) *FilterAggregation

+ func (agg *FilterAggregation) Filter(filter Mappable) *FilterAggregation

+ func (agg *FilterAggregation) Map() map[string]interface{}

+ func (agg *FilterAggregation) Name() string

+ type FuzzyQuery struct

+ func Fuzzy(field, value string) *FuzzyQuery

+ func (q *FuzzyQuery) Fuzziness(fuzz string) *FuzzyQuery

+ func (q *FuzzyQuery) Map() map[string]interface{}

+ func (q *FuzzyQuery) MaxExpansions(m uint16) *FuzzyQuery

+ func (q *FuzzyQuery) PrefixLength(l uint16) *FuzzyQuery

+ func (q *FuzzyQuery) Rewrite(s string) *FuzzyQuery

+ func (q *FuzzyQuery) Transpositions(b bool) *FuzzyQuery

+ func (q *FuzzyQuery) Value(val string) *FuzzyQuery

+ type HighlightBoundaryScanner uint8

+ const BoundaryScannerChars

+ const BoundaryScannerDefault

+ const BoundaryScannerSentence

+ const BoundaryScannerWord

+ func (a HighlightBoundaryScanner) String() string

+ type HighlightEncoder uint8

+ const EncoderDefault

+ const EncoderHtml

+ func (a HighlightEncoder) String() string

+ type HighlightFragmenter uint8

+ const FragmenterSimple

+ const FragmenterSpan

+ func (a HighlightFragmenter) String() string

+ type HighlightOrder uint8

+ const OrderNone

+ const OrderScore

+ func (a HighlightOrder) String() string

+ type HighlightTagsSchema uint8

+ const TagsSchemaDefault

+ const TagsSchemaStyled

+ func (a HighlightTagsSchema) String() string

+ type HighlightType uint8

+ const HighlighterFvh

+ const HighlighterPlain

+ const HighlighterUnified

+ func (a HighlightType) String() string

+ type IDsQuery struct

+ IDs struct{ ... }

+ func IDs(vals ...string) *IDsQuery

+ func (q *IDsQuery) Map() map[string]interface{}

+ type Mappable interface

+ Map func() map[string]interface{}

+ type MatchAllQuery struct

+ func MatchAll() *MatchAllQuery

+ func MatchNone() *MatchAllQuery

+ func (q *MatchAllQuery) Boost(b float32) *MatchAllQuery

+ func (q *MatchAllQuery) Map() map[string]interface{}

+ type MatchOperator uint8

+ const OperatorAnd

+ const OperatorOr

+ func (a MatchOperator) String() string

+ type MatchQuery struct

+ func Match(fieldName string, simpleQuery ...interface{}) *MatchQuery

+ func MatchBoolPrefix(fieldName string, simpleQuery ...interface{}) *MatchQuery

+ func MatchPhrase(fieldName string, simpleQuery ...interface{}) *MatchQuery

+ func MatchPhrasePrefix(fieldName string, simpleQuery ...interface{}) *MatchQuery

+ func (q *MatchQuery) Analyzer(a string) *MatchQuery

+ func (q *MatchQuery) AutoGenerateSynonymsPhraseQuery(b bool) *MatchQuery

+ func (q *MatchQuery) Fuzziness(f string) *MatchQuery

+ func (q *MatchQuery) FuzzyRewrite(s string) *MatchQuery

+ func (q *MatchQuery) Lenient(b bool) *MatchQuery

+ func (q *MatchQuery) Map() map[string]interface{}

+ func (q *MatchQuery) MaxExpansions(e uint16) *MatchQuery

+ func (q *MatchQuery) MinimumShouldMatch(s string) *MatchQuery

+ func (q *MatchQuery) Operator(op MatchOperator) *MatchQuery

+ func (q *MatchQuery) PrefixLength(l uint16) *MatchQuery

+ func (q *MatchQuery) Query(data interface{}) *MatchQuery

+ func (q *MatchQuery) Slop(n uint16) *MatchQuery

+ func (q *MatchQuery) Transpositions(b bool) *MatchQuery

+ func (q *MatchQuery) ZeroTermsQuery(s ZeroTerms) *MatchQuery

+ type MaxAgg struct

+ func Max(name, field string) *MaxAgg

+ func (agg *MaxAgg) Missing(val interface{}) *MaxAgg

+ type MinAgg struct

+ func Min(name, field string) *MinAgg

+ func (agg *MinAgg) Missing(val interface{}) *MinAgg

+ type MultiMatchQuery struct

+ func MultiMatch(simpleQuery ...interface{}) *MultiMatchQuery

+ func (q *MultiMatchQuery) Analyzer(a string) *MultiMatchQuery

+ func (q *MultiMatchQuery) AutoGenerateSynonymsPhraseQuery(b bool) *MultiMatchQuery

+ func (q *MultiMatchQuery) Boost(l float32) *MultiMatchQuery

+ func (q *MultiMatchQuery) Fields(a ...string) *MultiMatchQuery

+ func (q *MultiMatchQuery) Fuzziness(f string) *MultiMatchQuery

+ func (q *MultiMatchQuery) FuzzyRewrite(s string) *MultiMatchQuery

+ func (q *MultiMatchQuery) Lenient(b bool) *MultiMatchQuery

+ func (q *MultiMatchQuery) Map() map[string]interface{}

+ func (q *MultiMatchQuery) MaxExpansions(e uint16) *MultiMatchQuery

+ func (q *MultiMatchQuery) MinimumShouldMatch(s string) *MultiMatchQuery

+ func (q *MultiMatchQuery) Operator(op MatchOperator) *MultiMatchQuery

+ func (q *MultiMatchQuery) PrefixLength(l uint16) *MultiMatchQuery

+ func (q *MultiMatchQuery) Query(data interface{}) *MultiMatchQuery

+ func (q *MultiMatchQuery) Slop(n uint16) *MultiMatchQuery

+ func (q *MultiMatchQuery) TieBreaker(l float32) *MultiMatchQuery

+ func (q *MultiMatchQuery) Transpositions(b bool) *MultiMatchQuery

+ func (q *MultiMatchQuery) Type(t MultiMatchType) *MultiMatchQuery

+ func (q *MultiMatchQuery) ZeroTermsQuery(s ZeroTerms) *MultiMatchQuery

+ type MultiMatchType uint8

+ const MatchTypeBestFields

+ const MatchTypeBoolPrefix

+ const MatchTypeCrossFields

+ const MatchTypeMostFields

+ const MatchTypePhrase

+ const MatchTypePhrasePrefix

+ func (a MultiMatchType) String() string

+ type NestedAggregation struct

+ func NestedAgg(name string, path string) *NestedAggregation

+ func (agg *NestedAggregation) Aggs(aggs ...Aggregation) *NestedAggregation

+ func (agg *NestedAggregation) Map() map[string]interface{}

+ func (agg *NestedAggregation) Name() string

+ func (agg *NestedAggregation) Path(p string) *NestedAggregation

+ type NestedQuery struct

+ func Nested(path string, query Mappable) *NestedQuery

+ func (n *NestedQuery) IgnoreUnmapped(val bool) *NestedQuery

+ func (n *NestedQuery) Map() map[string]interface{}

+ func (n *NestedQuery) ScoreMode(mode string) *NestedQuery

+ type Order string

+ const OrderAsc

+ const OrderDesc

+ type PercentilesAgg struct

+ HDR struct{ ... }

+ Key *bool

+ Prcnts []float32

+ TDigest struct{ ... }

+ func Percentiles(name, field string) *PercentilesAgg

+ func (agg *PercentilesAgg) Compression(val uint16) *PercentilesAgg

+ func (agg *PercentilesAgg) Keyed(b bool) *PercentilesAgg

+ func (agg *PercentilesAgg) Map() map[string]interface{}

+ func (agg *PercentilesAgg) Missing(val interface{}) *PercentilesAgg

+ func (agg *PercentilesAgg) NumHistogramDigits(val uint8) *PercentilesAgg

+ func (agg *PercentilesAgg) Percents(percents ...float32) *PercentilesAgg

+ type PrefixQuery struct

+ func Prefix(field, value string) *PrefixQuery

+ func (q *PrefixQuery) Map() map[string]interface{}

+ func (q *PrefixQuery) Rewrite(s string) *PrefixQuery

+ type QueryHighlight struct

+ func Highlight() *QueryHighlight

+ func (q *QueryHighlight) BoundaryChars(s string) *QueryHighlight

+ func (q *QueryHighlight) BoundaryMaxScan(i uint16) *QueryHighlight

+ func (q *QueryHighlight) BoundaryScanner(t HighlightBoundaryScanner) *QueryHighlight

+ func (q *QueryHighlight) BoundaryScannerLocale(l string) *QueryHighlight

+ func (q *QueryHighlight) Encoder(e HighlightEncoder) *QueryHighlight

+ func (q *QueryHighlight) Field(name string, h ...*QueryHighlight) *QueryHighlight

+ func (q *QueryHighlight) Fields(h map[string]*QueryHighlight) *QueryHighlight

+ func (q *QueryHighlight) ForceSource(b bool) *QueryHighlight

+ func (q *QueryHighlight) FragmentOffset(i uint16) *QueryHighlight

+ func (q *QueryHighlight) FragmentSize(i uint16) *QueryHighlight

+ func (q *QueryHighlight) Fragmenter(f HighlightFragmenter) *QueryHighlight

+ func (q *QueryHighlight) HighlightQuery(b Mappable) *QueryHighlight

+ func (q *QueryHighlight) Map() map[string]interface{}

+ func (q *QueryHighlight) MatchedFields(s ...string) *QueryHighlight

+ func (q *QueryHighlight) NoMatchSize(i uint16) *QueryHighlight

+ func (q *QueryHighlight) NumberOfFragments(i uint16) *QueryHighlight

+ func (q *QueryHighlight) Order(o HighlightOrder) *QueryHighlight

+ func (q *QueryHighlight) PhraseLimit(i uint16) *QueryHighlight

+ func (q *QueryHighlight) PostTags(s ...string) *QueryHighlight

+ func (q *QueryHighlight) PreTags(s ...string) *QueryHighlight

+ func (q *QueryHighlight) RequireFieldMatch(b bool) *QueryHighlight

+ func (q *QueryHighlight) TagsSchema(s HighlightTagsSchema) *QueryHighlight

+ func (q *QueryHighlight) Type(t HighlightType) *QueryHighlight

+ type RangeQuery struct

+ func Range(field string) *RangeQuery

+ func (a *RangeQuery) Boost(b float32) *RangeQuery

+ func (a *RangeQuery) Format(f string) *RangeQuery

+ func (a *RangeQuery) Gt(val interface{}) *RangeQuery

+ func (a *RangeQuery) Gte(val interface{}) *RangeQuery

+ func (a *RangeQuery) Lt(val interface{}) *RangeQuery

+ func (a *RangeQuery) Lte(val interface{}) *RangeQuery

+ func (a *RangeQuery) Map() map[string]interface{}

+ func (a *RangeQuery) Relation(r RangeRelation) *RangeQuery

+ func (a *RangeQuery) TimeZone(zone string) *RangeQuery

+ type RangeRelation uint8

+ const RangeContains

+ const RangeIntersects

+ const RangeWithin

+ func (a RangeRelation) String() string

+ type RegexpQuery struct

+ func Regexp(field, value string) *RegexpQuery

+ func Wildcard(field, value string) *RegexpQuery

+ func (q *RegexpQuery) Flags(f string) *RegexpQuery

+ func (q *RegexpQuery) Map() map[string]interface{}

+ func (q *RegexpQuery) MaxDeterminizedStates(m uint16) *RegexpQuery

+ func (q *RegexpQuery) Rewrite(r string) *RegexpQuery

+ func (q *RegexpQuery) Value(v string) *RegexpQuery

+ type SearchRequest struct

+ func Aggregate(aggs ...Aggregation) *SearchRequest

+ func Query(q Mappable) *SearchRequest

+ func Search() *SearchRequest

+ func (req *SearchRequest) Aggs(aggs ...Aggregation) *SearchRequest

+ func (req *SearchRequest) Explain(b bool) *SearchRequest

+ func (req *SearchRequest) From(offset uint64) *SearchRequest

+ func (req *SearchRequest) Highlight(highlight Mappable) *SearchRequest

+ func (req *SearchRequest) Map() map[string]interface{}

+ func (req *SearchRequest) MarshalJSON() ([]byte, error)

+ func (req *SearchRequest) PostFilter(filter Mappable) *SearchRequest

+ func (req *SearchRequest) Query(q Mappable) *SearchRequest

+ func (req *SearchRequest) Run(api *elasticsearch.Client, o ...func(*esapi.SearchRequest)) (res *esapi.Response, err error)

+ func (req *SearchRequest) RunSearch(search esapi.Search, o ...func(*esapi.SearchRequest)) (res *esapi.Response, err error)

+ func (req *SearchRequest) SearchAfter(s ...interface{}) *SearchRequest

+ func (req *SearchRequest) Size(size uint64) *SearchRequest

+ func (req *SearchRequest) Sort(name string, order Order) *SearchRequest

+ func (req *SearchRequest) SourceExcludes(keys ...string) *SearchRequest

+ func (req *SearchRequest) SourceIncludes(keys ...string) *SearchRequest

+ func (req *SearchRequest) Timeout(dur time.Duration) *SearchRequest

+ type Sort []map[string]interface

+ type Source struct

+ func (source Source) Map() map[string]interface{}

+ type StatsAgg struct

+ func Stats(name, field string) *StatsAgg

+ func (agg *StatsAgg) Missing(val interface{}) *StatsAgg

+ type StringStatsAgg struct

+ ShowDist *bool

+ func StringStats(name, field string) *StringStatsAgg

+ func (agg *StringStatsAgg) Map() map[string]interface{}

+ func (agg *StringStatsAgg) Missing(val interface{}) *StringStatsAgg

+ func (agg *StringStatsAgg) ShowDistribution(b bool) *StringStatsAgg

+ type SumAgg struct

+ func Sum(name, field string) *SumAgg

+ func (agg *SumAgg) Missing(val interface{}) *SumAgg

+ type TermQuery struct

+ func Term(field string, value interface{}) *TermQuery

+ func (q *TermQuery) Boost(b float32) *TermQuery

+ func (q *TermQuery) Map() map[string]interface{}

+ func (q *TermQuery) Value(val interface{}) *TermQuery

+ type TermsAggregation struct

+ func TermsAgg(name, field string) *TermsAggregation

+ func (agg *TermsAggregation) Aggs(aggs ...Aggregation) *TermsAggregation

+ func (agg *TermsAggregation) Include(include ...string) *TermsAggregation

+ func (agg *TermsAggregation) Map() map[string]interface{}

+ func (agg *TermsAggregation) Name() string

+ func (agg *TermsAggregation) Order(order map[string]string) *TermsAggregation

+ func (agg *TermsAggregation) ShardSize(size float64) *TermsAggregation

+ func (agg *TermsAggregation) ShowTermDocCountError(b bool) *TermsAggregation

+ func (agg *TermsAggregation) Size(size uint64) *TermsAggregation

+ type TermsQuery struct

+ func Terms(field string, values ...interface{}) *TermsQuery

+ func (q *TermsQuery) Boost(b float32) *TermsQuery

+ func (q *TermsQuery) Values(values ...interface{}) *TermsQuery

+ func (q TermsQuery) Map() map[string]interface{}

+ type TermsSetQuery struct

+ func TermsSet(field string, terms ...string) *TermsSetQuery

+ func (q *TermsSetQuery) MinimumShouldMatchField(field string) *TermsSetQuery

+ func (q *TermsSetQuery) MinimumShouldMatchScript(script string) *TermsSetQuery

+ func (q *TermsSetQuery) Terms(terms ...string) *TermsSetQuery

+ func (q TermsSetQuery) Map() map[string]interface{}

+ type TopHitsAgg struct

+ func TopHits(name string) *TopHitsAgg

+ func (agg *TopHitsAgg) From(offset uint64) *TopHitsAgg

+ func (agg *TopHitsAgg) Map() map[string]interface{}

+ func (agg *TopHitsAgg) Name() string

+ func (agg *TopHitsAgg) Size(size uint64) *TopHitsAgg

+ func (agg *TopHitsAgg) Sort(name string, order Order) *TopHitsAgg

+ func (agg *TopHitsAgg) SourceIncludes(keys ...string) *TopHitsAgg

+ type ValueCountAgg struct

+ func ValueCount(name, field string) *ValueCountAgg

+ type WeightedAvgAgg struct

+ Val *BaseAggParams

+ Weig *BaseAggParams

+ func WeightedAvg(name string) *WeightedAvgAgg

+ func (agg *WeightedAvgAgg) Map() map[string]interface{}

+ func (agg *WeightedAvgAgg) Name() string

+ func (agg *WeightedAvgAgg) Value(field string, missing ...interface{}) *WeightedAvgAgg

+ func (agg *WeightedAvgAgg) Weight(field string, missing ...interface{}) *WeightedAvgAgg

+ type ZeroTerms uint8

+ const ZeroTermsAll

+ const ZeroTermsNone

+ func (a ZeroTerms) String() string