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

use std::num::NonZeroU32;

use versatile_data::*;

async fn insert(data: &mut Data, name: &FieldName, value: &str) -> NonZeroU32 {
    let fields = [(name.clone(), value.as_bytes().to_vec())].into();
    data.insert(Activity::Active, Term::Default, Term::Default, fields)
        .await
}

#[test]
fn deleting_twice_does_not_hand_out_the_same_row_twice() {
    let dir = std::env::temp_dir().join("versatile-data-double-delete");
    let _ = std::fs::remove_dir_all(&dir);
    let mut data = Data::new(&dir, DataOption::default());
    let name = FieldName::new("name".into());

    futures::executor::block_on(async {
        let a = insert(&mut data, &name, "a").await;
        let _b = insert(&mut data, &name, "b").await;

        data.delete(a).await;
        data.delete(a).await;
        // deleting a row that never existed must not create a free row either.
        data.delete(NonZeroU32::new(1000).unwrap()).await;

        let mut rows = vec![_b];
        for value in ["c", "d", "e"] {
            let row = insert(&mut data, &name, value).await;
            assert_ne!(row.get(), 1000, "a row that never existed was reused");
            assert!(!rows.contains(&row), "row {row} was handed out twice");
            rows.push(row);
        }
        assert_eq!(data.field_bytes(rows[1], &name), b"c");
        assert_eq!(data.field_bytes(rows[2], &name), b"d");
        assert_eq!(data.field_bytes(rows[3], &name), b"e");
        assert_eq!(data.all().len(), 4);
    });
}