esq

package module
v0.0.0-...-d8b6c03 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 24, 2021 License: Apache-2.0 Imports: 8 Imported by: 0

README

esq

elasticsearch query

Usage

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"

	"github.com/elastic/go-elasticsearch/v7"
	"github.com/jump2/esq"
)

func main() {
	es, err := elasticsearch.NewDefaultClient()
	if err != nil {
		log.Fatalf("Failed creating client: %s", err)
	}

	resp, err := esq.Search().Query(
		esq.Bool().Must(
			esq.Term("program_language", "golang"),
			esq.Terms("status", []string{"enabled"}),
		),
	).Size(20).Sort(esq.Map{
		"age": "desc",
	}).Run(
		es,
		es.Search.WithContext(context.Background()),
		es.Search.WithIndex("huang_test"),
	)

	if err != nil {
		log.Fatalf("Failed searching for stuff: %s", err)
	}

	defer resp.Body.Close()

	var e map[string]interface{}
	if err := json.NewDecoder(resp.Body).Decode(&e); err != nil {
		log.Fatalf("Error parsing the response body: %s", err)
	}
	fmt.Println(e)
	//...
}

Documentation

Index

Constants

View Source 
const (
	OperatorOr  Operator = "or"
	OperatorAnd Operator = "and"

	ZeroTermsNone ZeroTerms = "none"
	ZeroTermsAll  ZeroTerms = "all"

	BestFields   MultiMatchType = "best_fields"
	MostField    MultiMatchType = "most_fields"
	CrossField   MultiMatchType = "cross_fields"
	Phrase       MultiMatchType = "phrase"
	PhrasePrefix MultiMatchType = "phrase_prefix"

	ScoringBoolean        Rewrite = "scoring_boolean"
	ConstantScore         Rewrite = "constant_score"
	ConstantScoreBoolean  Rewrite = "constant_score_boolean"
	TopTermsBlendedFreqsN Rewrite = "top_terms_blended_freqs_N"
	TopTermsBoostN        Rewrite = "top_terms_boost_N"
	TopTermsN             Rewrite = "top_terms_N"
)

Variables

This section is empty.

Functions

func MatchAll 

func MatchAll() *matchAllQuery

func MatchNone 

func MatchNone() *matchNoneQuery
func Search() *search

func ToStr 

func ToStr(value interface{}) (s string)

Types

type BoolQuery 

type BoolQuery struct {
	// contains filtered or unexported fields
}

func Bool 

func Bool() *BoolQuery

func (*BoolQuery) Boost 

func (q *BoolQuery) Boost(v float32) *BoolQuery

func (*BoolQuery) Filter 

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

func (*BoolQuery) Map 

func (q *BoolQuery) Map() Map

func (*BoolQuery) MinimumShouldMatch 

func (q *BoolQuery) MinimumShouldMatch(v int8) *BoolQuery

func (*BoolQuery) Must 

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

func (*BoolQuery) MustNot 

func (q *BoolQuery) MustNot(mustNot ...Mappable) *BoolQuery

func (*BoolQuery) Should 

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

type ExistsQuery 

type ExistsQuery struct {
	Field string `json:"field"`
}

Exists Query

func Exists 

func Exists(field string) *ExistsQuery

func (*ExistsQuery) Map 

func (q *ExistsQuery) Map() Map

type FuzzyQuery 

type FuzzyQuery struct {
	// contains filtered or unexported fields
}

Fuzzy Query

func Fuzzy 

func Fuzzy(field string, value string) *FuzzyQuery

func (*FuzzyQuery) Fuzziness 

func (q *FuzzyQuery) Fuzziness(v string) *FuzzyQuery

func (*FuzzyQuery) Map 

func (q *FuzzyQuery) Map() Map

func (*FuzzyQuery) MaxExpansions 

func (q *FuzzyQuery) MaxExpansions(v int32) *FuzzyQuery

func (*FuzzyQuery) PrefixLength 

func (q *FuzzyQuery) PrefixLength(v int32) *FuzzyQuery

func (*FuzzyQuery) Rewrite 

func (q *FuzzyQuery) Rewrite(v string) *FuzzyQuery

func (*FuzzyQuery) Transpositions 

func (q *FuzzyQuery) Transpositions(v bool) *FuzzyQuery

type FuzzyQueryParameters 

type FuzzyQueryParameters struct {
	Value          string `json:"value"`
	Fuzziness      string `json:"fuzziness,omitempty"`
	MaxExpansions  int32  `json:"max_expansions,omitempty"`
	PrefixLength   int32  `json:"prefix_length,omitempty"`
	Transpositions bool   `json:"transpositions,omitempty"`
	Rewrite        string `json:"rewrite,omitempty"`
}

