opensearchtools

type ActionError ¶

type ActionError struct {
	Type      string `json:"type"`
	Reason    string `json:"reason"`
	Index     string `json:"index"`
	Shard     string `json:"shard"`
	IndexUUID string `json:"index_uuid"`
}

ActionError encapsulates error responses from OpenSearch on bulk Actions

type ActionResponse ¶

type ActionResponse struct {
	Type        string       `json:"-"`
	Index       string       `json:"_index"`
	ID          string       `json:"_id"`
	Version     uint64       `json:"_version"`
	Result      string       `json:"result"`
	Shards      *ShardMeta   `json:"_shards,omitempty"`
	SeqNo       uint64       `json:"_seq_no"`
	PrimaryTerm uint64       `json:"_primary_term"`
	Status      int          `json:"status"`
	Error       *ActionError `json:"error"`
}

ActionResponse is a domain model union type for all the fields of action responses for all supported OpenSearch versions. Currently supported versions are:

• OpenSearch 2

func (o *ActionResponse) UnmarshalJSON(m []byte) error

type AggregateVersionConverter ¶

type AggregateVersionConverter func(Aggregation) (Aggregation, error)

AggregateVersionConverter takes in a domain model Aggregation and makes any modifications or conversions needed for a specific version of OpenSearch.

type Aggregation ¶

type Aggregation interface {
	// ToOpenSearchJSON converts the Aggregation struct to the expected OpenSearch JSON
	ToOpenSearchJSON() ([]byte, error)

	// Validate that the aggregation is executable
	Validate() ValidationResults
}

Aggregation wraps all aggregation types into a common interface. Facilitating adding aggregations to opensearchtools.SearchRequests and marshaling into OpenSearch JSON.

type AggregationResultSet ¶

type AggregationResultSet interface {
	// GetAggregationResultSource fetches the raw JSON source for the provided name.
	// Returns nil, false if no aggregation response with the name exists.
	GetAggregationResultSource(name string) ([]byte, bool)

	// Keys returns a slice of keys for the list of sub aggregation results
	Keys() []string
}

AggregationResultSet represents a collection of Aggregation responses. This result set exists in two places:

• SearchResponse for a SearchRequest that included aggregations
• [BucketAggregation]s that have added sub aggregations to include.

The result set is characterized by the ability to contain multiple results keyed by the aggregation name.

type BoolQuery ¶

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

BoolQuery combines other queries to form more complex statements. An empty BoolQuery is executable by OpenSearch. Without any constraints it will match on everything.

For more details see https://opensearch.org/docs/latest/opensearch/query-dsl/bool/

func NewBoolQuery() *BoolQuery

func (q *BoolQuery) Filter(queries ...Query) *BoolQuery

func (q *BoolQuery) MinimumShouldMatch(n int) *BoolQuery

func (q *BoolQuery) Must(queries ...Query) *BoolQuery

func (q *BoolQuery) MustNot(queries ...Query) *BoolQuery

func (q *BoolQuery) Should(queries ...Query) *BoolQuery

func (q *BoolQuery) ToOpenSearchJSON() ([]byte, error)

type BucketAggregation ¶

type BucketAggregation interface {
	Aggregation
	// AddSubAggregation to the BucketAggregation for further refinement.
	AddSubAggregation(name string, agg Aggregation) BucketAggregation

	// SubAggregations returns all aggregations added to the BucketAggregation
	SubAggregations() map[string]Aggregation
}

BucketAggregation represents a family of OpenSearch aggregations. Bucket aggregations categorize sets of documents as buckets. The type of bucket aggregation determines whether a given document falls into a bucket or not. Bucket aggregations also support adding nested aggregations to further refine bucket results.

For more details, see https://opensearch.org/docs/latest/opensearch/bucket-agg/

type BucketSortAggregation ¶

type BucketSortAggregation struct {
	// From - the number of buckets to be truncated before returning
	// Negative values will be omitted
	From int

	// Size - the number of buckets to be returned
	// Negative values will be omitted
	Size int

	// Sort for the parent aggregation
	Sort []sort
}

BucketSortAggregation is a [pipeline aggregation] that modifies its parent aggregation by sorting and truncating the results. It does not generate a response itself. An empty BucketSortAggregation will return no results due to the default size of 0.

For more details see https://opensearch.org/docs/latest/opensearch/pipeline-agg/#bucket_sort [pipeline aggregation]: https://opensearch.org/docs/latest/opensearch/pipeline-agg/

func NewBucketSortAggregation() *BucketSortAggregation

func (b *BucketSortAggregation) AddSort(field string, isDesc bool) *BucketSortAggregation

func (b *BucketSortAggregation) ToOpenSearchJSON() ([]byte, error)

func (b *BucketSortAggregation) Validate() ValidationResults

