From 11bb2b31eb6a230543733020c8c353935adf5df4 Mon Sep 17 00:00:00 2001 From: k-yomo Date: Tue, 21 Dec 2021 22:00:39 +0900 Subject: [PATCH] Add support for combined_fields query --- query_combined_fields.go | 86 +++++++++++++++++++++++++++++++++++ query_combined_fields_test.go | 43 ++++++++++++++++++ 2 files changed, 129 insertions(+) create mode 100644 query_combined_fields.go create mode 100644 query_combined_fields_test.go diff --git a/query_combined_fields.go b/query_combined_fields.go new file mode 100644 index 0000000..87b4e2d --- /dev/null +++ b/query_combined_fields.go @@ -0,0 +1,86 @@ +package esquery + +import "github.com/fatih/structs" + +type CombinedFieldsQuery struct { + params combinedFieldsParams +} + +// Map returns a map representation of the query; implementing the +// Mappable interface. +func (q *CombinedFieldsQuery) Map() map[string]interface{} { + return map[string]interface{}{ + "combined_fields": structs.Map(q.params), + } +} + +type combinedFieldsParams struct { + Qry interface{} `structs:"query"` + Fields []string `structs:"fields"` + Boost float32 `structs:"boost,omitempty"` + AutoGenerate *bool `structs:"auto_generate_synonyms_phrase_query,omitempty"` + Op MatchOperator `structs:"operator,string,omitempty"` + MinMatch string `structs:"minimum_should_match,omitempty"` + ZeroTerms ZeroTerms `structs:"zero_terms_query,string,omitempty"` +} + +// CombinedFields creates a new query of type "combined_fields" +func CombinedFields(simpleQuery interface{}) *CombinedFieldsQuery { + return newCombinedFields(simpleQuery) +} + +func newCombinedFields(simpleQuery interface{}) *CombinedFieldsQuery { + return &CombinedFieldsQuery{ + params: combinedFieldsParams{ + Qry: simpleQuery, + }, + } +} + +// Query sets the data to find in the query's field (it is the "query" component +// of the query). +func (q *CombinedFieldsQuery) Query(data interface{}) *CombinedFieldsQuery { + q.params.Qry = data + return q +} + +// Fields sets the fields used in the query +func (q *CombinedFieldsQuery) Fields(a ...string) *CombinedFieldsQuery { + q.params.Fields = append(q.params.Fields, a...) + return q +} + +// AutoGenerateSynonymsPhraseQuery sets the "auto_generate_synonyms_phrase_query" +// boolean. +func (q *CombinedFieldsQuery) AutoGenerateSynonymsPhraseQuery(b bool) *CombinedFieldsQuery { + q.params.AutoGenerate = &b + return q +} + +// Boost +func (q *CombinedFieldsQuery) Boost(l float32) *CombinedFieldsQuery { + q.params.Boost = l + return q +} + +// Operator sets the boolean logic used to interpret text in the query value. +func (q *CombinedFieldsQuery) Operator(op MatchOperator) *CombinedFieldsQuery { + q.params.Op = op + return q +} + +// MinimumShouldMatch sets the minimum number of clauses that must match for a +// document to be returned. +func (q *CombinedFieldsQuery) MinimumShouldMatch(s string) *CombinedFieldsQuery { + q.params.MinMatch = s + return q +} + +// ZeroTermsQuery sets the "zero_terms_query" option to use. This indicates +// whether no documents are returned if the analyzer removes all tokens, such as +// when using a stop filter. +func (q *CombinedFieldsQuery) ZeroTermsQuery(s ZeroTerms) *CombinedFieldsQuery { + q.params.ZeroTerms = s + return q +} + diff --git a/query_combined_fields_test.go b/query_combined_fields_test.go new file mode 100644 index 0000000..d9183c0 --- /dev/null +++ b/query_combined_fields_test.go @@ -0,0 +1,43 @@ +package esquery + +import ( + "testing" +) + +func TestCombinedFields(t *testing.T) { + runMapTests(t, []mapTest{ + { + "simple combined_fields", + CombinedFields("value1").Fields("title"), + map[string]interface{}{ + "combined_fields": map[string]interface{}{ + "fields": []string{"title"}, + "query": "value1", + }, + }, + }, + { + "combined_fields all params", + CombinedFields("original"). + Query("test"). + Fields("title", "body"). + AutoGenerateSynonymsPhraseQuery(true). + Boost(6.4). + Operator(OperatorAnd). + MinimumShouldMatch("3<90%"). + ZeroTermsQuery(ZeroTermsAll), + map[string]interface{}{ + "combined_fields": map[string]interface{}{ + "auto_generate_synonyms_phrase_query": true, + "boost": 6.4, + "minimum_should_match": "3<90%", + "operator": "AND", + "zero_terms_query": "all", + "query": "test", + "fields": []string{"title", "body"}, + }, + }, + }, + }) +} +