type IdsQuery 

type IdsQuery struct {
	Values []interface{} `json:"values"`
}

IDs Query

func Ids 

func Ids(values ...interface{}) *IdsQuery

func (*IdsQuery) Map 

func (q *IdsQuery) Map() Map

type Map 

type Map map[string]interface{}

func NewMap 

func NewMap(key string, value interface{}) (m Map)

func (Map) Set 

func (m Map) Set(key string, value interface{})

type Mappable 

type Mappable interface {
	Map() Map
}

type MatchPhrasePrefixQuery 

type MatchPhrasePrefixQuery struct {
	// contains filtered or unexported fields
}

Match Phrase Prefix Query

func MatchPhrasePrefix 

func MatchPhrasePrefix(field string, query string) *MatchPhrasePrefixQuery

func (*MatchPhrasePrefixQuery) Analyzer 

func (q *MatchPhrasePrefixQuery) Analyzer(v string) *MatchPhrasePrefixQuery

func (*MatchPhrasePrefixQuery) Map 

func (q *MatchPhrasePrefixQuery) Map() Map

func (*MatchPhrasePrefixQuery) MaxExpansions 

func (q *MatchPhrasePrefixQuery) MaxExpansions(v int32) *MatchPhrasePrefixQuery

func (*MatchPhrasePrefixQuery) OmitValue 

func (q *MatchPhrasePrefixQuery) OmitValue(v string) *MatchPhrasePrefixQuery

func (*MatchPhrasePrefixQuery) Slop 

func (q *MatchPhrasePrefixQuery) Slop(v int32) *MatchPhrasePrefixQuery

func (*MatchPhrasePrefixQuery) ZeroTermsQuery 

func (q *MatchPhrasePrefixQuery) ZeroTermsQuery(v ZeroTerms) *MatchPhrasePrefixQuery

type MatchPhrasePrefixQueryParameters 

type MatchPhrasePrefixQueryParameters struct {
	Query          string    `json:"query"`
	Analyzer       string    `json:"analyzer,omitempty"`
	MaxExpansions  int32     `json:"max_expansions,omitempty"`
	Slop           int32     `json:"slop,omitempty"`
	ZeroTermsQuery ZeroTerms `json:"zero_terms_query,omitempty"`
}

type MatchPhraseQuery 

type MatchPhraseQuery struct {
	// contains filtered or unexported fields
}

Match Phrase Query

func MatchPhrase 

func MatchPhrase(field string, query string) *MatchPhraseQuery

func (*MatchPhraseQuery) Analyzer 

func (q *MatchPhraseQuery) Analyzer(v string) *MatchPhraseQuery

func (*MatchPhraseQuery) Map 

func (q *MatchPhraseQuery) Map() Map

func (*MatchPhraseQuery) OmitValue 

func (q *MatchPhraseQuery) OmitValue(v string) *MatchPhraseQuery

func (*MatchPhraseQuery) Slop 

func (q *MatchPhraseQuery) Slop(v int32) *MatchPhraseQuery

func (*MatchPhraseQuery) ZeroTermsQuery 

func (q *MatchPhraseQuery) ZeroTermsQuery(v ZeroTerms) *MatchPhraseQuery

type MatchPhraseQueryParameters 

type MatchPhraseQueryParameters struct {
	Query          string    `json:"query"`
	Analyzer       string    `json:"analyzer,omitempty"`
	ZeroTermsQuery ZeroTerms `json:"zero_terms_query,omitempty"`
	Slop           int32     `json:"slop,omitempty"`
}

type MatchQuery 

type MatchQuery struct {
	// contains filtered or unexported fields
}

Match Query

func Match 

func Match(field string, query string) *MatchQuery

func (*MatchQuery) Analyzer 

func (q *MatchQuery) Analyzer(v string) *MatchQuery

func (*MatchQuery) AutoGenerateSynonymsPhraseQuery 

func (q *MatchQuery) AutoGenerateSynonymsPhraseQuery(v bool) *MatchQuery

func (*MatchQuery) Fuzziness 

func (q *MatchQuery) Fuzziness(v string) *MatchQuery

func (*MatchQuery) FuzzyRewrite 

func (q *MatchQuery) FuzzyRewrite(v string) *MatchQuery

func (*MatchQuery) FuzzyTranspositions 

func (q *MatchQuery) FuzzyTranspositions(v bool) *MatchQuery

