versatile-data 0.117.0

A library for databases that has convenient datasets that group together commonly used fields and gives you the flexibility to create your own fields.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

use std::num::NonZeroU32;

use hashbrown::HashMap;
use versatile_data::*;

fn new_data(name: &str) -> Data {
    let dir = std::env::temp_dir().join(format!("versatile-data-sort-{name}"));
    let _ = std::fs::remove_dir_all(&dir);
    Data::new(&dir, DataOption::default())
}

async fn insert(data: &mut Data, term_end: Term, fields: &[(&FieldName, &str)]) -> NonZeroU32 {
    let fields: HashMap<FieldName, Vec<u8>> = fields
        .iter()
        .map(|(name, value)| ((*name).clone(), value.as_bytes().to_vec()))
        .collect();
    data.insert(Activity::Active, Term::Default, term_end, fields)
        .await
}

#[test]
fn sort_by_last_updated_uses_last_updated() {
    let mut data = new_data("last-updated");
    let name = FieldName::new("name".into());
    futures::executor::block_on(async {
        // term_end decreases while last_updated increases.
        let r1 = insert(&mut data, Term::Overwrite(300), &[(&name, "a")]).await;
        std::thread::sleep(std::time::Duration::from_millis(1100));
        let r2 = insert(&mut data, Term::Overwrite(200), &[(&name, "b")]).await;
        std::thread::sleep(std::time::Duration::from_millis(1100));
        let r3 = insert(&mut data, Term::Overwrite(100), &[(&name, "c")]).await;

        let rows = data.all();
        let asc = data.sort(&rows, &[Order::Asc(OrderKey::LastUpdated)]);
        assert_eq!(asc, [r1, r2, r3]);
        let desc = data.sort(&rows, &[Order::Desc(OrderKey::LastUpdated)]);
        assert_eq!(desc, [r3, r2, r1]);
    });
}

#[test]
fn sort_by_field_keeps_rows_without_the_field() {
    let mut data = new_data("missing-field");
    let name = FieldName::new("name".into());
    let other = FieldName::new("other".into());
    futures::executor::block_on(async {
        let b = insert(&mut data, Term::Default, &[(&name, "b")]).await;
        let none = insert(&mut data, Term::Default, &[(&other, "x")]).await;
        let a = insert(&mut data, Term::Default, &[(&name, "a")]).await;

        let rows = data.all();
        let asc = data.sort(&rows, &[Order::Asc(OrderKey::Field(name.clone()))]);
        assert_eq!(asc, [a, b, none]);
        let desc = data.sort(&rows, &[Order::Desc(OrderKey::Field(name.clone()))]);
        assert_eq!(desc, [b, a, none]);
    });
}

#[test]
fn sub_sort_by_field_with_rows_without_the_field() {
    let mut data = new_data("missing-sub-field");
    let group = FieldName::new("group".into());
    let name = FieldName::new("name".into());
    futures::executor::block_on(async {
        let none = insert(&mut data, Term::Default, &[(&group, "g")]).await;
        let b = insert(&mut data, Term::Default, &[(&group, "g"), (&name, "b")]).await;
        let a = insert(&mut data, Term::Default, &[(&group, "g"), (&name, "a")]).await;

        let rows = data.all();
        let sorted = data.sort(
            &rows,
            &[
                Order::Asc(OrderKey::Field(group.clone())),
                Order::Asc(OrderKey::Field(name.clone())),
            ],
        );
        assert_eq!(sorted, [a, b, none]);
    });
}