rrdb 0.0.1

ready
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

#![cfg(test)]

use crate::lib::ast::predule::{
    InsertQuery, InsertValue, SQLExpression, SelectColumn, SelectItem, SelectQuery, TableName,
};
use crate::lib::parser::context::ParserContext;
use crate::lib::parser::predule::Parser;

#[test]
pub fn insert_into_values_1() {
    let text = r#"
        INSERT INTO foo.bar(a, b, c)
        Values(1, 2, 3)
    "#
    .to_owned();

    let mut parser = Parser::new(text).unwrap();

    let expected = InsertQuery::builder()
        .set_into_table(TableName {
            database_name: Some("foo".into()),
            table_name: "bar".into(),
        })
        .set_columns(vec!["a".into(), "b".into(), "c".into()])
        .set_values(vec![InsertValue {
            list: vec![
                SQLExpression::Integer(1),
                SQLExpression::Integer(2),
                SQLExpression::Integer(3),
            ],
        }])
        .build();

    assert_eq!(
        parser.parse(ParserContext::default()).unwrap(),
        vec![expected.into()],
    );
}

#[test]
pub fn insert_into_values_2() {
    let text = r#"
        INSERT INTO foo.bar(a, b, c)
        Values(1, 2, 3), (4, 5, 6)
    "#
    .to_owned();

    let mut parser = Parser::new(text).unwrap();

    let expected = InsertQuery::builder()
        .set_into_table(TableName {
            database_name: Some("foo".into()),
            table_name: "bar".into(),
        })
        .set_columns(vec!["a".into(), "b".into(), "c".into()])
        .set_values(vec![
            InsertValue {
                list: vec![
                    SQLExpression::Integer(1),
                    SQLExpression::Integer(2),
                    SQLExpression::Integer(3),
                ],
            },
            InsertValue {
                list: vec![
                    SQLExpression::Integer(4),
                    SQLExpression::Integer(5),
                    SQLExpression::Integer(6),
                ],
            },
        ])
        .build();

    assert_eq!(
        parser.parse(ParserContext::default()).unwrap(),
        vec![expected.into()],
    );
}

#[test]
pub fn insert_into_select_1() {
    let text = r#"
        INSERT INTO foo.bar(a, b, c)
        Select s.a, s.b, s.c from boom.some as s
    "#
    .to_owned();

    let mut parser = Parser::new(text).unwrap();

    let expected = InsertQuery::builder()
        .set_into_table(TableName {
            database_name: Some("foo".into()),
            table_name: "bar".into(),
        })
        .set_columns(vec!["a".into(), "b".into(), "c".into()])
        .set_select(
            SelectQuery::builder()
                .add_select_item(
                    SelectItem::builder()
                        .set_item(SelectColumn::new(Some("s".into()), "a".into()).into())
                        .build(),
                )
                .add_select_item(
                    SelectItem::builder()
                        .set_item(SelectColumn::new(Some("s".into()), "b".into()).into())
                        .build(),
                )
                .add_select_item(
                    SelectItem::builder()
                        .set_item(SelectColumn::new(Some("s".into()), "c".into()).into())
                        .build(),
                )
                .set_from_table(TableName {
                    database_name: Some("boom".into()),
                    table_name: "some".into(),
                })
                .set_from_alias("s".into())
                .build(),
        )
        .build();

    assert_eq!(
        parser.parse(ParserContext::default()).unwrap(),
        vec![expected.into()],
    );
}