func (*MatchQuery) Lenient 

func (q *MatchQuery) Lenient(v bool) *MatchQuery

func (*MatchQuery) Map 

func (q *MatchQuery) Map() Map

func (*MatchQuery) MaxExpansions 

func (q *MatchQuery) MaxExpansions(v int32) *MatchQuery

func (*MatchQuery) MinimumShouldMatch 

func (q *MatchQuery) MinimumShouldMatch(v string) *MatchQuery

func (*MatchQuery) OmitValue 

func (q *MatchQuery) OmitValue(v string) *MatchQuery

func (*MatchQuery) Operator 

func (q *MatchQuery) Operator(v Operator) *MatchQuery

func (*MatchQuery) PrefixLength 

func (q *MatchQuery) PrefixLength(v int32) *MatchQuery

func (*MatchQuery) ZeroTermsQuery 

func (q *MatchQuery) ZeroTermsQuery(v ZeroTerms) *MatchQuery

type MatchQueryParameters 

type MatchQueryParameters struct {
	Query                           string    `json:"query"`
	Analyzer                        string    `json:"analyzer,omitempty"`
	AutoGenerateSynonymsPhraseQuery *bool     `json:"auto_generate_synonyms_phrase_query,omitempty"`
	Fuzziness                       string    `json:"fuzziness,omitempty"`
	MaxExpansions                   int32     `json:"max_expansions,omitempty"`
	PrefixLength                    int32     `json:"prefix_length,omitempty"`
	FuzzyTranspositions             bool      `json:"fuzzy_transpositions,omitempty"`
	FuzzyRewrite                    string    `json:"fuzzy_rewrite,omitempty"`
	Lenient                         *bool     `json:"lenient,omitempty"`
	Operator                        Operator  `json:"operator,omitempty"`
	MinimumShouldMatch              string    `json:"minimum_should_match,omitempty"`
	ZeroTermsQuery                  ZeroTerms `json:"zero_terms_query,omitempty"`
}

type MultiMatchQuery 

type MultiMatchQuery struct {
	// contains filtered or unexported fields
}

Multi-match Query The fuzziness parameter cannot be used with the cross_fields type.

func MultiMatch 

func MultiMatch(fields []string, query string) *MultiMatchQuery

func (*MultiMatchQuery) Analyzer 

func (q *MultiMatchQuery) Analyzer(v string) *MultiMatchQuery

func (*MultiMatchQuery) AutoGenerateSynonymsPhraseQuery 

func (q *MultiMatchQuery) AutoGenerateSynonymsPhraseQuery(v bool) *MultiMatchQuery

func (*MultiMatchQuery) Boost 

func (q *MultiMatchQuery) Boost(v float32) *MultiMatchQuery

func (*MultiMatchQuery) CutoffFrequency 

func (q *MultiMatchQuery) CutoffFrequency(v float32) *MultiMatchQuery

func (*MultiMatchQuery) Fuzziness 

func (q *MultiMatchQuery) Fuzziness(v string) *MultiMatchQuery

func (*MultiMatchQuery) FuzzyTranspositions 

func (q *MultiMatchQuery) FuzzyTranspositions(v bool) *MultiMatchQuery

func (*MultiMatchQuery) Lenient 

func (q *MultiMatchQuery) Lenient(v bool) *MultiMatchQuery

func (*MultiMatchQuery) Map 

func (q *MultiMatchQuery) Map() Map

func (*MultiMatchQuery) MaxExpansions 

func (q *MultiMatchQuery) MaxExpansions(v int32) *MultiMatchQuery

func (*MultiMatchQuery) MinimumShouldMatch 

func (q *MultiMatchQuery) MinimumShouldMatch(v string) *MultiMatchQuery

func (*MultiMatchQuery) OmitValue 

func (q *MultiMatchQuery) OmitValue(v string) *MultiMatchQuery

func (*MultiMatchQuery) Operator 

func (q *MultiMatchQuery) Operator(o Operator) *MultiMatchQuery

func (*MultiMatchQuery) PrefixLength 

func (q *MultiMatchQuery) PrefixLength(v int32) *MultiMatchQuery

func (*MultiMatchQuery) Rewrite 

func (q *MultiMatchQuery) Rewrite(v Rewrite) *MultiMatchQuery

func (*MultiMatchQuery) TieBreaker 

func (q *MultiMatchQuery) TieBreaker(v float32) *MultiMatchQuery

func (*MultiMatchQuery) Type 

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

func (*MultiMatchQuery) ZeroTermsQuery 

