versatile-data 0.50.2

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
118
119
120
121

#[cfg(test)]

#[test]
fn test() {
    use versatile_data::prelude::*;

    let dir="./vd-test/";
    if std::path::Path::new(dir).exists(){
        std::fs::remove_dir_all(dir).unwrap();
    }
    if let Ok(mut data)=Data::new(dir){
        let range=1..=10;
        for i in range.clone(){
            data.update(&Operation::New{
                activity:Activity::Active
                ,term_begin:Term::Defalut
                ,term_end:Term::Defalut
                ,fields:vec![
                    KeyValue::new("num",i.to_string())
                    ,KeyValue::new("num_by3",(i*3).to_string())
                ]
            });
        }
        data.update_activity(3,Activity::Inactive).unwrap();
        let mut sam=0.0;
        for i in range.clone(){
            sam+=data.field_num(i,"num");
            println!(
                "{},{},{},{},{},{},{},{}"
                ,data.serial(i)
                ,if data.activity(i)==Activity::Active{
                    "Active"
                }else{
                    "Inactive"
                }
                ,data.uuid_str(i)
                ,data.last_updated(i)
                ,data.term_begin(i)
                ,data.term_end(i)
                ,std::str::from_utf8(data.field_bytes(i,"num")).unwrap()
                ,std::str::from_utf8(data.field_bytes(i,"num_by3")).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(chrono::Local::now().timestamp()))
            //.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(&Order::Serial)
        ;
        println!("sorted-serial:{:?}",r);

        let r=data
            .search_default() 
            .result_with_sort(&Order::Field("num"))   //natural order
        ;
        println!("sorted-num:{:?}",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").unwrap();
        data.update_field(4,"hoge",b"agaba").unwrap();
        data.update_field(5,"hoge",b"agababi").unwrap();
        data.update_field(1,"hoge",b"ageabe").unwrap();
        data.update_field(7,"hoge",b"ageee").unwrap();
        data.update_field(6,"hoge",b"bebebe").unwrap();
        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("age".to_string()))
            .result()
        ;
        println!("forward:{:?}",r);

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

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

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