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
80
81
82

use versatile_data::*;

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

async fn insert_n(data: &mut Data, n: u32) {
    let name = FieldName::new("n".into());
    for i in 0..n {
        let fields = [(name.clone(), i.to_string().into_bytes())].into();
        data.insert(Activity::Active, Term::Default, Term::Default, fields)
            .await;
    }
}

#[test]
fn empty_narrow_condition_returns_all_rows() {
    let mut data = new_data("empty-narrow", DataOption::default());
    futures::executor::block_on(async {
        insert_n(&mut data, 3).await;
        let empty = vec![];
        let rows = data
            .begin_search()
            .search(Condition::Narrow(&empty))
            .result()
            .await;
        assert_eq!(rows.len(), 3);
    });
}

#[test]
fn search_row_with_out_of_range_numbers() {
    let mut data = new_data("row-range", DataOption::default());
    futures::executor::block_on(async {
        insert_n(&mut data, 3).await;

        let huge = search::Number::In(vec![-1, 0, 2, 1 << 32, (1 << 32) + 1]);
        let rows = data.begin_search().search_row(&huge).result().await;
        assert_eq!(rows.into_iter().map(|r| r.get()).collect::<Vec<_>>(), [2]);

        let range = search::Number::Range(-10..=isize::MAX);
        let rows = data.begin_search().search_row(&range).result().await;
        assert_eq!(rows.len(), 3);
    });
}

#[test]
fn search_by_disabled_index_returns_nothing() {
    let option = DataOption {
        uuid: false,
        activity: false,
        term: false,
        last_updated: false,
        allocation_lot: 1,
    };
    let mut data = new_data("disabled", option);
    futures::executor::block_on(async {
        insert_n(&mut data, 2).await;

        let uuids = [1u128];
        let uuid = Condition::Uuid(&uuids);
        assert!(data.begin_search().search(uuid).result().await.is_empty());

        let term = Condition::Term(search::Term::default());
        assert!(data.begin_search().search(term).result().await.is_empty());

        let n = search::Number::Min(0);
        let last_updated = Condition::LastUpdated(&n);
        assert!(
            data.begin_search()
                .search(last_updated)
                .result()
                .await
                .is_empty()
        );

        // the default search does not add conditions for disabled indexes.
        assert_eq!(data.search_default().result().await.len(), 2);
    });
}