func (q *MultiMatchQuery) ZeroTermsQuery(v ZeroTerms) *MultiMatchQuery

type MultiMatchQueryParameters 

type MultiMatchQueryParameters struct {
	Query                           string         `json:"query"`
	Fields                          []string       `json:"fields,omitempty"`
	Type                            MultiMatchType `json:"type,omitempty"`
	Operator                        Operator       `json:"operator,omitempty"`
	MinimumShouldMatch              string         `json:"minimum_should_match ,omitempty"`
	TieBreaker                      float32        `json:"tie_breaker,omitempty"`
	Analyzer                        string         `json:"analyzer,omitempty"`
	Boost                           float32        `json:"boost,omitempty"`
	AutoGenerateSynonymsPhraseQuery bool           `json:"auto_generate_synonyms_phrase_query,omitempty"`
	Fuzziness                       string         `json:"fuzziness,omitempty"`
	MaxExpansions                   int32          `json:"max_expansions,omitempty"`
	PrefixLength                    int32          `json:"prefix_length,omitempty"`
	FuzzyTranspositions             bool           `json:"fuzzy_transpositions,omitempty"`
	Lenient                         bool           `json:"lenient,omitempty"`
	ZeroTermsQuery                  ZeroTerms      `json:"zero_terms_query,omitempty"`
	CutoffFrequency                 float32        `json:"cutoff_frequency,omitempty"`
	Rewrite                         Rewrite        `json:"rewrite,omitempty"`
}

type MultiMatchType 

type MultiMatchType string

type Operator 

type Operator string

type PrefixQuery 

type PrefixQuery struct {
	// contains filtered or unexported fields
}

Prefix Query

func Prefix 

func Prefix(field string, value string) *PrefixQuery

func (*PrefixQuery) CaseInsensitive 

func (q *PrefixQuery) CaseInsensitive(v bool) *PrefixQuery

add in 7.10.0

func (*PrefixQuery) Map 

func (q *PrefixQuery) Map() Map

func (*PrefixQuery) OmitValue 

func (q *PrefixQuery) OmitValue(v string) *PrefixQuery

func (*PrefixQuery) Rewrite 

func (q *PrefixQuery) Rewrite(v Rewrite) *PrefixQuery

type PrefixQueryParameters 

type PrefixQueryParameters struct {
	Value           string  `json:"value"`
	Rewrite         Rewrite `json:"rewrite,omitempty"`
	CaseInsensitive bool    `json:"case_insensitive,omitempty"`
}

type RangeQuery 

type RangeQuery struct {
	// contains filtered or unexported fields
}

func Range 

func Range(field string) *RangeQuery

func (*RangeQuery) Boost 

func (q *RangeQuery) Boost(v float32) *RangeQuery

func (*RangeQuery) Format 

func (q *RangeQuery) Format(v string) *RangeQuery

func (*RangeQuery) Gt 

func (q *RangeQuery) Gt(v interface{}) *RangeQuery

func (*RangeQuery) Gte 

func (q *RangeQuery) Gte(v interface{}) *RangeQuery

func (*RangeQuery) Lt 

func (q *RangeQuery) Lt(v interface{}) *RangeQuery

func (*RangeQuery) Lte 

func (q *RangeQuery) Lte(v interface{}) *RangeQuery

func (*RangeQuery) Map 

func (q *RangeQuery) Map() Map

func (*RangeQuery) OmitValue 

func (q *RangeQuery) OmitValue(v interface{}) *RangeQuery

func (*RangeQuery) Relation 

func (q *RangeQuery) Relation(v Relation) *RangeQuery

func (*RangeQuery) TimeZone 

func (q *RangeQuery) TimeZone(v string) *RangeQuery

type RangeQueryParameters 

type RangeQueryParameters struct {
	Gt       interface{} `json:"gt,omitempty"`
	Gte      interface{} `json:"gte,omitempty"`
	Lt       interface{} `json:"lt,omitempty"`
	Lte      interface{} `json:"lte,omitempty"`
	Format   string      `json:"format,omitempty"`
	Relation Relation    `json:"relation,omitempty"`
	TimeZone string      `json:"time_zone,omitempty"`
	Boost    float32     `json:"boost,omitempty"`
}

type RegexpQuery 

type RegexpQuery struct {
	// contains filtered or unexported fields
}

Regexp Query

func Regex 

func Regex(field string, value string) *RegexpQuery

func (*RegexpQuery) CaseInsensitive 

func (q *RegexpQuery) CaseInsensitive(v bool) *RegexpQuery

add in 7.10.0

func (*RegexpQuery) Flags 

