versatile-data 0.86.1

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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

#[cfg(test)]
#[test]
fn test() {
    use std::sync::Arc;

    use versatile_data::*;

    let dir = "./vd-test/";
    if std::path::Path::new(dir).exists() {
        std::fs::remove_dir_all(dir).unwrap();
    }
    let mut data = Data::new(dir, DataOption::default());
    let range = 1..=10;
    for i in range.clone() {
        data.update(&Operation::New(Record {
            fields: vec![
                KeyValue::new("num", i.to_string()),
                KeyValue::new("num_by3", (i * 3).to_string()),
                KeyValue::new("num_mod3", (i % 3).to_string()),
            ],
            ..Default::default()
        }));
    }
    let mut sam = 0.0;
    for i in range.clone() {
        sam += data.field_num(i, "num");
        println!(
            "{},{},{},{}",
            data.serial(i),
            std::str::from_utf8(data.field_bytes(i, "num")).unwrap(),
            std::str::from_utf8(data.field_bytes(i, "num_by3")).unwrap(),
            std::str::from_utf8(data.field_bytes(i, "num_mod3")).unwrap()
        );
    }
    assert_eq!(sam, 55.0);

    let r = data
        .search_field("num", search::Field::Range(b"3".to_vec(), b"8".to_vec()))
        .search_default() //Automatic execution of the following two lines
        //.search_term(Term::In(SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs()))
        //.search_activity(Activity::Active)
        .result();
    println!("{:?}", r);

    let r = data
        .search_default()
        .search(Condition::Wide(vec![
            Condition::Field("num".to_string(), search::Field::Match(b"4".to_vec())),
            Condition::Field("num".to_string(), search::Field::Match(b"6".to_vec())),
        ]))
        .result();
    println!("Wide test:{:?}", r);

    let r = data
        .search_default()
        .result_with_sort(vec![Order::Asc(OrderKey::Serial)]);
    println!("sorted-serial:{:?}", r);

    let r=data
            .search_default()
            .result_with_sort(vec![Order::Desc(OrderKey::Field("num".to_owned()))])   //natural order
        ;
    println!("sorted-num-desc:{:?}", r);

    let r = data
        .search_default()
        .result_with_sort(vec![Order::Desc(OrderKey::Field("num_mod3".to_owned()))]);
    println!("sorted-mod3-desc:{:?}", r);

    let r = data.search_default().result_with_sort(vec![
        Order::Asc(OrderKey::Field("num_mod3".to_owned())),
        Order::Asc(OrderKey::Field("num".to_owned())),
    ]);
    println!("sorted mod3-asc num-asc:{:?}", r);

    let r = data.search_default().result_with_sort(vec![
        Order::Asc(OrderKey::Field("num_mod3".to_owned())),
        Order::Desc(OrderKey::Field("num".to_owned())),
    ]);
    println!("sorted mod3-asc num-desc:{:?}", r);

    let r = data
        .search_field("num", search::Field::Range(b"3".to_vec(), b"8".to_vec()))
        .search_row(search::Number::Range(4..=7))
        .search_default()
        .result();
    println!("{:?}", r);

    data.update_field(2, "hoge", b"HAHA");
    data.update_field(4, "hoge", b"agaba");
    data.update_field(5, "hoge", b"agababi");
    data.update_field(1, "hoge", b"ageabe");
    data.update_field(7, "hoge", b"ageee");
    data.update_field(6, "hoge", b"bebebe");
    let r = data
        .search_field("hoge", search::Field::Match(b"HAHA".to_vec()))
        .result();
    println!("match:{:?}", r);

    let r = data
        .search_field("hoge", search::Field::Forward(Arc::new("age".to_string())))
        .result();
    println!("forward:{:?}", r);

    let r = data
        .search_field("hoge", search::Field::Partial(Arc::new("eb".to_string())))
        .result();
    println!("partial:{:?}", r);

    let r = data
        .search_field("hoge", search::Field::Backward(Arc::new("be".to_string())))
        .result();
    println!("backward:{:?}", r);

    let r = data.begin_search().result();
    println!("all:{:?}", r);
}