func (b *BucketSortAggregation) WithFrom(from int) *BucketSortAggregation

func (b *BucketSortAggregation) WithSize(size int) *BucketSortAggregation

type Bulk ¶

type Bulk interface {
	Bulk(ctx context.Context, req *BulkRequest) (OpenSearchResponse[BulkResponse], error)
}

Bulk defines a method which knows how to make an OpenSearch Bulk request. It should be implemented by a version-specific executor.

type BulkAction ¶

type BulkAction struct {
	Type BulkActionType
	Doc  RoutableDoc
}

BulkAction is a domain model union type for all actions a BulkRequest can perform across all supported OpenSearch versions. Currently supported versions are:

• OpenSearch 2

While the struct has all the combined fields, only valid fields will be marshaled depending on the type of action. For this reason, it's recommended to use the type constructors:

• NewIndexBulkAction
• NewCreateBulkAction
• NewDeleteBulkAction
• NewUpdateBulkAction

For more details, see https://opensearch.org/docs/latest/api-reference/document-apis/bulk/#request-body

func NewCreateBulkAction(doc RoutableDoc) BulkAction

func NewDeleteBulkAction(index, id string) BulkAction

func NewIndexBulkAction(doc RoutableDoc) BulkAction

func NewUpdateBulkAction(doc RoutableDoc) BulkAction

func (b *BulkAction) MarshalJSONLines() ([][]byte, error)

type BulkActionType ¶

type BulkActionType string

BulkActionType is an enum for the various BulkActionTypes.

const (
	// BulkCreate creates a document if it doesn’t already exist and returns an error otherwise.
	BulkCreate BulkActionType = "create"

	// BulkIndex creates a document if it doesn’t yet exist and replaces the document if it already exists.
	BulkIndex BulkActionType = "index"

	// BulkDelete deletes a document if it exists. If the document doesn’t exist,
	// OpenSearch doesn’t return an error, but instead returns not_found under ActionResponse.Result.
	BulkDelete BulkActionType = "delete"

	// BulkUpdate updates existing documents and returns an error if the document doesn’t exist.
	BulkUpdate BulkActionType = "update"
)

type BulkRequest ¶

type BulkRequest struct {
	// Actions lists the actions to be performed in the BulkRequest
	Actions []BulkAction

	// Refresh determines if the request should wait for a refresh or not
	Refresh Refresh

	// Index determines the entire index for the request
	Index string

	// ParseResponseItemsOnlyOnFailure determines if the bulk response is parsed all the time or only when errors present in the response
	ParseResponseItemsOnlyOnFailure bool
}

BulkRequest is a domain model union type for all the fields of BulkRequests for all supported OpenSearch versions. Currently supported versions are:

• OpenSearch 2

An empty BulkRequest will fail to execute. At least one Action is required to be added.

func NewBulkRequest() *BulkRequest

func (r *BulkRequest) Add(actions ...BulkAction) *BulkRequest

func (r *BulkRequest) WithIndex(index string) *BulkRequest

type BulkResponse ¶

type BulkResponse struct {
	Took   int64
	Errors bool
	Items  []ActionResponse
	Error  *Error
}

BulkResponse is a domain model union response type for BulkRequest for all supported OpenSearch versions. Currently supported versions are:

• OpenSearch 2

Contains a slice of ActionResponse for each individual BulkAction performed by the request.

type DateHistogramAggregation ¶

type DateHistogramAggregation struct {
	// Field to be bucketed
	Field string

	// MinDocCount is the lower count threshold for a bucket to be included in the results.
	// Negative counts will be omitted
	MinDocCount int64

	// Interval string using OpenSearch [date math].
	// [date math]: https://opensearch.org/docs/latest/opensearch/supported-field-types/date/#date-math
	Interval string

	// TimeZone, times are stored internally in UTC and by default date histograms are bucketed in UTC.
	// Set the TimeZone to overwrite this default
	TimeZone string

	// Order list of [Order]s to sort the aggregation buckets. Default order is _count: desc
	Order []Order

	// Aggregations sub aggregations for each bucket. Mapped by string label to sub aggregation
	Aggregations map[string]Aggregation
}

DateHistogramAggregation buckets documents based on a date interval. An empty DateHistogramAggregation will have several issues with execution:

• the target Field must be non-null and non-empty
• the Interval must be non-null and non-empty

For more details see https://opensearch.org/docs/latest/opensearch/bucket-agg/#histogram-date_histogram

func NewDateHistogramAggregation(field, interval string) *DateHistogramAggregation

func (d *DateHistogramAggregation) AddOrder(orders ...Order) *DateHistogramAggregation

func (d *DateHistogramAggregation) AddSubAggregation(name string, agg Aggregation) BucketAggregation

func (d *DateHistogramAggregation) SubAggregations() map[string]Aggregation

