sq3-rs 0.2.15

SQLite reader with no dependencies
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

use crate::query::{
    expression::SqliteExpression,
    keyword::{Distinct, KeywordFrom},
    stmt::{
        select::{ColumnName, ResultColumns, TableName},
        SelectStmt,
    },
};

#[test]
fn ok_on_test_select_parser() {
    use crate::query::stmt::select::{Initial, SelectParser};
    let input = String::from("SELECT id, name FROM users WHERE id = 1");
    dbg!(&input);
    let result = SelectParser::<Initial>::new(input)
        .parse_select()
        .and_then(|p| p.parse_columns())
        .and_then(|p| p.parse_table())
        .and_then(|p| p.parse_condition());

    match result {
        Ok(_) => println!("Parsing completed successfully"),
        Err(e) => println!("Parsing error: {}", e),
    }
}

#[test]
fn ok_on_run_valid_select_query() {
    let expected = SelectStmt {
        distinct: Some(Box::new(Distinct)),
        result_columns: Some(ResultColumns::Filter(vec![
            ColumnName("id"),
            ColumnName("name"),
        ])),
        from: Some(KeywordFrom),
        origin: Some(TableName("users")),
        expr: None,
        ..Default::default()
    };
    let query = "SELECT DISTINCT id,name FROM users WHERE age > 18;";

    println!("Query: {}", query);
    if let Some((_, next_to_parse)) = query.split_once(' ') {
        let select = SelectStmt::parse(next_to_parse).unwrap();
        {
            let maybe_expected = &expected.distinct;
            let maybe_retrieved = &select.distinct;
            match (maybe_expected, maybe_retrieved) {
                (Some(dyn_expected), Some(dyn_retrieved)) => {
                    let expected = dyn_expected.as_any().downcast_ref::<Distinct>().unwrap();
                    let retrieved = dyn_retrieved.as_any().downcast_ref::<Distinct>().unwrap();
                    // dbg!(expected, retrieved);
                    assert_eq!(expected, retrieved);
                }
                _ => panic!(),
            }
        }
        {
            let maybe_expected = &expected.result_columns;
            let maybe_retrieved = &select.result_columns;
            match (maybe_expected, maybe_retrieved) {
                (Some(expected), Some(retrieved)) => {
                    // dbg!(expected, retrieved);
                    assert_eq!(expected, retrieved);
                }
                _ => panic!(),
            }
        }
        {
            let maybe_expected = &expected.from;
            let maybe_retrieved = &select.from;
            match (maybe_expected, maybe_retrieved) {
                (Some(expected), Some(retrieved)) => {
                    // dbg!(expected, retrieved);
                    assert_eq!(expected, retrieved);
                }
                _ => panic!(),
            }
        }
        {
            let maybe_expected = &expected.origin;
            let maybe_retrieved = &select.origin;
            match (maybe_expected, maybe_retrieved) {
                (Some(expected), Some(retrieved)) => {
                    // dbg!(expected, retrieved);
                    assert_eq!(expected, retrieved);
                }
                _ => panic!(),
            }
        }
        // {
        //     let maybe_expected = &expected.expr;
        //     let maybe_retrieved = &select.expr;
        //     dbg!(maybe_expected, maybe_retrieved);
        //     match (maybe_expected, maybe_retrieved) {
        //         (Some(expected), Some(retrieved)) => {
        //             // dbg!(expected, retrieved);
        //             assert_eq!(expected, retrieved);
        //         }
        //         _ => panic!(),
        //     }
        // }
    } else {
        panic!()
    }
}

// #[test]
// #[ignore = "Todo"]
// fn err_on_run_invalid_select_queries() {
//     for query in invalid_queries() {
//         println!("Query: {}", query);
//         let res = SqliteQuery::run(&query);
//         println!("{res:?}");
//         assert!(res.is_err());
//     }
// }