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

use crate::parser::WordComparer;

#[derive(Debug)]
pub struct QueryComparers {
    pub select: WordComparer,
    pub distinct: WordComparer,
    pub alias: WordComparer,
    pub from: WordComparer,
    pub join: WordComparer,
    pub inner_join: WordComparer,
    pub left_join: WordComparer,
    pub right_join: WordComparer,
    pub full_join: WordComparer,
    pub on: WordComparer,
    pub r#where: WordComparer,
    pub group_by: WordComparer,
    pub asc: WordComparer,
    pub desc: WordComparer,
    pub having: WordComparer,
    pub order_by: WordComparer,
    pub limit: WordComparer,
    pub offset: WordComparer,
    pub and: WordComparer,
    pub or: WordComparer,
    pub equal: WordComparer,
    pub not_equal_b: WordComparer, // basic
    pub not_equal_c: WordComparer, // c
    pub greater_than: WordComparer,
    pub greater_than_or_equal: WordComparer,
    pub less_than: WordComparer,
    pub less_than_or_equal: WordComparer,
    pub like: WordComparer,
    pub not_like: WordComparer,
    pub is_null: WordComparer,
    pub is_not_null: WordComparer,
    pub r#in: WordComparer,
    pub not_in: WordComparer,
    pub b_true: WordComparer,
    pub b_false: WordComparer,
    pub null: WordComparer,
    pub param: WordComparer,
}

impl Default for QueryComparers {
    fn default() -> Self {
        Self::new()
    }
}

impl QueryComparers {
    pub fn new() -> Self {
        Self {
            select: WordComparer::new("SELECT").with_whitespace_postfix(),
            distinct: WordComparer::new("DISTINCT").with_whitespace_postfix(),
            alias: WordComparer::new("AS").with_whitespace_postfix(),
            from: WordComparer::new("FROM").with_whitespace_postfix(),
            join: WordComparer::new("JOIN").with_whitespace_postfix(),
            inner_join: WordComparer::new("INNER JOIN").with_whitespace_postfix(),
            left_join: WordComparer::new("LEFT JOIN").with_whitespace_postfix(),
            right_join: WordComparer::new("RIGHT JOIN").with_whitespace_postfix(),
            full_join: WordComparer::new("FULL JOIN").with_whitespace_postfix(),
            on: WordComparer::new("ON").with_whitespace_postfix(),
            r#where: WordComparer::new("WHERE").with_whitespace_postfix(),
            group_by: WordComparer::new("GROUP BY").with_whitespace_postfix(),
            asc: WordComparer::new("ASC").with_whitespace_postfix().with_eof().with_optional_postfix(','),
            desc: WordComparer::new("DESC").with_whitespace_postfix().with_eof().with_optional_postfix(','),
            having: WordComparer::new("HAVING").with_whitespace_postfix(),
            order_by: WordComparer::new("ORDER BY").with_whitespace_postfix(),
            limit: WordComparer::new("LIMIT").with_whitespace_postfix(),
            offset: WordComparer::new("OFFSET").with_whitespace_postfix(),
            and: WordComparer::new("AND").with_whitespace_postfix(),
            or: WordComparer::new("OR").with_whitespace_postfix(),
            equal: WordComparer::new("=").with_whitespace_postfix(),
            not_equal_b: WordComparer::new("<>").with_whitespace_postfix(),
            not_equal_c: WordComparer::new("!=").with_whitespace_postfix(),
            greater_than: WordComparer::new(">").with_whitespace_postfix(),
            greater_than_or_equal: WordComparer::new(">=").with_whitespace_postfix(),
            less_than: WordComparer::new("<").with_whitespace_postfix(),
            less_than_or_equal: WordComparer::new("<=").with_whitespace_postfix(),
            like: WordComparer::new("LIKE").with_whitespace_postfix(),
            not_like: WordComparer::new("NOT LIKE").with_whitespace_postfix(),
            is_null: WordComparer::new("IS NULL").with_whitespace_postfix().with_eof(),
            is_not_null: WordComparer::new("IS NOT NULL").with_whitespace_postfix().with_eof(),
            r#in: WordComparer::new("IN").with_whitespace_postfix().with_delimiter('('),
            not_in: WordComparer::new("NOT IN").with_whitespace_postfix().with_delimiter('('),
            b_true: WordComparer::new("TRUE").with_any_delimiter_postfix().with_eof(),
            b_false: WordComparer::new("FALSE").with_any_delimiter_postfix().with_eof(),
            null: WordComparer::new("NULL").with_any_delimiter_postfix().with_eof(),
            param: WordComparer::new("?").with_any_delimiter_postfix().with_eof(),
        }
    }
}