Struct TermsAggregation

pub struct TermsAggregation { /* private fields */ }

A multi-bucket value source based aggregation where buckets are dynamically built - one per unique value.

https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-bucket-terms-aggregation.html

Implementations

impl TermsAggregation

pub fn size(self, size: u64) -> Self

The size parameter can be set to define how many term buckets should be returned out of the overall terms list.

By default, the node coordinating the search process will request each shard to provide its own top size term buckets and once all shards respond, it will reduce the results to the final list that will then be returned to the client.

This means that if the number of unique terms is greater than size, the returned list is slightly off and not accurate (it could be that the term counts are slightly off and it could even be that a term that should have been in the top size buckets was not returned).

pub fn show_term_doc_count_error(self, show_term_doc_count_error: bool) -> Self

Shows an error value for each term returned by the aggregation which represents the worst case error in the document count and can be useful when deciding on a value for the shard_size parameter. This is calculated by summing the document counts for the last term returned by all shards which did not return the term.

pub fn order<T>(self, order: T) -> Self

where T: Into<TermsOrderCollection>,

The order of the buckets can be customized by setting the order parameter. By default, the buckets are ordered by their doc_count descending. Order field allows changing this behavior.

Sorting by ascending _count or by sub aggregation is discouraged as it increases the error on document counts. It is fine when a single shard is queried, or when the field that is being aggregated was used as a routing key at index time: in these cases results will be accurate since shards have disjoint values. However otherwise, errors are unbounded. One particular case that could still be useful is sorting by min or max aggregation: counts will not be accurate but at least the top buckets will be correctly picked.

pub fn min_doc_count(self, min_doc_count: u16) -> Self

Only returns terms that match more than a configured number of hits using the min_doc_count

Default value is 1

pub fn missing<T>(self, missing: T) -> Self

where T: Serialize,

The missing parameter defines how documents that are missing a value should be treated. By default they will be ignored but it is also possible to treat them as if they had a value.

pub fn include<T>(self, include: T) -> Self

where T: Into<TermsInclude>,

The include parameter can be set to include only specific terms in the response.

pub fn exclude<T>(self, exclude: T) -> Self

where T: Into<TermsExclude>,

The exclude parameter can be set to exclude specific terms from the response.

pub fn script(self, script: Script) -> Self

Sets the script for the aggregation.

pub fn field<T>(self, field: T) -> Self

where T: Into<String>,

The field can be Keyword, Numeric, ip, boolean, or binary.

pub fn aggregate<N, A>(self, aggregation_name: N, aggregation: A) -> Self

where N: Into<AggregationName>, A: Into<Aggregation>,

Pushes aggregation

Trait Implementations

impl Clone for TermsAggregation

fn clone(&self) -> TermsAggregation

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TermsAggregation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<TermsAggregation> for Aggregation

fn from(q: TermsAggregation) -> Self

Converts to this type from the input type.

impl PartialEq for TermsAggregation

fn eq(&self, other: &TermsAggregation) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for TermsAggregation

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for TermsAggregation