golib
/
esquery
2
0
Fork 0
Code Pull Requests Releases Activity
esquery/query_match.go

204 lines
4.6 KiB
Go
Raw Normal View History

Initial commit This commit is the initial commit for a Go library providing an idiomatic, easy-to-use query builder for ElasticSearch. The library can build queries and execute them using the structures from the official Go SDK provided by the ES project (https://github.com/elastic/go-elasticsearch). The library currently provides the capabilities to create and execute simple ElasticSearch queries, specifically Match queries (match, match_bool_prefix, match_phrase and match_phrase_prefix), Match All queries (match_all, match_none), and all of the Term-level queries (e.g. range, regexp, etc.). Unit tests are included for each support query, and the code is linted using golangci-lint (see enabled linters in .golangci-lint). The unit tests currently only verify the builder creates valid JSON queries and does not attempt to actually run queries against a (mock) ES instance.
2020-02-18 12:00:15 +00:00
package esquery
import (
"bytes"
"io"
Refactor API, add aggregations and custom queries This commit introduces a refactor of the codebase and the API, to make it more user friendly. Queries can now directly be executed via the `Run()` method. Internally, the library no longer uses JSON generation as a major mechanism, instead all types need to implement a `Mappable` interface which simply turns each type in a `map[string]interface{}`, which is what the ElasticSearch client expects. This makes the code easier to write, and makes writing tests less error prone, as JSON need not be written directly. Support for metrics aggregations is also added. However, aggregations of type bucket, pipeline and matrix are not supported yet. To make the library more useful in its current state, support is added for running custom queries and aggregations, via the `CustomQuery()` and `CustomAgg()` functions, which both accepts an arbitrary `map[string]interface{}`.
2020-02-19 11:35:21 +00:00
"github.com/fatih/structs"
Initial commit This commit is the initial commit for a Go library providing an idiomatic, easy-to-use query builder for ElasticSearch. The library can build queries and execute them using the structures from the official Go SDK provided by the ES project (https://github.com/elastic/go-elasticsearch). The library currently provides the capabilities to create and execute simple ElasticSearch queries, specifically Match queries (match, match_bool_prefix, match_phrase and match_phrase_prefix), Match All queries (match_all, match_none), and all of the Term-level queries (e.g. range, regexp, etc.). Unit tests are included for each support query, and the code is linted using golangci-lint (see enabled linters in .golangci-lint). The unit tests currently only verify the builder creates valid JSON queries and does not attempt to actually run queries against a (mock) ES instance.
2020-02-18 12:00:15 +00:00
)
/*******************************************************************************
* Match Queries
* https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-match-query.html
* https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-match-bool-prefix-query.html
* https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-match-query-phrase.html
* https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-match-query-phrase-prefix.html
******************************************************************************/
type matchType uint8
const (
TypeMatch matchType = iota
TypeMatchBoolPrefix
TypeMatchPhrase
TypeMatchPhrasePrefix
)
type MatchQuery struct {
field string
mType matchType
params matchParams
}
Refactor API, add aggregations and custom queries This commit introduces a refactor of the codebase and the API, to make it more user friendly. Queries can now directly be executed via the `Run()` method. Internally, the library no longer uses JSON generation as a major mechanism, instead all types need to implement a `Mappable` interface which simply turns each type in a `map[string]interface{}`, which is what the ElasticSearch client expects. This makes the code easier to write, and makes writing tests less error prone, as JSON need not be written directly. Support for metrics aggregations is also added. However, aggregations of type bucket, pipeline and matrix are not supported yet. To make the library more useful in its current state, support is added for running custom queries and aggregations, via the `CustomQuery()` and `CustomAgg()` functions, which both accepts an arbitrary `map[string]interface{}`.
2020-02-19 11:35:21 +00:00
func (a *MatchQuery) Map() map[string]interface{} {
Initial commit This commit is the initial commit for a Go library providing an idiomatic, easy-to-use query builder for ElasticSearch. The library can build queries and execute them using the structures from the official Go SDK provided by the ES project (https://github.com/elastic/go-elasticsearch). The library currently provides the capabilities to create and execute simple ElasticSearch queries, specifically Match queries (match, match_bool_prefix, match_phrase and match_phrase_prefix), Match All queries (match_all, match_none), and all of the Term-level queries (e.g. range, regexp, etc.). Unit tests are included for each support query, and the code is linted using golangci-lint (see enabled linters in .golangci-lint). The unit tests currently only verify the builder creates valid JSON queries and does not attempt to actually run queries against a (mock) ES instance.
2020-02-18 12:00:15 +00:00
var mType string
switch a.mType {
case TypeMatch:
mType = "match"
case TypeMatchBoolPrefix:
mType = "match_bool_prefix"
case TypeMatchPhrase:
mType = "match_phrase"
case TypeMatchPhrasePrefix:
mType = "match_phrase_prefix"
}
Refactor API, add aggregations and custom queries This commit introduces a refactor of the codebase and the API, to make it more user friendly. Queries can now directly be executed via the `Run()` method. Internally, the library no longer uses JSON generation as a major mechanism, instead all types need to implement a `Mappable` interface which simply turns each type in a `map[string]interface{}`, which is what the ElasticSearch client expects. This makes the code easier to write, and makes writing tests less error prone, as JSON need not be written directly. Support for metrics aggregations is also added. However, aggregations of type bucket, pipeline and matrix are not supported yet. To make the library more useful in its current state, support is added for running custom queries and aggregations, via the `CustomQuery()` and `CustomAgg()` functions, which both accepts an arbitrary `map[string]interface{}`.
2020-02-19 11:35:21 +00:00
return map[string]interface{}{
Initial commit This commit is the initial commit for a Go library providing an idiomatic, easy-to-use query builder for ElasticSearch. The library can build queries and execute them using the structures from the official Go SDK provided by the ES project (https://github.com/elastic/go-elasticsearch). The library currently provides the capabilities to create and execute simple ElasticSearch queries, specifically Match queries (match, match_bool_prefix, match_phrase and match_phrase_prefix), Match All queries (match_all, match_none), and all of the Term-level queries (e.g. range, regexp, etc.). Unit tests are included for each support query, and the code is linted using golangci-lint (see enabled linters in .golangci-lint). The unit tests currently only verify the builder creates valid JSON queries and does not attempt to actually run queries against a (mock) ES instance.
2020-02-18 12:00:15 +00:00
mType: map[string]interface{}{
Refactor API, add aggregations and custom queries This commit introduces a refactor of the codebase and the API, to make it more user friendly. Queries can now directly be executed via the `Run()` method. Internally, the library no longer uses JSON generation as a major mechanism, instead all types need to implement a `Mappable` interface which simply turns each type in a `map[string]interface{}`, which is what the ElasticSearch client expects. This makes the code easier to write, and makes writing tests less error prone, as JSON need not be written directly. Support for metrics aggregations is also added. However, aggregations of type bucket, pipeline and matrix are not supported yet. To make the library more useful in its current state, support is added for running custom queries and aggregations, via the `CustomQuery()` and `CustomAgg()` functions, which both accepts an arbitrary `map[string]interface{}`.
2020-02-19 11:35:21 +00:00
a.field: structs.Map(a.params),
Initial commit This commit is the initial commit for a Go library providing an idiomatic, easy-to-use query builder for ElasticSearch. The library can build queries and execute them using the structures from the official Go SDK provided by the ES project (https://github.com/elastic/go-elasticsearch). The library currently provides the capabilities to create and execute simple ElasticSearch queries, specifically Match queries (match, match_bool_prefix, match_phrase and match_phrase_prefix), Match All queries (match_all, match_none), and all of the Term-level queries (e.g. range, regexp, etc.). Unit tests are included for each support query, and the code is linted using golangci-lint (see enabled linters in .golangci-lint). The unit tests currently only verify the builder creates valid JSON queries and does not attempt to actually run queries against a (mock) ES instance.
2020-02-18 12:00:15 +00:00
},
Refactor API, add aggregations and custom queries This commit introduces a refactor of the codebase and the API, to make it more user friendly. Queries can now directly be executed via the `Run()` method. Internally, the library no longer uses JSON generation as a major mechanism, instead all types need to implement a `Mappable` interface which simply turns each type in a `map[string]interface{}`, which is what the ElasticSearch client expects. This makes the code easier to write, and makes writing tests less error prone, as JSON need not be written directly. Support for metrics aggregations is also added. However, aggregations of type bucket, pipeline and matrix are not supported yet. To make the library more useful in its current state, support is added for running custom queries and aggregations, via the `CustomQuery()` and `CustomAgg()` functions, which both accepts an arbitrary `map[string]interface{}`.
2020-02-19 11:35:21 +00:00
}
Initial commit This commit is the initial commit for a Go library providing an idiomatic, easy-to-use query builder for ElasticSearch. The library can build queries and execute them using the structures from the official Go SDK provided by the ES project (https://github.com/elastic/go-elasticsearch). The library currently provides the capabilities to create and execute simple ElasticSearch queries, specifically Match queries (match, match_bool_prefix, match_phrase and match_phrase_prefix), Match All queries (match_all, match_none), and all of the Term-level queries (e.g. range, regexp, etc.). Unit tests are included for each support query, and the code is linted using golangci-lint (see enabled linters in .golangci-lint). The unit tests currently only verify the builder creates valid JSON queries and does not attempt to actually run queries against a (mock) ES instance.
2020-02-18 12:00:15 +00:00
}
type matchParams struct {
Refactor API, add aggregations and custom queries This commit introduces a refactor of the codebase and the API, to make it more user friendly. Queries can now directly be executed via the `Run()` method. Internally, the library no longer uses JSON generation as a major mechanism, instead all types need to implement a `Mappable` interface which simply turns each type in a `map[string]interface{}`, which is what the ElasticSearch client expects. This makes the code easier to write, and makes writing tests less error prone, as JSON need not be written directly. Support for metrics aggregations is also added. However, aggregations of type bucket, pipeline and matrix are not supported yet. To make the library more useful in its current state, support is added for running custom queries and aggregations, via the `CustomQuery()` and `CustomAgg()` functions, which both accepts an arbitrary `map[string]interface{}`.
2020-02-19 11:35:21 +00:00
Qry interface{} `structs:"query"`
Anl string `structs:"analyzer,omitempty"`
AutoGenerate *bool `structs:"auto_generate_synonyms_phrase_query,omitempty"`
Fuzz string `structs:"fuzziness,omitempty"`
MaxExp uint16 `structs:"max_expansions,omitempty"`
PrefLen uint16 `structs:"prefix_length,omitempty"`
Trans *bool `structs:"transpositions,omitempty"`
FuzzyRw string `structs:"fuzzy_rewrite,omitempty"`
Lent bool `structs:"lenient,omitempty"`
Op MatchOperator `structs:"operator,string,omitempty"`
MinMatch string `structs:"minimum_should_match,omitempty"`
ZeroTerms ZeroTerms `structs:"zero_terms_query,string,omitempty"`
Slp uint16 `structs:"slop,omitempty"` // only relevant for match_phrase query
Initial commit This commit is the initial commit for a Go library providing an idiomatic, easy-to-use query builder for ElasticSearch. The library can build queries and execute them using the structures from the official Go SDK provided by the ES project (https://github.com/elastic/go-elasticsearch). The library currently provides the capabilities to create and execute simple ElasticSearch queries, specifically Match queries (match, match_bool_prefix, match_phrase and match_phrase_prefix), Match All queries (match_all, match_none), and all of the Term-level queries (e.g. range, regexp, etc.). Unit tests are included for each support query, and the code is linted using golangci-lint (see enabled linters in .golangci-lint). The unit tests currently only verify the builder creates valid JSON queries and does not attempt to actually run queries against a (mock) ES instance.
2020-02-18 12:00:15 +00:00
}
func Match(fieldName string, simpleQuery ...interface{}) *MatchQuery {
return newMatch(TypeMatch, fieldName, simpleQuery...)
}
func MatchBoolPrefix(fieldName string, simpleQuery ...interface{}) *MatchQuery {
return newMatch(TypeMatchBoolPrefix, fieldName, simpleQuery...)
}
func MatchPhrase(fieldName string, simpleQuery ...interface{}) *MatchQuery {
return newMatch(TypeMatchPhrase, fieldName, simpleQuery...)
}
func MatchPhrasePrefix(fieldName string, simpleQuery ...interface{}) *MatchQuery {
return newMatch(TypeMatchPhrasePrefix, fieldName, simpleQuery...)
}
func newMatch(mType matchType, fieldName string, simpleQuery ...interface{}) *MatchQuery {
var qry interface{}
Add Search() function, README and fix some lint errors This commit changes the internal `search()` function into an exposed `Search()` function that can be used to execute queries against an instance of an ElasticSearch client. The per-query-type methods of `Run()` are removed for now to prevent having to create them for every type. `Search()` is agnostic. A README.md file is added with some information, and a few lingering lint errors are fixed.
2020-02-18 16:43:19 +00:00
if len(simpleQuery) > 0 {
Initial commit This commit is the initial commit for a Go library providing an idiomatic, easy-to-use query builder for ElasticSearch. The library can build queries and execute them using the structures from the official Go SDK provided by the ES project (https://github.com/elastic/go-elasticsearch). The library currently provides the capabilities to create and execute simple ElasticSearch queries, specifically Match queries (match, match_bool_prefix, match_phrase and match_phrase_prefix), Match All queries (match_all, match_none), and all of the Term-level queries (e.g. range, regexp, etc.). Unit tests are included for each support query, and the code is linted using golangci-lint (see enabled linters in .golangci-lint). The unit tests currently only verify the builder creates valid JSON queries and does not attempt to actually run queries against a (mock) ES instance.
2020-02-18 12:00:15 +00:00
qry = simpleQuery[len(simpleQuery)-1]
}
return &MatchQuery{
field: fieldName,
mType: mType,
params: matchParams{
Qry: qry,
},
}
}
func (q *MatchQuery) Query(data interface{}) *MatchQuery {
q.params.Qry = data
return q
}
func (q *MatchQuery) Analyzer(a string) *MatchQuery {
q.params.Anl = a
return q
}
func (q *MatchQuery) AutoGenerateSynonymsPhraseQuery(b bool) *MatchQuery {
q.params.AutoGenerate = &b
return q
}
func (q *MatchQuery) Fuzziness(f string) *MatchQuery {
q.params.Fuzz = f
return q
}
func (q *MatchQuery) MaxExpansions(e uint16) *MatchQuery {
q.params.MaxExp = e
return q
}
func (q *MatchQuery) PrefixLength(l uint16) *MatchQuery {
q.params.PrefLen = l
return q
}
func (q *MatchQuery) Transpositions(b bool) *MatchQuery {
q.params.Trans = &b
return q
}
func (q *MatchQuery) FuzzyRewrite(s string) *MatchQuery {
q.params.FuzzyRw = s
return q
}
func (q *MatchQuery) Lenient(b bool) *MatchQuery {
q.params.Lent = b
return q
}
func (q *MatchQuery) Operator(op MatchOperator) *MatchQuery {
q.params.Op = op
return q
}
func (q *MatchQuery) MinimumShouldMatch(s string) *MatchQuery {
q.params.MinMatch = s
return q
}
func (q *MatchQuery) Slop(n uint16) *MatchQuery {
q.params.Slp = n
return q
}
Refactor API, add aggregations and custom queries This commit introduces a refactor of the codebase and the API, to make it more user friendly. Queries can now directly be executed via the `Run()` method. Internally, the library no longer uses JSON generation as a major mechanism, instead all types need to implement a `Mappable` interface which simply turns each type in a `map[string]interface{}`, which is what the ElasticSearch client expects. This makes the code easier to write, and makes writing tests less error prone, as JSON need not be written directly. Support for metrics aggregations is also added. However, aggregations of type bucket, pipeline and matrix are not supported yet. To make the library more useful in its current state, support is added for running custom queries and aggregations, via the `CustomQuery()` and `CustomAgg()` functions, which both accepts an arbitrary `map[string]interface{}`.
2020-02-19 11:35:21 +00:00
func (q *MatchQuery) ZeroTermsQuery(s ZeroTerms) *MatchQuery {
Initial commit This commit is the initial commit for a Go library providing an idiomatic, easy-to-use query builder for ElasticSearch. The library can build queries and execute them using the structures from the official Go SDK provided by the ES project (https://github.com/elastic/go-elasticsearch). The library currently provides the capabilities to create and execute simple ElasticSearch queries, specifically Match queries (match, match_bool_prefix, match_phrase and match_phrase_prefix), Match All queries (match_all, match_none), and all of the Term-level queries (e.g. range, regexp, etc.). Unit tests are included for each support query, and the code is linted using golangci-lint (see enabled linters in .golangci-lint). The unit tests currently only verify the builder creates valid JSON queries and does not attempt to actually run queries against a (mock) ES instance.
2020-02-18 12:00:15 +00:00
q.params.ZeroTerms = s
return q
}
func (q *MatchQuery) Reader() io.Reader {
var b bytes.Buffer
return &b
}
type MatchOperator uint8
const (
OR MatchOperator = iota
AND
)
Refactor API, add aggregations and custom queries This commit introduces a refactor of the codebase and the API, to make it more user friendly. Queries can now directly be executed via the `Run()` method. Internally, the library no longer uses JSON generation as a major mechanism, instead all types need to implement a `Mappable` interface which simply turns each type in a `map[string]interface{}`, which is what the ElasticSearch client expects. This makes the code easier to write, and makes writing tests less error prone, as JSON need not be written directly. Support for metrics aggregations is also added. However, aggregations of type bucket, pipeline and matrix are not supported yet. To make the library more useful in its current state, support is added for running custom queries and aggregations, via the `CustomQuery()` and `CustomAgg()` functions, which both accepts an arbitrary `map[string]interface{}`.
2020-02-19 11:35:21 +00:00
func (a MatchOperator) String() string {
Initial commit This commit is the initial commit for a Go library providing an idiomatic, easy-to-use query builder for ElasticSearch. The library can build queries and execute them using the structures from the official Go SDK provided by the ES project (https://github.com/elastic/go-elasticsearch). The library currently provides the capabilities to create and execute simple ElasticSearch queries, specifically Match queries (match, match_bool_prefix, match_phrase and match_phrase_prefix), Match All queries (match_all, match_none), and all of the Term-level queries (e.g. range, regexp, etc.). Unit tests are included for each support query, and the code is linted using golangci-lint (see enabled linters in .golangci-lint). The unit tests currently only verify the builder creates valid JSON queries and does not attempt to actually run queries against a (mock) ES instance.
2020-02-18 12:00:15 +00:00
switch a {
case OR:
Refactor API, add aggregations and custom queries This commit introduces a refactor of the codebase and the API, to make it more user friendly. Queries can now directly be executed via the `Run()` method. Internally, the library no longer uses JSON generation as a major mechanism, instead all types need to implement a `Mappable` interface which simply turns each type in a `map[string]interface{}`, which is what the ElasticSearch client expects. This makes the code easier to write, and makes writing tests less error prone, as JSON need not be written directly. Support for metrics aggregations is also added. However, aggregations of type bucket, pipeline and matrix are not supported yet. To make the library more useful in its current state, support is added for running custom queries and aggregations, via the `CustomQuery()` and `CustomAgg()` functions, which both accepts an arbitrary `map[string]interface{}`.
2020-02-19 11:35:21 +00:00
return "or"
Initial commit This commit is the initial commit for a Go library providing an idiomatic, easy-to-use query builder for ElasticSearch. The library can build queries and execute them using the structures from the official Go SDK provided by the ES project (https://github.com/elastic/go-elasticsearch). The library currently provides the capabilities to create and execute simple ElasticSearch queries, specifically Match queries (match, match_bool_prefix, match_phrase and match_phrase_prefix), Match All queries (match_all, match_none), and all of the Term-level queries (e.g. range, regexp, etc.). Unit tests are included for each support query, and the code is linted using golangci-lint (see enabled linters in .golangci-lint). The unit tests currently only verify the builder creates valid JSON queries and does not attempt to actually run queries against a (mock) ES instance.
2020-02-18 12:00:15 +00:00
case AND:
Refactor API, add aggregations and custom queries This commit introduces a refactor of the codebase and the API, to make it more user friendly. Queries can now directly be executed via the `Run()` method. Internally, the library no longer uses JSON generation as a major mechanism, instead all types need to implement a `Mappable` interface which simply turns each type in a `map[string]interface{}`, which is what the ElasticSearch client expects. This makes the code easier to write, and makes writing tests less error prone, as JSON need not be written directly. Support for metrics aggregations is also added. However, aggregations of type bucket, pipeline and matrix are not supported yet. To make the library more useful in its current state, support is added for running custom queries and aggregations, via the `CustomQuery()` and `CustomAgg()` functions, which both accepts an arbitrary `map[string]interface{}`.
2020-02-19 11:35:21 +00:00
return "and"
Initial commit This commit is the initial commit for a Go library providing an idiomatic, easy-to-use query builder for ElasticSearch. The library can build queries and execute them using the structures from the official Go SDK provided by the ES project (https://github.com/elastic/go-elasticsearch). The library currently provides the capabilities to create and execute simple ElasticSearch queries, specifically Match queries (match, match_bool_prefix, match_phrase and match_phrase_prefix), Match All queries (match_all, match_none), and all of the Term-level queries (e.g. range, regexp, etc.). Unit tests are included for each support query, and the code is linted using golangci-lint (see enabled linters in .golangci-lint). The unit tests currently only verify the builder creates valid JSON queries and does not attempt to actually run queries against a (mock) ES instance.
2020-02-18 12:00:15 +00:00
default:
Refactor API, add aggregations and custom queries This commit introduces a refactor of the codebase and the API, to make it more user friendly. Queries can now directly be executed via the `Run()` method. Internally, the library no longer uses JSON generation as a major mechanism, instead all types need to implement a `Mappable` interface which simply turns each type in a `map[string]interface{}`, which is what the ElasticSearch client expects. This makes the code easier to write, and makes writing tests less error prone, as JSON need not be written directly. Support for metrics aggregations is also added. However, aggregations of type bucket, pipeline and matrix are not supported yet. To make the library more useful in its current state, support is added for running custom queries and aggregations, via the `CustomQuery()` and `CustomAgg()` functions, which both accepts an arbitrary `map[string]interface{}`.
2020-02-19 11:35:21 +00:00
return ""
Initial commit This commit is the initial commit for a Go library providing an idiomatic, easy-to-use query builder for ElasticSearch. The library can build queries and execute them using the structures from the official Go SDK provided by the ES project (https://github.com/elastic/go-elasticsearch). The library currently provides the capabilities to create and execute simple ElasticSearch queries, specifically Match queries (match, match_bool_prefix, match_phrase and match_phrase_prefix), Match All queries (match_all, match_none), and all of the Term-level queries (e.g. range, regexp, etc.). Unit tests are included for each support query, and the code is linted using golangci-lint (see enabled linters in .golangci-lint). The unit tests currently only verify the builder creates valid JSON queries and does not attempt to actually run queries against a (mock) ES instance.
2020-02-18 12:00:15 +00:00
}
}
type ZeroTerms uint8
const (
None ZeroTerms = iota
All
)
Refactor API, add aggregations and custom queries This commit introduces a refactor of the codebase and the API, to make it more user friendly. Queries can now directly be executed via the `Run()` method. Internally, the library no longer uses JSON generation as a major mechanism, instead all types need to implement a `Mappable` interface which simply turns each type in a `map[string]interface{}`, which is what the ElasticSearch client expects. This makes the code easier to write, and makes writing tests less error prone, as JSON need not be written directly. Support for metrics aggregations is also added. However, aggregations of type bucket, pipeline and matrix are not supported yet. To make the library more useful in its current state, support is added for running custom queries and aggregations, via the `CustomQuery()` and `CustomAgg()` functions, which both accepts an arbitrary `map[string]interface{}`.
2020-02-19 11:35:21 +00:00
func (a ZeroTerms) String() string {
Initial commit This commit is the initial commit for a Go library providing an idiomatic, easy-to-use query builder for ElasticSearch. The library can build queries and execute them using the structures from the official Go SDK provided by the ES project (https://github.com/elastic/go-elasticsearch). The library currently provides the capabilities to create and execute simple ElasticSearch queries, specifically Match queries (match, match_bool_prefix, match_phrase and match_phrase_prefix), Match All queries (match_all, match_none), and all of the Term-level queries (e.g. range, regexp, etc.). Unit tests are included for each support query, and the code is linted using golangci-lint (see enabled linters in .golangci-lint). The unit tests currently only verify the builder creates valid JSON queries and does not attempt to actually run queries against a (mock) ES instance.
2020-02-18 12:00:15 +00:00
switch a {
case None:
Refactor API, add aggregations and custom queries This commit introduces a refactor of the codebase and the API, to make it more user friendly. Queries can now directly be executed via the `Run()` method. Internally, the library no longer uses JSON generation as a major mechanism, instead all types need to implement a `Mappable` interface which simply turns each type in a `map[string]interface{}`, which is what the ElasticSearch client expects. This makes the code easier to write, and makes writing tests less error prone, as JSON need not be written directly. Support for metrics aggregations is also added. However, aggregations of type bucket, pipeline and matrix are not supported yet. To make the library more useful in its current state, support is added for running custom queries and aggregations, via the `CustomQuery()` and `CustomAgg()` functions, which both accepts an arbitrary `map[string]interface{}`.
2020-02-19 11:35:21 +00:00
return "none"
Initial commit This commit is the initial commit for a Go library providing an idiomatic, easy-to-use query builder for ElasticSearch. The library can build queries and execute them using the structures from the official Go SDK provided by the ES project (https://github.com/elastic/go-elasticsearch). The library currently provides the capabilities to create and execute simple ElasticSearch queries, specifically Match queries (match, match_bool_prefix, match_phrase and match_phrase_prefix), Match All queries (match_all, match_none), and all of the Term-level queries (e.g. range, regexp, etc.). Unit tests are included for each support query, and the code is linted using golangci-lint (see enabled linters in .golangci-lint). The unit tests currently only verify the builder creates valid JSON queries and does not attempt to actually run queries against a (mock) ES instance.
2020-02-18 12:00:15 +00:00
case All:
Refactor API, add aggregations and custom queries This commit introduces a refactor of the codebase and the API, to make it more user friendly. Queries can now directly be executed via the `Run()` method. Internally, the library no longer uses JSON generation as a major mechanism, instead all types need to implement a `Mappable` interface which simply turns each type in a `map[string]interface{}`, which is what the ElasticSearch client expects. This makes the code easier to write, and makes writing tests less error prone, as JSON need not be written directly. Support for metrics aggregations is also added. However, aggregations of type bucket, pipeline and matrix are not supported yet. To make the library more useful in its current state, support is added for running custom queries and aggregations, via the `CustomQuery()` and `CustomAgg()` functions, which both accepts an arbitrary `map[string]interface{}`.
2020-02-19 11:35:21 +00:00
return "all"
Initial commit This commit is the initial commit for a Go library providing an idiomatic, easy-to-use query builder for ElasticSearch. The library can build queries and execute them using the structures from the official Go SDK provided by the ES project (https://github.com/elastic/go-elasticsearch). The library currently provides the capabilities to create and execute simple ElasticSearch queries, specifically Match queries (match, match_bool_prefix, match_phrase and match_phrase_prefix), Match All queries (match_all, match_none), and all of the Term-level queries (e.g. range, regexp, etc.). Unit tests are included for each support query, and the code is linted using golangci-lint (see enabled linters in .golangci-lint). The unit tests currently only verify the builder creates valid JSON queries and does not attempt to actually run queries against a (mock) ES instance.
2020-02-18 12:00:15 +00:00
default:
Refactor API, add aggregations and custom queries This commit introduces a refactor of the codebase and the API, to make it more user friendly. Queries can now directly be executed via the `Run()` method. Internally, the library no longer uses JSON generation as a major mechanism, instead all types need to implement a `Mappable` interface which simply turns each type in a `map[string]interface{}`, which is what the ElasticSearch client expects. This makes the code easier to write, and makes writing tests less error prone, as JSON need not be written directly. Support for metrics aggregations is also added. However, aggregations of type bucket, pipeline and matrix are not supported yet. To make the library more useful in its current state, support is added for running custom queries and aggregations, via the `CustomQuery()` and `CustomAgg()` functions, which both accepts an arbitrary `map[string]interface{}`.
2020-02-19 11:35:21 +00:00
return ""
Initial commit This commit is the initial commit for a Go library providing an idiomatic, easy-to-use query builder for ElasticSearch. The library can build queries and execute them using the structures from the official Go SDK provided by the ES project (https://github.com/elastic/go-elasticsearch). The library currently provides the capabilities to create and execute simple ElasticSearch queries, specifically Match queries (match, match_bool_prefix, match_phrase and match_phrase_prefix), Match All queries (match_all, match_none), and all of the Term-level queries (e.g. range, regexp, etc.). Unit tests are included for each support query, and the code is linted using golangci-lint (see enabled linters in .golangci-lint). The unit tests currently only verify the builder creates valid JSON queries and does not attempt to actually run queries against a (mock) ES instance.
2020-02-18 12:00:15 +00:00
}
}