fosk 0.2.0

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
145
146
147
148
149
150
151
152
153
154
155
156
157
158

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

pub struct LimitAndOffsetParser;

impl LimitAndOffsetParser {
    pub fn parse(parser: &mut QueryParser) -> Result<(Option<i64>, Option<i64>), ParseError> {
        let mut limit = None;
        let mut offset = None;

        while !parser.check_next_phase() {
            if parser.comparers.limit.compare(parser) {
                parser.jump(parser.comparers.limit.length);
                let value = ScalarExpr::parse(parser, false)?;
                match value {
                    ScalarExpr::Literal(Literal::Int(value)) => limit = Some(value),
                    _ => {
                        return ParseError::new(
                            "Invalid limit",
                            parser.get_initial_sequence_pos(),
                            parser,
                        )
                        .err();
                    }
                }
            } else if parser.comparers.offset.compare(parser) {
                parser.jump(parser.comparers.offset.length);
                let value = ScalarExpr::parse(parser, false)?;
                match value {
                    ScalarExpr::Literal(Literal::Int(value)) => offset = Some(value),
                    _ => {
                        return ParseError::new(
                            "Invalid offset",
                            parser.get_initial_sequence_pos(),
                            parser,
                        )
                        .err();
                    }
                }
            } else {
                return ParseError::new(
                    "Invalid offset",
                    parser.get_initial_sequence_pos(),
                    parser,
                )
                .err();
            }
        }

        Ok((limit, offset))
    }
}

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

    #[test]
    pub fn test_limit() {
        let text = "LIMIT 10";

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

        let (limit, offset) =
            LimitAndOffsetParser::parse(&mut parser).expect("Failed to parse limit and offset");

        assert_eq!(limit.unwrap(), 10);
        assert!(offset.is_none());
    }

    #[test]
    pub fn test_offset() {
        let text = "OFFSET 10";

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

        let (limit, offset) =
            LimitAndOffsetParser::parse(&mut parser).expect("Failed to parse limit and offset");

        assert!(limit.is_none());
        assert_eq!(offset.unwrap(), 10);
    }

    #[test]
    pub fn test_offset_and_limit() {
        let text = "OFFSET 20 LIMIT 30";

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

        let (limit, offset) =
            LimitAndOffsetParser::parse(&mut parser).expect("Failed to parse limit and offset");

        assert_eq!(limit.unwrap(), 30);
        assert_eq!(offset.unwrap(), 20);
    }

    #[test]
    pub fn test_offset_and_limit_wrong_limit() {
        let text = "OFFSET 20 LIMIT AB";

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

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

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

    #[test]
    pub fn test_offset_and_limit_wrong_offset() {
        let text = "OFFSET 20 30 LIMIT AB";

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

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

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

    #[test]
    pub fn test_offset_and_limit_wrong_phase() {
        let text = "OFFSET 20 LIMIT 60 GROUP BY ";

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

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

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