func (d *DateHistogramAggregation) ToOpenSearchJSON() ([]byte, error)

func (d *DateHistogramAggregation) Validate() ValidationResults

func (d *DateHistogramAggregation) WithMinDocCount(minCount int64) *DateHistogramAggregation

func (d *DateHistogramAggregation) WithTimeZone(tz string) *DateHistogramAggregation

type DateHistogramAggregationResults ¶

type DateHistogramAggregationResults struct {
	Buckets []DateHistogramBucketResult
}

DateHistogramAggregationResults represents the results from a DateHistogramAggregation request

func (d *DateHistogramAggregationResults) UnmarshalJSON(m []byte) error

type DateHistogramBucketResult ¶

type DateHistogramBucketResult struct {
	KeyString             string
	Key                   int64
	DocCount              int64
	SubAggregationResults map[string]json.RawMessage
}

DateHistogramBucketResult is a [AggregationResultMap] for a DateHistogramAggregation

func (d *DateHistogramBucketResult) GetAggregationResultSource(name string) ([]byte, bool)

func (d *DateHistogramBucketResult) Keys() []string

func (d *DateHistogramBucketResult) UnmarshalJSON(m []byte) error

type DateRangeAggregation ¶

type DateRangeAggregation struct {
	// Field to be targeted
	Field string

	// Ranges - list of range buckets
	Ranges []Range

	// Format - the date format for the [RangeBucketResult.FromString] and
	// [RangeBucketResult.ToString] in the results
	Format string

	// Aggregations sub aggregations for each bucket. Mapped by string label to sub aggregation
	Aggregations map[string]Aggregation
}

DateRangeAggregation is conceptually the same as the RangeAggregation, except that it lets you perform date math and format the date strings. An empty DateDateRangeAggregation will have some issues with execution

func NewDateRangeAggregation(field string) *DateRangeAggregation

func (dr *DateRangeAggregation) AddKeyedRange(key string, from, to any) *DateRangeAggregation

func (dr *DateRangeAggregation) AddRange(from, to any) *DateRangeAggregation

func (dr *DateRangeAggregation) AddRanges(ranges ...Range) *DateRangeAggregation

func (dr *DateRangeAggregation) AddSubAggregation(name string, agg Aggregation) BucketAggregation

func (dr *DateRangeAggregation) SubAggregations() map[string]Aggregation

func (dr *DateRangeAggregation) ToOpenSearchJSON() ([]byte, error)

func (dr *DateRangeAggregation) Validate() ValidationResults

func (dr *DateRangeAggregation) WithFormat(format string) *DateRangeAggregation

type DateRangeAggregationResults ¶

type DateRangeAggregationResults struct {
	Buckets []RangeBucketResult `json:"buckets"`
}

DateRangeAggregationResults represents the results from a range aggregation request.

type DocumentRef ¶

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

DocumentRef references a document via its index and id. It is the most basic implementation of RoutableDoc.

func NewDocumentRef(index, id string) DocumentRef

func (d DocumentRef) ID() string

func (d DocumentRef) Index() string

type DocumentResult ¶

type DocumentResult interface {
	// GetSource returns the raw bytes of the document
	GetSource() []byte
}

DocumentResult defines any OpenSearch response that contains a document source.

type Error ¶

type Error struct {
	RootCause    []Error
	Type         string
	Reason       string
	Index        string
	ResourceID   string
	ResourceType string
	IndexUUID    string
}

Error encapsulates an error response from a given OpenSearch request.

type ExistsQuery ¶

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

ExistsQuery searches for documents that contain a specific field.

For more details see https://opensearch.org/docs/latest/opensearch/query-dsl/term/#exists

func NewExistsQuery(field string) *ExistsQuery

func (q *ExistsQuery) ToOpenSearchJSON() ([]byte, error)

type FilterAggregation ¶

type FilterAggregation struct {
	// Filter to be applied to the document set before aggregating
	Filter Query

	// Aggregations to be performed on the reduced set
	Aggregations map[string]Aggregation
}

FilterAggregation is a query clause, exactly like a search query. You can use the FilterAggregation to narrow down the entire set of documents to a specific set before creating buckets. An empty FilterAggregation will fail to execute as a filter is required.

For more details see https://opensearch.org/docs/latest/opensearch/bucket-agg/#filter-filters

func NewFilterAggregation(filter Query) *FilterAggregation

func (f *FilterAggregation) AddSubAggregation(name string, agg Aggregation) BucketAggregation

func (f *FilterAggregation) SubAggregations() map[string]Aggregation

func (f *FilterAggregation) ToOpenSearchJSON() ([]byte, error)

func (f *FilterAggregation) Validate() ValidationResults

type FilterAggregationResults ¶

