Struct TableVerify 

#[non_exhaustive]
pub struct TableVerify {
    pub per_index: Vec<IndexVerify>,
    pub spot_rows: u64,
    pub spot_type_mismatches: u64,
}

The whole TABLE.VERIFY answer.

let mut t = kevy_index::TableVerify::default();
t.per_index.push(kevy_index::IndexVerify::new("t.at"));
assert_eq!((t.per_index.len(), t.spot_rows), (1, 0));

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.

per_index: Vec<IndexVerify>

One row per compiled index of the table.

use kevy_index::{IndexVerify, TableVerify, parse_table_declare};
let t = parse_table_declare(&[
    b"TABLE.DECLARE", b"t", b"PREFIX", b"t:", b"PK", b"id", b"COLUMN", b"id", b"i64",
    b"COLUMN", b"at", b"i64", b"INDEX", b"at", b"range", b"INDEX", b"id", b"unique",
])?;
let mut report = TableVerify::default();
report.per_index = t.compile()?.iter().map(|i| IndexVerify::new(i.name())).collect();
assert_eq!(report.per_index.len(), 2);

spot_rows: u64

Rows the bounded column-type spot check sampled this call.

let mut report = kevy_index::TableVerify::default();
(report.spot_rows, report.spot_type_mismatches) = (64, 0);
assert_eq!(report.spot_type_mismatches, 0, "all 64 sampled rows match their types");

spot_type_mismatches: u64

Of those, rows holding a value that contradicts the declared column type.

use kevy_index::{IndexValue, ValType};
let mut report = kevy_index::TableVerify::default();
// a sampled row holds "abc" in a column declared i64
for raw in [&b"1"[..], b"abc"] {
    report.spot_rows += 1;
    if IndexValue::coerce(ValType::I64, raw).is_none() {
        report.spot_type_mismatches += 1;
    }
}
assert_eq!((report.spot_rows, report.spot_type_mismatches), (2, 1));

Trait Implementations

impl Clone for TableVerify

fn clone(&self) -> TableVerify

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TableVerify

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

Formats the value using the given formatter.

impl Default for TableVerify

fn default() -> TableVerify

Returns the “default value” for a type.

impl Eq for TableVerify

impl Hash for TableVerify

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 TableVerify

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for TableVerify