fosk 0.1.3

In-memory SQL-like query engine and lightweight data store for testing and prototyping.
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use crate::parser::{ast::ScalarExpr, ParseError, QueryParser};

pub struct ParamParser;

impl ParamParser {
    pub fn is_param(parser: &QueryParser) -> bool {
        parser.comparers.param.compare(parser)
    }

    pub fn parse(parser: &mut QueryParser) -> Result<ScalarExpr, ParseError> {
        if parser.comparers.param.compare(parser) {
            parser.jump(parser.comparers.param.length);
            return Ok(ScalarExpr::Parameter)
        }

        Err(ParseError::new("Invalid Parameter", parser.position, parser))
    }
}

#[cfg(test)]
pub mod tests {
    use crate::parser::{ast::{ParamParser, ScalarExpr}, QueryParser};

    #[test]
    pub fn test_param_parser() {
        let text = "?";

        let mut parser = QueryParser::new(text);

        let result = ParamParser::parse(&mut parser);

        match result {
            Ok(result) => match result {
                ScalarExpr::Parameter => {}, //should happen
                _ => panic!(),
            },
            Err(_) => panic!(),
        }
    }

    #[test]
    pub fn test_param_parser_upper() {
        let text = "?";

        let mut parser = QueryParser::new(text);

        let result = ParamParser::parse(&mut parser);

        match result {
            Ok(result) => match result {
                ScalarExpr::Parameter => {}, //should happen
                _ => panic!(),
            },
            Err(_) => panic!(),
        }
    }

    #[test]
    pub fn test_param_parser_param_space_delimiter() {
        let text = "? ";

        let mut parser = QueryParser::new(text);

        let result = ParamParser::parse(&mut parser);

        match result {
            Ok(result) => match result {
                ScalarExpr::Parameter => {}, //should happen
                _ => panic!(),
            },
            Err(_) => panic!(),
        }
    }

    #[test]
    pub fn test_param_parser_param_comma_delimiter() {
        let text = "?,";

        let mut parser = QueryParser::new(text);

        let result = ParamParser::parse(&mut parser);

        match result {
            Ok(result) => match result {
                ScalarExpr::Parameter => {}, //should happen
                _ => panic!(),
            },
            Err(_) => panic!(),
        }
    }

    #[test]
    pub fn test_param_parser_param_break_line() {
        let text = "?\r\n";

        let mut parser = QueryParser::new(text);

        let result = ParamParser::parse(&mut parser);

        match result {
            Ok(result) => match result {
                ScalarExpr::Parameter => {}, //should happen
                _ => panic!(),
            },
            Err(_) => panic!(),
        }
    }

    #[test]
    pub fn test_param_parser_param_wrong() {
        let text = "?e";

        let mut parser = QueryParser::new(text);

        let result = ParamParser::parse(&mut parser);

        match result {
            Ok(_) => panic!(),
            Err(err) => {
                assert_eq!(err.text, "?");
                assert_eq!(err.start, 0);
                assert_eq!(err.end, 0);
            },
        }
    }

    #[test]
    pub fn test_param_parser_param_wrong_2() {
        let text = "?#";

        let mut parser = QueryParser::new(text);

        let result = ParamParser::parse(&mut parser);

        match result {
            Ok(_) => panic!(),
            Err(err) => {
                assert_eq!(err.text, "?");
                assert_eq!(err.start, 0);
                assert_eq!(err.end, 0);
            },
        }
    }
}