Enum TableEnsure 

#[non_exhaustive]
pub enum TableEnsure {
    Created,
    Unchanged,
}

What table_ensure found (the boot verb — see the embedded docs).

The decision the boot verb makes, in terms of this crate:

use kevy_index::{TableCatalog, TableEnsure, TableSpec, parse_table_declare, spec_diff};

fn ensure(cat: &mut TableCatalog, spec: TableSpec) -> Result<TableEnsure, String> {
    match cat.get(&spec.name) {
        None => {
            cat.create(spec).map_err(|e| e.to_string())?;
            Ok(TableEnsure::Created)
        }
        Some(cur) if cur.sans_auto() == spec => Ok(TableEnsure::Unchanged),
        Some(cur) => Err(spec_diff(cur, &spec)),
    }
}

let decl = |pk: &'static [u8]| {
    parse_table_declare(&[b"TABLE.DECLARE", b"t", b"PREFIX", b"t:", b"PK", pk, b"COLUMN", pk, b"i64"])
};
let mut cat = TableCatalog::new();
assert_eq!(ensure(&mut cat, decl(b"id")?)?, TableEnsure::Created);
assert_eq!(ensure(&mut cat, decl(b"id")?)?, TableEnsure::Unchanged);
assert!(ensure(&mut cat, decl(b"uid")?).is_err());

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.

Created

The table did not exist; it was declared and its indexes built.

use kevy_index::TableEnsure;
// the wire reply a boot path answers with
let reply = |e: TableEnsure| match e {
    TableEnsure::Unchanged => "+UNCHANGED",
    _ => "+OK",
};
assert_eq!(reply(TableEnsure::Created), "+OK");

Unchanged

An identical declaration already exists; nothing was touched.

use kevy_index::TableEnsure;
let first_boot = TableEnsure::Created;
let every_later_boot = TableEnsure::Unchanged;
assert_ne!(first_boot, every_later_boot, "only the first boot builds anything");

Trait Implementations

impl Clone for TableEnsure

fn clone(&self) -> TableEnsure

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for TableEnsure

impl Debug for TableEnsure

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

Formats the value using the given formatter.

impl Eq for TableEnsure

impl Hash for TableEnsure

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 TableEnsure

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for TableEnsure