textdb 0.1.0

A high performance read only text database
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

use textdb::{accessor, maps, Table};

#[test]
fn test_tsv_text() {
    type Res<'a> = Result<Vec<&'a str>, std::str::Utf8Error>;
    let accessor = accessor::TsvText::<0>::default();

    let map = maps::SafeMemoryMap::from_str("A\nB\nC");
    let textdb = Table::new(map, accessor);
    assert_eq!(textdb.keys().collect::<Res>().unwrap(), ["A", "B", "C"]);
    assert_eq!(textdb.cols(0).collect::<Res>().unwrap(), ["A", "B", "C"]);
    assert_eq!(textdb.cols(1).collect::<Res>().unwrap(), ["", "", ""]);

    assert!(textdb.is_sorted().unwrap());

    let map = maps::SafeMemoryMap::from_str("A\nB\nC\n");
    let textdb = Table::new(map, accessor);
    assert!(textdb.is_sorted().unwrap());
    assert_eq!(textdb.keys().collect::<Res>().unwrap(), ["A", "B", "C"]);
    assert_eq!(textdb.cols(1).collect::<Res>().unwrap(), ["", "", ""]);

    let map = maps::SafeMemoryMap::from_str("B\nA\nC");
    let textdb = Table::new(map, accessor);
    assert_eq!(textdb.cols(1).collect::<Res>().unwrap(), ["", "", ""]);

    assert!(!textdb.is_sorted().unwrap());
    assert_eq!(textdb.keys().collect::<Res>().unwrap(), ["B", "A", "C"]);
    assert_eq!(textdb.cols(0).collect::<Res>().unwrap(), ["B", "A", "C"]);
    assert_eq!(textdb.cols(1).collect::<Res>().unwrap(), ["", "", ""]);

    let map = maps::SafeMemoryMap::from_str("A\t1\nB\t2\nC\t3");
    let textdb = Table::new(map, accessor);

    assert!(textdb.is_sorted().unwrap());
    assert_eq!(textdb.keys().collect::<Res>().unwrap(), ["A", "B", "C"]);
    assert_eq!(textdb.cols(0).collect::<Res>().unwrap(), ["A", "B", "C"]);
    assert_eq!(textdb.cols(1).collect::<Res>().unwrap(), ["1", "2", "3"]);
}
#[test]

fn test_tsv_parse() {
    // Not sorted by text
    let accessor = accessor::TsvText::<0>::default();
    let map = maps::SafeMemoryMap::from_str("10\n0100\n");
    let textdb = Table::new(map, accessor);
    assert!(!textdb.is_sorted().unwrap());

    // Sorted by number
    let accessor = accessor::TsvParse::<u32, 0>::default();
    let map = maps::SafeMemoryMap::from_str("10\n0100\n");
    let textdb = Table::new(map, accessor);
    assert!(textdb.is_sorted().unwrap());
}

#[test]
fn test_get_matching_lines_a() {
    let text = "A\nB\nC\nC\nD\nE\nF\nF\nF\nF\nF\nG\nH\nI\nJ\nK\nL\n";
    let textdb = Table::text_tsv_from_str(text);

    assert!(textdb.is_sorted().unwrap());

    assert_eq!(textdb.get_matching_lines("F".as_bytes()).count(), 5);
    assert_eq!(textdb.get_matching_lines("C".as_bytes()).count(), 2);
}

#[test]
fn test_get_matching_lines_b() {
    let text = "F\nF\nF\nF\nF\n";
    let textdb = Table::text_tsv_from_str(text);

    assert!(textdb.is_sorted().unwrap());

    assert_eq!(textdb.get_matching_lines("F".as_bytes()).count(), 5);
}

#[test]
fn test_get_matching_lines_1() {
    let kv = [(6, 6), (10, 1), (113, 2), (113, 5), (129, 3), (140, 0), (168, 7), (205, 9), (211, 8), (215, 4)];
    let text = kv.iter().map(|(k, v)| format!("{k}\t{v}")).collect::<Vec<_>>().join("\n");
    let accessor = accessor::TsvParse::<u8, 0>::default();
    let map = maps::SafeMemoryMap::from_str(&text);
    let textdb = Table::new(map, accessor);

    assert!(textdb.is_sorted().unwrap());

    assert_eq!(textdb.get_matching_lines(&113).count(), 2);
}


#[test]
fn test_get_matching_lines_2() {
    for i in 0..1000 {
        let mut kv = (0..i).map(|i| {
            let key : u8 = rand::random();
            (key, i)
        }).collect::<Vec<_>>();

        kv.sort();

        let text = kv.iter().map(|(k, v)| format!("{k}\t{v}")).collect::<Vec<_>>().join("\n");

        // println!("{kv:?} {text}");

        let accessor = accessor::TsvParse::<u8, 0>::default();
        let map = maps::SafeMemoryMap::from_str(&text);
        let textdb = Table::new(map, accessor);

        assert!(textdb.is_sorted().unwrap());

        for (k, _v) in kv {
            // println!("finding k={k}");
            for line in textdb.get_matching_lines(&k) {
                assert_eq!(line.col(0).unwrap().parse::<u8>().unwrap(), k);
                // assert_eq!(line.col(1).unwrap().parse::<u32>().unwrap(), v);
                // println!("{k} {v} {line}");
            }
        }
    }

}