Struct OrderPath 

#[non_exhaustive]
pub struct OrderPath {
    pub name: Vec<u8>,
    pub on: Vec<(Vec<u8>, SortOrder)>,
}

One composite-sort path (ORDERPATH — cookbook §8 mechanized): compiles to a composite Range index named <table>.<name>.

use kevy_index::{OrderPath, SortOrder};
let p = OrderPath::new("recent", vec![(b"at".to_vec(), SortOrder::Desc)]);
assert_eq!(p.on[0].1, SortOrder::Desc);

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

name: Vec<u8>

Path name (the compiled index’s suffix).

let t = declare("TABLE.DECLARE t PREFIX t: PK id COLUMN id i64 ORDERPATH newest ON id DESC")?;
assert_eq!(t.orderpaths[0].name, b"newest");
assert_eq!(t.compile()?[0].name(), b"t.newest");

on: Vec<(Vec<u8>, SortOrder)>

(column, direction) in sort-significance order.

let t = declare("TABLE.DECLARE t PREFIX t: PK id COLUMN id i64 COLUMN c str ORDERPATH p ON c THEN id DESC")?;
assert_eq!(t.orderpaths[0].on, [(b"c".to_vec(), SortOrder::Asc), (b"id".to_vec(), SortOrder::Desc)]);

Implementations

impl OrderPath

pub fn new(name: impl Into<Vec<u8>>, on: Vec<(Vec<u8>, SortOrder)>) -> OrderPath

Path name over on, most significant column first.

use kevy_index::{OrderPath, SortOrder};
let p = OrderPath::new("by_city", vec![(b"city".to_vec(), SortOrder::Asc)]);
assert_eq!(p.name, b"by_city");

Trait Implementations

impl Clone for OrderPath

fn clone(&self) -> OrderPath

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OrderPath

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

Formats the value using the given formatter.

impl Eq for OrderPath

impl Hash for OrderPath

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 OrderPath

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for OrderPath