Enum AggBy 

#[non_exhaustive]
pub enum AggBy {
    Count,
    Sum,
    Min,
    Max,
}

Ranking metric for AggSegment::top_groups.

use kevy_index::AggBy;
assert_eq!(AggBy::default(), AggBy::Count);
assert_eq!(AggBy::parse(b"MAX"), Some(AggBy::Max), "tags are case-insensitive");
assert_eq!(AggBy::parse(b"avg"), None);

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Count

By row count (default).

s.apply(b"o:1", row(b"eu", 30));
s.apply(b"o:2", row(b"eu", 12));
s.apply(b"o:3", row(b"us", 99));
let top = s.top_groups(kevy_index::AggBy::Count, 1);
assert_eq!((top[0].0.as_slice(), top[0].1.count), (&b"eu"[..], 2));

Sum

By sum.

s.apply(b"o:1", row(b"eu", 30));
s.apply(b"o:2", row(b"eu", 12));
s.apply(b"o:3", row(b"us", 99));
let top = s.top_groups(kevy_index::AggBy::Sum, 1);
assert_eq!((top[0].0.as_slice(), top[0].1.sum), (&b"us"[..], 99.0));

Min

By minimum (ascending — smallest mins first).

s.apply(b"o:1", row(b"eu", 30));
s.apply(b"o:2", row(b"eu", 12));
s.apply(b"o:3", row(b"us", 99));
let top = s.top_groups(kevy_index::AggBy::Min, 2);
assert_eq!(top[0].0, b"eu", "12 < 99");

Max

By maximum (descending — largest maxes first).

s.apply(b"o:1", row(b"eu", 30));
s.apply(b"o:2", row(b"eu", 12));
s.apply(b"o:3", row(b"us", 99));
let top = s.top_groups(kevy_index::AggBy::Max, 2);
assert_eq!(top[0].0, b"us", "99 > 30");

Implementations

impl AggBy

pub fn tag(self) -> &'static str

The wire tag, as AggBy::parse reads it.

use kevy_index::AggBy;
assert_eq!(AggBy::parse(AggBy::Sum.tag().as_bytes()), Some(AggBy::Sum));

pub fn parse(raw: &[u8]) -> Option<AggBy>

Wire tag.

Trait Implementations

impl Clone for AggBy

fn clone(&self) -> AggBy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for AggBy

impl Debug for AggBy

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

Formats the value using the given formatter.

impl Default for AggBy

fn default() -> AggBy

Returns the “default value” for a type.

impl Eq for AggBy

impl Hash for AggBy

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for AggBy

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for AggBy