func (q *RegexpQuery) Flags(v string) *RegexpQuery

func (*RegexpQuery) Map 

func (q *RegexpQuery) Map() Map

func (*RegexpQuery) MaxDeterminizedStates 

func (q *RegexpQuery) MaxDeterminizedStates(v int32) *RegexpQuery

func (*RegexpQuery) OmitValue 

func (q *RegexpQuery) OmitValue(v string) *RegexpQuery

func (*RegexpQuery) Rewrite 

func (q *RegexpQuery) Rewrite(v Rewrite) *RegexpQuery

type RegexpQueryParameters 

type RegexpQueryParameters struct {
	Value                 string  `json:"value"`
	Flags                 string  `json:"flags,omitempty"`
	Rewrite               Rewrite `json:"rewrite,omitempty"`
	CaseInsensitive       bool    `json:"case_insensitive,omitempty"`
	MaxDeterminizedStates int32   `json:"max_determinized_states,omitempty"`
}

type Relation 

type Relation string

Range Query 

const (
	RelationIntersects Relation = "INTERSECTS"
	RelationContains   Relation = "CONTAINS"
	RelationWithin     Relation = "WITHIN"
)

type Rewrite 

type Rewrite string

type SearchParameter 

type SearchParameter struct {
	Query  Map      `json:"query"`
	Size   *int     `json:"size,omitempty"`
	From   *int     `json:"from,omitempty"`
	Source []string `json:"_source,omitempty"`
	Sort   []Map    `json:"sort,omitempty"`
}

type TermQuery 

type TermQuery struct {
	// contains filtered or unexported fields
}

Term Query

func Term 

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

func (*TermQuery) Boost 

func (q *TermQuery) Boost(v float32) *TermQuery

func (*TermQuery) Map 

func (q *TermQuery) Map() Map

func (*TermQuery) OmitValue 

func (q *TermQuery) OmitValue(v interface{}) *TermQuery

type TermQueryParameters 

type TermQueryParameters struct {
	Value interface{} `json:"value"`
	Boost float32     `json:"boost,omitempty"`
}

type TermsQuery 

type TermsQuery struct {
	// contains filtered or unexported fields
}

Terms Query

func Terms 

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

func (*TermsQuery) Boost 

func (q *TermsQuery) Boost(v float32) *TermsQuery

func (*TermsQuery) Map 

func (q *TermsQuery) Map() Map

func (*TermsQuery) OmitValue 

func (q *TermsQuery) OmitValue(v interface{}) *TermsQuery

type TermsSetQuery 

type TermsSetQuery struct {
	// contains filtered or unexported fields
}

Terms Set Query

func TermsSet 

func TermsSet(field string, value ...interface{}) *TermsSetQuery

func (*TermsSetQuery) Map 

func (q *TermsSetQuery) Map() Map

func (*TermsSetQuery) MinimumShouldMatchField 

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

func (*TermsSetQuery) MinimumShouldMatchScript 

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

func (*TermsSetQuery) OmitValue 

func (q *TermsSetQuery) OmitValue(v interface{}) *TermsSetQuery

type TermsSetQueryParameters 

type TermsSetQueryParameters struct {
	Terms                    []interface{} `json:"terms"`
	MinimumShouldMatchField  string        `json:"minimum_should_match_field,omitempty"`
	MinimumShouldMatchScript Map           `json:"minimum_should_match_script,omitempty"`
}

type WildcardQuery 

type WildcardQuery struct {
	// contains filtered or unexported fields
}

Wildcard Query

func Wildcard 

func Wildcard(field string, value string) *WildcardQuery

func (*WildcardQuery) Boost 

func (q *WildcardQuery) Boost(v float32) *WildcardQuery

func (*WildcardQuery) CaseInsensitive 

func (q *WildcardQuery) CaseInsensitive(v bool) *WildcardQuery

add in 7.10.0

func (*WildcardQuery) Map 

func (q *WildcardQuery) Map() Map

func (*WildcardQuery) OmitValue 

func (q *WildcardQuery) OmitValue(v string) *WildcardQuery

func (*WildcardQuery) Rewrite 

func (q *WildcardQuery) Rewrite(v Rewrite) *WildcardQuery

type WildcardQueryParameters 

type WildcardQueryParameters struct {
	Value           string  `json:"value"`
	Boost           float32 `json:"boost,omitempty"`
	Rewrite         Rewrite `json:"rewrite,omitempty"`
	CaseInsensitive bool    `json:"case_insensitive,omitempty"`
}

type ZeroTerms 

type ZeroTerms string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.