From fb742c189ed43878d94f3261f85dc55c1bc35fdf Mon Sep 17 00:00:00 2001 From: Oliver Eilhard Date: Wed, 16 Jun 2021 11:49:17 +0200 Subject: [PATCH] Support case sensitivity in most term-level queries Elasticsearch 7.10 added a case-sensitivity option to most term-level queries. Close #1496 --- search_queries_prefix.go | 19 ++++++++++++++----- search_queries_prefix_test.go | 4 ++-- search_queries_regexp.go | 9 +++++++++ search_queries_regexp_test.go | 3 ++- search_queries_term.go | 19 ++++++++++++++----- search_queries_term_test.go | 3 ++- search_queries_wildcard.go | 8 ++++---- 7 files changed, 47 insertions(+), 18 deletions(-) diff --git a/search_queries_prefix.go b/search_queries_prefix.go index 8178aac3f..5e9813e19 100644 --- a/search_queries_prefix.go +++ b/search_queries_prefix.go @@ -10,11 +10,12 @@ package elastic // For more details, see // https://www.elastic.co/guide/en/elasticsearch/reference/7.0/query-dsl-prefix-query.html type PrefixQuery struct { - name string - prefix string - boost *float64 - rewrite string - queryName string + name string + prefix string + boost *float64 + rewrite string + caseInsensitive *bool + queryName string } // NewPrefixQuery creates and initializes a new PrefixQuery. @@ -33,6 +34,11 @@ func (q *PrefixQuery) Rewrite(rewrite string) *PrefixQuery { return q } +func (q *PrefixQuery) CaseInsensitive(caseInsensitive bool) *PrefixQuery { + q.caseInsensitive = &caseInsensitive + return q +} + // QueryName sets the query name for the filter that can be used when // searching for matched_filters per hit. func (q *PrefixQuery) QueryName(queryName string) *PrefixQuery { @@ -57,6 +63,9 @@ func (q *PrefixQuery) Source() (interface{}, error) { if q.rewrite != "" { subQuery["rewrite"] = q.rewrite } + if q.caseInsensitive != nil { + subQuery["case_insensitive"] = *q.caseInsensitive + } if q.queryName != "" { subQuery["_name"] = q.queryName } diff --git a/search_queries_prefix_test.go b/search_queries_prefix_test.go index 78d27b600..2666fbe82 100644 --- a/search_queries_prefix_test.go +++ b/search_queries_prefix_test.go @@ -27,7 +27,7 @@ func TestPrefixQuery(t *testing.T) { } func TestPrefixQueryWithOptions(t *testing.T) { - q := NewPrefixQuery("user", "ki") + q := NewPrefixQuery("user", "ki").CaseInsensitive(true) q = q.QueryName("my_query_name") src, err := q.Source() if err != nil { @@ -38,7 +38,7 @@ func TestPrefixQueryWithOptions(t *testing.T) { t.Fatalf("marshaling to JSON failed: %v", err) } got := string(data) - expected := `{"prefix":{"user":{"_name":"my_query_name","value":"ki"}}}` + expected := `{"prefix":{"user":{"_name":"my_query_name","case_insensitive":true,"value":"ki"}}}` if got != expected { t.Errorf("expected\n%s\n,got:\n%s", expected, got) } diff --git a/search_queries_regexp.go b/search_queries_regexp.go index 25a0c3d02..fd8370bd3 100644 --- a/search_queries_regexp.go +++ b/search_queries_regexp.go @@ -14,6 +14,7 @@ type RegexpQuery struct { flags string boost *float64 rewrite string + caseInsensitive *bool queryName string maxDeterminizedStates *int } @@ -46,6 +47,11 @@ func (q *RegexpQuery) Rewrite(rewrite string) *RegexpQuery { return q } +func (q *RegexpQuery) CaseInsensitive(caseInsensitive bool) *RegexpQuery { + q.caseInsensitive = &caseInsensitive + return q +} + // QueryName sets the query name for the filter that can be used // when searching for matched_filters per hit func (q *RegexpQuery) QueryName(queryName string) *RegexpQuery { @@ -73,6 +79,9 @@ func (q *RegexpQuery) Source() (interface{}, error) { if q.rewrite != "" { x["rewrite"] = q.rewrite } + if q.caseInsensitive != nil { + x["case_insensitive"] = *q.caseInsensitive + } if q.queryName != "" { x["name"] = q.queryName } diff --git a/search_queries_regexp_test.go b/search_queries_regexp_test.go index d30c0a36d..46562adfb 100644 --- a/search_queries_regexp_test.go +++ b/search_queries_regexp_test.go @@ -30,6 +30,7 @@ func TestRegexpQueryWithOptions(t *testing.T) { q := NewRegexpQuery("name.first", "s.*y"). Boost(1.2). Flags("INTERSECTION|COMPLEMENT|EMPTY"). + CaseInsensitive(true). QueryName("my_query_name") src, err := q.Source() if err != nil { @@ -40,7 +41,7 @@ func TestRegexpQueryWithOptions(t *testing.T) { t.Fatalf("marshaling to JSON failed: %v", err) } got := string(data) - expected := `{"regexp":{"name.first":{"boost":1.2,"flags":"INTERSECTION|COMPLEMENT|EMPTY","name":"my_query_name","value":"s.*y"}}}` + expected := `{"regexp":{"name.first":{"boost":1.2,"case_insensitive":true,"flags":"INTERSECTION|COMPLEMENT|EMPTY","name":"my_query_name","value":"s.*y"}}}` if got != expected { t.Errorf("expected\n%s\n,got:\n%s", expected, got) } diff --git a/search_queries_term.go b/search_queries_term.go index 832e67e5e..7d9c89dc6 100644 --- a/search_queries_term.go +++ b/search_queries_term.go @@ -10,10 +10,11 @@ package elastic // For details, see // https://www.elastic.co/guide/en/elasticsearch/reference/7.0/query-dsl-term-query.html type TermQuery struct { - name string - value interface{} - boost *float64 - queryName string + name string + value interface{} + boost *float64 + caseInsensitive *bool + queryName string } // NewTermQuery creates and initializes a new TermQuery. @@ -27,6 +28,11 @@ func (q *TermQuery) Boost(boost float64) *TermQuery { return q } +func (q *TermQuery) CaseInsensitive(caseInsensitive bool) *TermQuery { + q.caseInsensitive = &caseInsensitive + return q +} + // QueryName sets the query name for the filter that can be used // when searching for matched_filters per hit func (q *TermQuery) QueryName(queryName string) *TermQuery { @@ -41,7 +47,7 @@ func (q *TermQuery) Source() (interface{}, error) { tq := make(map[string]interface{}) source["term"] = tq - if q.boost == nil && q.queryName == "" { + if q.boost == nil && q.caseInsensitive == nil && q.queryName == "" { tq[q.name] = q.value } else { subQ := make(map[string]interface{}) @@ -49,6 +55,9 @@ func (q *TermQuery) Source() (interface{}, error) { if q.boost != nil { subQ["boost"] = *q.boost } + if q.caseInsensitive != nil { + subQ["case_insensitive"] = *q.caseInsensitive + } if q.queryName != "" { subQ["_name"] = q.queryName } diff --git a/search_queries_term_test.go b/search_queries_term_test.go index f800fa954..8def1df47 100644 --- a/search_queries_term_test.go +++ b/search_queries_term_test.go @@ -30,6 +30,7 @@ func TestTermQueryWithOptions(t *testing.T) { q := NewTermQuery("user", "ki") q = q.Boost(2.79) q = q.QueryName("my_tq") + q = q.CaseInsensitive(true) src, err := q.Source() if err != nil { t.Fatal(err) @@ -39,7 +40,7 @@ func TestTermQueryWithOptions(t *testing.T) { t.Fatalf("marshaling to JSON failed: %v", err) } got := string(data) - expected := `{"term":{"user":{"_name":"my_tq","boost":2.79,"value":"ki"}}}` + expected := `{"term":{"user":{"_name":"my_tq","boost":2.79,"case_insensitive":true,"value":"ki"}}}` if got != expected { t.Errorf("expected\n%s\n,got:\n%s", expected, got) } diff --git a/search_queries_wildcard.go b/search_queries_wildcard.go index cbb26e990..4cc1a8dbc 100644 --- a/search_queries_wildcard.go +++ b/search_queries_wildcard.go @@ -20,7 +20,7 @@ type WildcardQuery struct { boost *float64 rewrite string queryName string - caseInsensitive bool + caseInsensitive *bool } // NewWildcardQuery creates and initializes a new WildcardQuery. @@ -50,7 +50,7 @@ func (q *WildcardQuery) QueryName(queryName string) *WildcardQuery { // CaseInsensitive sets case insensitive matching of this query. func (q *WildcardQuery) CaseInsensitive(caseInsensitive bool) *WildcardQuery { - q.caseInsensitive = caseInsensitive + q.caseInsensitive = &caseInsensitive return q } @@ -84,8 +84,8 @@ func (q *WildcardQuery) Source() (interface{}, error) { if q.queryName != "" { wq["_name"] = q.queryName } - if q.caseInsensitive { - wq["case_insensitive"] = true + if q.caseInsensitive != nil { + wq["case_insensitive"] = *q.caseInsensitive } return source, nil