Enum ValueFilter 

#[non_exhaustive]
pub enum ValueFilter<'a> {
    Range {
        field: &'a [u8],
        min: &'a [u8],
        max: &'a [u8],
    },
    Eq {
        field: &'a [u8],
        value: &'a [u8],
    },
}

One FILTER predicate: which stored value field it reads, and the test on it — the wire’s RANGE / EQ shapes, in-process.

The bounds are raw bytes and are coerced with the type the field was DECLARED as, so a numeric range compares numerically rather than lexicographically.

use kevy_embedded::ValueFilter;

let cheap = ValueFilter::Range { field: b"price", min: b"0", max: b"10" };
assert_ne!(cheap, ValueFilter::Eq { field: b"price", value: b"5" });

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.

Range

field between min and max, both inclusive.

// u:1 (age 30, paid, total 5), u:2 (40, paid, 20), u:3 (50, due, 8)
let f = [ValueFilter::Range { field: b"total", min: b"5", max: b"10" }];
assert_eq!(keys(ScalarQueryOpts::default().with_filters(&f))?, [b"u:1".to_vec(), b"u:3".to_vec()]);

Fields

field: &'a [u8]

The declared value field to read.

// u:1 (age 30, paid, total 5), u:2 (40, paid, 20), u:3 (50, due, 8)
// `total` is declared I64, so the bounds compare as numbers, not bytes
let f = [ValueFilter::Range { field: b"total", min: b"9", max: b"100" }];
assert_eq!(keys(ScalarQueryOpts::default().with_filters(&f))?, [b"u:2".to_vec()]);

min: &'a [u8]

Lower bound, inclusive.

// u:1 (age 30, paid, total 5), u:2 (40, paid, 20), u:3 (50, due, 8)
let f = [ValueFilter::Range { field: b"total", min: b"8", max: b"99" }];
assert_eq!(keys(ScalarQueryOpts::default().with_filters(&f))?.len(), 2, "8 itself is in");

max: &'a [u8]

Upper bound, inclusive.

// u:1 (age 30, paid, total 5), u:2 (40, paid, 20), u:3 (50, due, 8)
let f = [ValueFilter::Range { field: b"total", min: b"0", max: b"8" }];
assert_eq!(keys(ScalarQueryOpts::default().with_filters(&f))?.len(), 2, "8 itself is in");

Eq

field exactly value.

// u:1 (age 30, paid, total 5), u:2 (40, paid, 20), u:3 (50, due, 8)
let f = [ValueFilter::Eq { field: b"status", value: b"due" }];
assert_eq!(keys(ScalarQueryOpts::default().with_filters(&f))?, [b"u:3".to_vec()]);

Fields

field: &'a [u8]

The declared value field to read.

// u:1 (age 30, paid, total 5), u:2 (40, paid, 20), u:3 (50, due, 8)
// a field the index does not store is refused, not read as empty
let f = [ValueFilter::Eq { field: b"email", value: b"x" }];
assert!(keys(ScalarQueryOpts::default().with_filters(&f)).is_err());

value: &'a [u8]

The value to match.

// u:1 (age 30, paid, total 5), u:2 (40, paid, 20), u:3 (50, due, 8)
let f = [ValueFilter::Eq { field: b"total", value: b"20" }];
assert_eq!(keys(ScalarQueryOpts::default().with_filters(&f))?, [b"u:2".to_vec()]);

Trait Implementations

impl<'a> Clone for ValueFilter<'a>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for ValueFilter<'a>

impl<'a> Debug for ValueFilter<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for ValueFilter<'a>

impl<'a> Hash for ValueFilter<'a>

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

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<'a> PartialEq for ValueFilter<'a>

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

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for ValueFilter<'a>