type FilterAggregationResults struct {
	DocCount              uint64
	SubAggregationResults map[string]json.RawMessage
}

FilterAggregationResults is a [AggregationResultMap] for a FilterAggregation

func (f *FilterAggregationResults) GetAggregationResultSource(name string) ([]byte, bool)

func (f *FilterAggregationResults) Keys() []string

func (f *FilterAggregationResults) UnmarshalJSON(m []byte) error

type Hit ¶

type Hit struct {
	Index  string
	ID     string
	Score  float64
	Source json.RawMessage
}

Hit is a domain model union response type across all supported OpenSearch versions. Currently supported versions are:

-OpenSearch2

Hit the individual document found by the `[Query] performed by the SearchRequest.

func (h Hit) GetSource() []byte

type Hits ¶

type Hits struct {
	// Total documents that matched the query.
	Total Total

	// MaxScore max score of all matching documents
	MaxScore float64

	// Hits slice of documents matched by the [Query]
	Hits []Hit
}

Hits is a domain model union response type across all supported OpenSearch versions. Currently supported versions are:

-OpenSearch2

Hits are the list of documents hit from the executed Query.

type MGet ¶

type MGet interface {
	MGet(ctx context.Context, req *MGetRequest) (OpenSearchResponse[MGetResponse], error)
}

MGet defines a method which knows how to make an OpenSearch Multi-get request. It should be implemented by a version-specific executor.

type MGetRequest ¶

type MGetRequest struct {
	// Index destination for entire request
	// if used individual documents don't need to specify the index
	Index string

	// Docs are the list of documents to be fetched.
	Docs []RoutableDoc
}

MGetRequest is a domain model union type for all the fields of a Multi-Get request for all supported OpenSearch versions. Currently supported versions are:

• OpenSearch 2

This MGetRequest is intended to be used along with a version-specific executor such as opensearchtools/osv2.Executor. For example:

mgetReq := NewMGetRequest().
	Add("example_index", "example_id")
mgetResp, err := osv2Executor.MGet(ctx, mgetReq)

An error can be returned if

• The request to OpenSearch fails
• The results json cannot be unmarshalled

func NewMGetRequest() *MGetRequest

func (m *MGetRequest) Add(index, id string) *MGetRequest

func (m *MGetRequest) AddDocs(docs ...RoutableDoc) *MGetRequest

func (m *MGetRequest) WithIndex(index string) *MGetRequest

type MGetResponse ¶

type MGetResponse struct {
	Docs []MGetResult
}

MGetResponse is a domain model union response type for Multi-Get for all supported OpenSearch versions. Currently supported versions are:

• OpenSearch 2

Contains a slice of MGetResult for each document in the response.

type MGetResult ¶

type MGetResult struct {
	Index       string
	ID          string
	Version     int
	SeqNo       int
	PrimaryTerm int
	Found       bool
	Source      json.RawMessage
	Error       error
}

MGetResult is a domain model union type representing an individual document result in for a request item in a Multi-Get response for all supported OpenSearch versions. Currently supported versions are:

• OpenSearch 2

func (m MGetResult) GetSource() []byte

type MatchAllQuery ¶

type MatchAllQuery struct {
}

MatchAllQuery returns all documents.

For more details see https://opensearch.org/docs/latest/opensearch/query-dsl/full-text/#match-all

func NewMatchAllQuery() *MatchAllQuery

func (q *MatchAllQuery) ToOpenSearchJSON() ([]byte, error)

type MatchPhraseQuery ¶

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

MatchPhraseQuery finds document that match documents that contain an exact phrase in a specified order. An empty MatchPhraseQuery will be rejected by OpenSearch for two reasons:

• a field must not be empty or null
• a value must be non-null

For more details see https://opensearch.org/docs/latest/opensearch/query-dsl/full-text/#match-phrase

func NewMatchPhraseQuery(field, phrase string) *MatchPhraseQuery

func (q *MatchPhraseQuery) ToOpenSearchJSON() ([]byte, error)

type MatchQuery ¶

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

MatchQuery finds documents that matches the analyzed string value.

For more details see https://opensearch.org/docs/latest/opensearch/query-dsl/full-text/#match

func NewMatchQuery(field, value string) *MatchQuery

func (q *MatchQuery) SetOperator(op string) *MatchQuery

func (q *MatchQuery) ToOpenSearchJSON() ([]byte, error)

type NestedQuery ¶ added in v0.4.0

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

NestedQuery is a type of joining query that allows searches in fields that are of the `nested` type. An empty NestedQuery will be rejected by OpenSearch for two reasons:

• a path must not be nil or empty
• a query must not be nil

For more details see https://opensearch.org/docs/latest/query-dsl/

func NewNestedQuery(path string, query Query) *NestedQuery

func (q *NestedQuery) ToOpenSearchJSON() ([]byte, error)

type OpenSearchResponse ¶

type OpenSearchResponse[T any] struct {
	ValidationResults ValidationResults
	StatusCode        int
	Header            http.Header
	Response          T
}

OpenSearchResponse is a generic return type for an OpenSearch query which has meta fields common to all response types as well as a generic Response field abstract across all response types.

func NewOpenSearchResponse[T any](vrs ValidationResults, statusCode int, header http.Header, response T) OpenSearchResponse[T]

type Order ¶

type Order struct {
	Target string
	Desc   bool
}

Order encapsulates the sorting capabilities for Aggregation requests to OpenSearch. An empty Order will be rejected by OpenSearch as the target must be non-nil and non-empty

func NewOrder(field string, desc bool) Order

func (o Order) ToOpenSearchJSON() ([]byte, error)

type PercentilesAggregation ¶

type PercentilesAggregation struct {
	// Field to be bucketed
	Field string
}

PercentilesAggregation is the percentage of the data that’s at or below a certain threshold value. An empty PercentilesAggregation will have some issues with execution:

• the target Field must be non-nil and non-empty.

For more details see https://opensearch.org/docs/latest/opensearch/metric-agg/#percentile-percentile_ranks

func NewPercentileAggregation(field string) *PercentilesAggregation

func (p *PercentilesAggregation) ToOpenSearchJSON() ([]byte, error)

func (p *PercentilesAggregation) Validate() ValidationResults

type PercentilesAggregationResult ¶ added in v0.2.0

type PercentilesAggregationResult struct {
	P1        *float64
	P1String  string
	P5        *float64
	P5String  string
	P25       *float64
	P25String string
	P50       *float64
	P50String string
	P75       *float64
	P75String string
	P95       *float64
	P95String string
	P99       *float64
	P99String string
}

PercentilesAggregationResult will contain all percentiles or no percentiles. If there are no values for the percentile, it will be omitted

func (p *PercentilesAggregationResult) UnmarshalJSON(b []byte) error

type PrefixQuery ¶

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

PrefixQuery finds documents that contain the value as a prefix. An empty PrefixQuery will be rejected by OpenSearch for two reasons:

• a field must not be empty or null
• a value must be non-null

For more details see https://opensearch.org/docs/latest/opensearch/query-dsl/term/#prefix

func NewPrefixQuery(field string, value any) *PrefixQuery

func (q *PrefixQuery) ToOpenSearchJSON() ([]byte, error)

type PtrTo ¶

type PtrTo[T any] interface {
	*T
}

PtrTo is a generic constraint that restricts value to be pointers. T can be any type.

type Query ¶

type Query interface {
	// ToOpenSearchJSON converts the Query struct to the expected OpenSearch JSON
	ToOpenSearchJSON() ([]byte, error)
}

Query wraps all query types in a common interface. Facilitating a common pattern to convert the logical struct into the appropriate request JSON.

func BoolQueryConverter(boolQuery *BoolQuery, converter QueryVersionConverter) (Query, error)

type QueryVersionConverter ¶

type QueryVersionConverter func(Query) (Query, error)

QueryVersionConverter takes in a domain model Query and makes any modifications or conversions needed for a specific version of OpenSearch

type Range ¶

type Range struct {
	// Key label for the range bucket. If one is not provided
	// OpenSearch defaults to "{From}-{To}
	Key string `json:"key,omitempty"`

	// From - lower inclusive bound of the range
	From any `json:"from,omitempty"`

	// To - upper exclusive bound of the range
	To any `json:"to,omitempty"`
}

type RangeAggregation ¶

type RangeAggregation struct {
	// Field to be targeted
	Field string

	// Ranges - list of range buckets
	Ranges []Range

	// Aggregations sub aggregations for each bucket. Mapped by string label to sub aggregation
	Aggregations map[string]Aggregation
}

RangeAggregation lets you manually define each bucket, and it's range. An empty RangeAggregation will have some issues with execution:

• the target Field must be non-nil and non-empty
• the aggregation must have at least one Range defined

For more details see https://opensearch.org/docs/latest/opensearch/bucket-agg/#range-date_range-ip_range

func NewRangeAggregation(field string) *RangeAggregation

func (r *RangeAggregation) AddKeyedRange(key string, from, to any) *RangeAggregation

func (r *RangeAggregation) AddRange(from, to any) *RangeAggregation

func (r *RangeAggregation) AddRanges(ranges ...Range) *RangeAggregation

func (r *RangeAggregation) AddSubAggregation(name string, agg Aggregation) BucketAggregation

func (r *RangeAggregation) SubAggregations() map[string]Aggregation

func (r *RangeAggregation) ToOpenSearchJSON() ([]byte, error)

func (r *RangeAggregation) Validate() ValidationResults

type RangeAggregationResults ¶

type RangeAggregationResults struct {
	Buckets []RangeBucketResult `json:"buckets"`
}

RangeAggregationResults represents the results from a range aggregation request.

type RangeBucketResult ¶

type RangeBucketResult struct {
	// Key - the bucket label
	Key string

	// From - the lower inclusive bound of the bucket.
	// It will match the type of the [Range.From] in the request.
	From any

	// FromString - if the [Range.From] was not a string,
	// a string representation will also be included
	FromString string

	// To - the upper exclusive bound of the bucket.
	// It will match the type of the [Range.To] in the request.
	To any

	// ToString - if the [Range.To] was not a string,
	// a string representation will also be included
	ToString string

	// DocCount - number of documents that fit in this bucket
	DocCount int64

	// SubAggregationResults for any nested aggregations
	SubAggregationResults map[string]json.RawMessage
}

RangeBucketResult is a [AggregationResultMap] for a RangeAggregation

func (r *RangeBucketResult) GetAggregationResultSource(name string) ([]byte, bool)

func (r *RangeBucketResult) Keys() []string

func (r *RangeBucketResult) UnmarshalJSON(m []byte) error

type RangeQuery ¶

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

RangeQuery allows you to search on a targeted field matching a defined range. An empty RangeQuery will be rejected by OpenSearch as it requires a non-null and non-empty field.

For more details see https://opensearch.org/docs/latest/opensearch/query-dsl/term/#range-query

func NewRangeQuery(field string) *RangeQuery

func (q *RangeQuery) Gt(value any) *RangeQuery

func (q *RangeQuery) Gte(value any) *RangeQuery

func (q *RangeQuery) Lt(value any) *RangeQuery

func (q *RangeQuery) Lte(value any) *RangeQuery

func (q *RangeQuery) ToOpenSearchJSON() ([]byte, error)

type Refresh ¶

type Refresh string

Refresh is a common query parameter across OpenSearch write requests

More details can be found on https://opensearch.org/docs/latest/api-reference/document-apis/bulk/

const (
	// True - make the write operation immediately available for search
	True Refresh = "true"
	// False - default, do not wait for the write operation to be available for search
	False Refresh = "false"
	// WaitFor - waits for the normal index refresh to make the write operation searchable
	WaitFor Refresh = "wait_for"
)

type RegexQuery ¶

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

RegexQuery allows you to search on a targeted field matching on values that fit the regular expression. An empty Regex will be rejected by OpenSearch for two reasons:

• a field must not be empty or null
• a value must be non-null

For more details see https://opensearch.org/docs/latest/opensearch/query-dsl/term/#regex

func NewRegexQuery(field, regex string) *RegexQuery

func (q *RegexQuery) ToOpenSearchJSON() ([]byte, error)

type RoutableDoc ¶

type RoutableDoc interface {
	// Index returns the index the document should be routed to
	Index() string
	// ID returns the document ID
	ID() string
}

RoutableDoc interface defines an OpenSearch document that can be routed to a specific index. The most basic implementation is DocumentRef.

type Search ¶

type Search interface {
	Search(ctx context.Context, req *SearchRequest) (OpenSearchResponse[SearchResponse], error)
}

Search defines a method which knows how to make an OpenSearch Search request. It should be implemented by a version-specific executor.

type SearchRequest ¶

type SearchRequest struct {
	// Query to be performed by the search
	Query Query

	// Index(s) to be targeted by the search
	Index []string

	// Size of results to be returned
	Size int

	// From the starting index to search from
	From int

	// Sort(s) to order the results returned
	Sort []Sort

	// TrackTotalHits - whether to return how many documents matched the query.
	TrackTotalHits any

	// Routing - Values used to route the update by query operation to a specific shard
	Routing []string

	// Aggregations to be performed on the results of the Query
	Aggregations map[string]Aggregation
}

SearchRequest is a domain model union type for all the fields of a Search request across all supported OpenSearch versions. Currently supported versions are:

• OpenSearch 2

This SearchRequest is intended to be used along with a version-specific executor such as opensearchtools/osv2.Executor. For example:

searchReq := NewSearchRequest().
	WithQuery(NewTermQuery("field", "term"))
searchResp, err := osv2Executor.Search(ctx, searchReq)

An error can be returned if

• The request to OpenSearch fails
• The results json cannot be unmarshalled

func NewSearchRequest() *SearchRequest

func (r *SearchRequest) AddAggregation(name string, agg Aggregation) *SearchRequest

func (r *SearchRequest) AddIndices(indices ...string) *SearchRequest

func (r *SearchRequest) AddSorts(sort ...Sort) *SearchRequest

func (r *SearchRequest) WithFrom(n int) *SearchRequest

func (r *SearchRequest) WithQuery(q Query) *SearchRequest

func (r *SearchRequest) WithRouting(routing ...string) *SearchRequest

func (r *SearchRequest) WithSize(n int) *SearchRequest

func (r *SearchRequest) WithTrackTotalHits(track any) *SearchRequest

type SearchResponse ¶

type SearchResponse struct {
	// Took the time in Milliseconds OpenSearch took to execute the query
	Took int

	// TimedOut true if the request timed out
	TimedOut bool

	// Shards [ShardMeta] counts of the shards used in the request processing
	Shards ShardMeta

	// Hits are the results of the [Query]
	Hits Hits

	// Error if OpenSearch failed but responded with errors
	Error *Error

	// Aggregations response if any were requested
	Aggregations map[string]json.RawMessage
}

SearchResponse is a domain model union response type across all supported OpenSearch versions. Currently supported versions are:

-OpenSearch2

func (sr SearchResponse) GetAggregationResultSource(name string) ([]byte, bool)

func (sr SearchResponse) Keys() []string

type ShardMeta ¶

type ShardMeta struct {
	Total      int
	Successful int
	Skipped    int
	Failed     int
}

ShardMeta contains information about the shards used or interacted with to perform a given OpenSearch Request.

type SingleValueAggType ¶

type SingleValueAggType string

SingleValueAggType represents valid single value metric aggregations

type SingleValueAggregationResult ¶

type SingleValueAggregationResult struct {
	// Value will return nil if not metrics were aggregated
	Value *float64 `json:"value,omitempty"`

	// ValueString is optional depending on the field type of the value being aggregated
	ValueString string `json:"value_as_string,omitempty"`
}

SingleValueAggregationResult union of the single-value metric aggregations results.

type SingleValueMetricAggregation ¶

type SingleValueMetricAggregation struct {
	// Type of metric aggregation to be performed
	Type SingleValueAggType

	// Field to be bucketed
	Field string

	// PrecisionThreshold is used only for CardinalityAggregation. It defines the
	// threshold below which counts are expected to be close to accurate.
	// Negative values will be omitted
	PrecisionThreshold int

	// Missing is used to define how documents missing the target field should be treated.
	// The value of Missing is substituted for the document.
	Missing any
}

SingleValueMetricAggregation is a union of the single-value metric aggregations.

• Cardinality
• Sum
• Min
• Max
• Average

Metric aggregations let you perform simple calculations on values of a field. An empty SingleValueMetricAggregation will have some issues with execution:

• the target Field must be non-nil and non-empty
• the Type field must be non-empty and matching a SingleValueAggType

For more details see https://opensearch.org/docs/latest/opensearch/metric-agg

func NewAverageAggregation(field string) *SingleValueMetricAggregation

func NewCardinalityAggregation(field string) *SingleValueMetricAggregation

func NewMaximumAggregation(field string) *SingleValueMetricAggregation

func NewMinimumAggregation(field string) *SingleValueMetricAggregation

func NewSumAggregation(field string) *SingleValueMetricAggregation

func (s *SingleValueMetricAggregation) ToOpenSearchJSON() ([]byte, error)

func (s *SingleValueMetricAggregation) Validate() ValidationResults

func (s *SingleValueMetricAggregation) WithMissing(missing any) *SingleValueMetricAggregation

func (s *SingleValueMetricAggregation) WithPrecisionThreshold(p int) *SingleValueMetricAggregation

type Sort ¶

type Sort struct {
	Field string
	Desc  bool
}

Sort encapsulates the sort capabilities for OpenSearch. An empty Sort will be rejected by OpenSearch as a field must be non-null and non-empty.

For more details see https://opensearch.org/docs/latest/opensearch/search/sort/

func NewSort(field string, desc bool) Sort

func (s *Sort) ToOpenSearchJSON() ([]byte, error)

type TermBucketResult ¶

type TermBucketResult struct {
	Key                   string
	DocCount              int64
	SubAggregationResults map[string]json.RawMessage
}

TermBucketResult is a [AggregationResultMap] for a TermsAggregation

func (t *TermBucketResult) GetAggregationResultSource(name string) ([]byte, bool)

func (t *TermBucketResult) Keys() []string

func (t *TermBucketResult) UnmarshalJSON(m []byte) error

type TermQuery ¶

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

TermQuery finds documents that have the field matching the exact value. An empty TermQuery will be rejected by OpenSearch for two reasons:

• a field must not be empty or null
• a value must be non-null

For more details see https://opensearch.org/docs/latest/opensearch/query-dsl/term/

func NewTermQuery(field string, value any) *TermQuery

func (q *TermQuery) ToOpenSearchJSON() ([]byte, error)

type TermsAggregation ¶

type TermsAggregation struct {
	// Field to be bucketed
	Field string

	// Size of the number of buckets to be returned. Negative sizes will be omitted
	Size int

	// MinDocCount is the lower count threshold for a bucket to be included in the results.
	// Negative counts will be omitted
	MinDocCount int64

	// Missing counts documents that are missing the field being aggregated
	Missing string

	// Include filters values based on a regexp, Include cannot be used in tandem with IncludeValues
	Include string

	// IncludeValues filters values base on a list of exact matches,
	// IncludeValues cannot be used in tandem with Include
	IncludeValues []string

	// Exclude filters values based on a regexp, Exclude cannot be used in tandem with ExcludeValues
	Exclude string

	// ExcludeValues filters values base on a list of exact matches,
	// ExcludeValues cannot be used in tandem with Exclude
	ExcludeValues []string

	// Order list of [Order]s to sort the aggregation buckets. Default order is _count: desc
	Order []Order

	// Aggregations sub aggregations for each bucket. Mapped by string label to sub aggregation
	Aggregations map[string]Aggregation
}

TermsAggregation dynamically creates a bucket for each unique term of a field. An empty TermsAggregation will have some issues with execution:

• the target Field must be non-nil and non-empty.
• a Size of 0 will return no buckets

For more details see https://opensearch.org/docs/latest/opensearch/bucket-agg/

func NewTermsAggregation(field string) *TermsAggregation

func (t *TermsAggregation) AddOrder(orders ...Order) *TermsAggregation

func (t *TermsAggregation) AddSubAggregation(name string, agg Aggregation) BucketAggregation

func (t *TermsAggregation) SubAggregations() map[string]Aggregation

func (t *TermsAggregation) ToOpenSearchJSON() ([]byte, error)

func (t *TermsAggregation) Validate() ValidationResults

func (t *TermsAggregation) WithExclude(exclude string) *TermsAggregation

func (t *TermsAggregation) WithExcludes(excludes []string) *TermsAggregation

func (t *TermsAggregation) WithInclude(include string) *TermsAggregation

func (t *TermsAggregation) WithIncludes(include []string) *TermsAggregation

func (t *TermsAggregation) WithMinDocCount(minCount int64) *TermsAggregation

func (t *TermsAggregation) WithMissing(missing string) *TermsAggregation

func (t *TermsAggregation) WithSize(size int) *TermsAggregation

type TermsAggregationResults ¶

type TermsAggregationResults struct {
	DocCountErrorUpperBound int64
	SumOtherDocCount        int64
	Buckets                 []TermBucketResult
}

TermsAggregationResults represents the results from a terms aggregation request.

func (t *TermsAggregationResults) UnmarshalJSON(m []byte) error

type TermsQuery ¶

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

TermsQuery finds documents that have the field match one of the listed values. An empty TermsQuery will be rejected by OpenSearch for two reasons:

• a field must not be empty or null
• a value must be non-null

For more details see https://opensearch.org/docs/latest/opensearch/query-dsl/term/#terms

func NewTermsQuery(field string, values ...any) *TermsQuery

func (q *TermsQuery) ToOpenSearchJSON() ([]byte, error)

type Total ¶

type Total struct {
	Value    int64
	Relation string
}

Total is a domain model union response type across all supported OpenSearch versions. Currently supported versions are:

-OpenSearch2

Total contains the total number of documents found by the Query performed by the SearchRequest.

type ValidationError ¶

type ValidationError struct {
	ValidationResults ValidationResults
}

ValidationError is an error which contains ValidationResults

func NewValidationError(vrs ValidationResults) *ValidationError

func (e *ValidationError) Error() string

type ValidationResult ¶

type ValidationResult struct {
	Message string
	Fatal   bool
}

ValidationResult is an individual validation result item to be returned by a [ValidateForVersion] call.

func NewValidationResult(message string, fatal bool) ValidationResult

type ValidationResults ¶

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

A collection of ValidationResults that implements set logic, meaning it holds unique entries only (no duplicates)

func NewValidationResults() ValidationResults

func ValidationResultsFromSlice(vrs []ValidationResult) ValidationResults

func (vrs *ValidationResults) Add(vr ValidationResult)

func (vrs *ValidationResults) Extend(other ValidationResults)

func (vrs *ValidationResults) IsFatal() bool

func (vrs *ValidationResults) Len() int

type Validator ¶

type Validator interface {
	Validate() ValidationResults
}

Validator defines the behavior for validating a domain model object.

type WildcardQuery ¶

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

WildcardQuery searches for documents with a field matching a wildcard pattern. An empty TermQuery will be rejected by OpenSearch for two reasons:

• a field must not be empty or null
• a value must be non-null

For more details see https://opensearch.org/docs/latest/opensearch/query-dsl/term/#wildcards

func NewWildcardQuery(field, value string) *WildcardQuery

func (q *WildcardQuery) ToOpenSearchJSON() ([]byte, error)