fosk 0.1.13

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, TextCollector}, ParseError, QueryParser};

#[derive(Clone, PartialEq)]
pub struct  Identifier {
    pub expression: ScalarExpr,
    pub alias: Option<String>,
}

impl Identifier {
    pub fn parse(parser: &mut QueryParser) -> Result<Identifier, ParseError> {
        let scalar = ScalarExpr::parse(parser, true)?;

        if !parser.current().is_whitespace() || parser.eof() {
            return Ok(Identifier {
                expression: scalar,
                alias: None
            });
        }

        while parser.current().is_whitespace() {
            parser.next();
        }

        if parser.comparers.from.compare(parser) {
            return Ok(Identifier {
                expression: scalar,
                alias: None
            });
        }

        if !parser.comparers.alias.compare(parser) {
            return ParseError::new("Invalid alias for identifier", parser.position, parser).err();
        }

        parser.jump(parser.comparers.alias.length);

        while parser.current().is_whitespace() {
            parser.next();
        }

        Ok(Identifier {
            expression: scalar,
            alias: Some(TextCollector::collect(parser)?),
        })
    }
}

use std::fmt;

impl fmt::Display for Identifier {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match &self.alias {
            Some(a) => write!(f, "{} as {}", self.expression, a),
            None => write!(f, "{}", self.expression),
        }
    }
}

impl fmt::Debug for Identifier {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Identifier({})", self)
    }
}

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

    #[test]
    pub fn test_identifier() {
        let text = "column";

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

        let result = Identifier::parse(&mut parser).expect("Failed to parse Identifier");

        match result.expression {
            ScalarExpr::Column(column) => match column {
                Column::Name { name } => assert_eq!(name, text),
                Column::WithCollection { collection: _, name: _ } => panic!(),
            },
            _ => panic!(),
        };

        assert_eq!(result.alias, None);
    }

    #[test]
    pub fn test_identifier_with_alias() {
        let text = "column as alias";

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

        let result = Identifier::parse(&mut parser).expect("Failed to parse ScalarExpr");

        match result.expression {
            ScalarExpr::Column(column) => match column {
                Column::Name { name } => assert_eq!(name, "column"),
                Column::WithCollection { collection: _, name: _ } => panic!(),
            },
            _ => panic!(),
        };
    }

    #[test]
    pub fn test_identifier_with_collection_and_alias() {
        let text = "collection.column as alias";

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

        let result = Identifier::parse(&mut parser).expect("Failed to parse ScalarExpr");

        match result.expression {
            ScalarExpr::Column(column) => match column {
                Column::Name { name: _ } => panic!(),
                Column::WithCollection { collection, name } => {
                    assert_eq!(name, "column");
                    assert_eq!(collection, "collection");
                    assert_eq!(result.alias.unwrap(), "alias");
                },
            },
            _ => panic!(),
        };
    }

    #[test]
    pub fn test_identifier_with_wrong_alias() {
        let text = "column asa alias";

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

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

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

}