dbx-core 0.1.0-beta

High-performance file-based database engine with 5-Tier Hybrid Storage
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

//! LogicalPlanner INSERT tests

#[cfg(test)]
mod tests {
    use crate::sql::planner::logical::LogicalPlanner;
    use crate::sql::planner::types::{Expr, LogicalPlan};
    use crate::sql::SqlParser;
    use crate::storage::columnar::ScalarValue;

    #[test]
    fn test_insert_single_row() {
        let parser = SqlParser::new();
        let sql = "INSERT INTO users (id, name) VALUES (1, 'Alice')";
        let statements = parser.parse(sql).unwrap();

        let planner = LogicalPlanner::new();
        let plan = planner.plan(&statements[0]).unwrap();

        match plan {
            LogicalPlan::Insert {
                table,
                columns,
                values,
            } => {
                assert_eq!(table, "users");
                assert_eq!(columns, vec!["id", "name"]);
                assert_eq!(values.len(), 1);
                assert_eq!(values[0].len(), 2);

                // Check first value (id = 1)
                match &values[0][0] {
                    Expr::Literal(ScalarValue::Int64(i)) => assert_eq!(*i, 1),
                    _ => panic!("Expected Int64 literal for id"),
                }

                // Check second value (name = 'Alice')
                match &values[0][1] {
                    Expr::Literal(ScalarValue::Utf8(s)) => assert_eq!(s, "Alice"),
                    _ => panic!("Expected Utf8 literal for name"),
                }
            }
            _ => panic!("Expected INSERT plan"),
        }
    }

    #[test]
    fn test_insert_multiple_rows() {
        let parser = SqlParser::new();
        let sql = "INSERT INTO users (id, name) VALUES (1, 'Alice'), (2, 'Bob'), (3, 'Charlie')";
        let statements = parser.parse(sql).unwrap();

        let planner = LogicalPlanner::new();
        let plan = planner.plan(&statements[0]).unwrap();

        match plan {
            LogicalPlan::Insert {
                table,
                columns,
                values,
            } => {
                assert_eq!(table, "users");
                assert_eq!(columns, vec!["id", "name"]);
                assert_eq!(values.len(), 3);

                // Check first row
                match &values[0][0] {
                    Expr::Literal(ScalarValue::Int64(i)) => assert_eq!(*i, 1),
                    _ => panic!("Expected Int64 literal"),
                }
                match &values[0][1] {
                    Expr::Literal(ScalarValue::Utf8(s)) => assert_eq!(s, "Alice"),
                    _ => panic!("Expected Utf8 literal"),
                }

                // Check second row
                match &values[1][0] {
                    Expr::Literal(ScalarValue::Int64(i)) => assert_eq!(*i, 2),
                    _ => panic!("Expected Int64 literal"),
                }
                match &values[1][1] {
                    Expr::Literal(ScalarValue::Utf8(s)) => assert_eq!(s, "Bob"),
                    _ => panic!("Expected Utf8 literal"),
                }

                // Check third row
                match &values[2][0] {
                    Expr::Literal(ScalarValue::Int64(i)) => assert_eq!(*i, 3),
                    _ => panic!("Expected Int64 literal"),
                }
                match &values[2][1] {
                    Expr::Literal(ScalarValue::Utf8(s)) => assert_eq!(s, "Charlie"),
                    _ => panic!("Expected Utf8 literal"),
                }
            }
            _ => panic!("Expected INSERT plan"),
        }
    }

    #[test]
    fn test_insert_different_types() {
        let parser = SqlParser::new();
        let sql = "INSERT INTO data (id, value, flag) VALUES (42, 3.14, true)";
        let statements = parser.parse(sql).unwrap();

        let planner = LogicalPlanner::new();
        let plan = planner.plan(&statements[0]).unwrap();

        match plan {
            LogicalPlan::Insert { values, .. } => {
                assert_eq!(values.len(), 1);
                assert_eq!(values[0].len(), 3);

                // Check Int64
                match &values[0][0] {
                    Expr::Literal(ScalarValue::Int64(i)) => assert_eq!(*i, 42),
                    _ => panic!("Expected Int64"),
                }

                // Check Float64
                match &values[0][1] {
                    Expr::Literal(ScalarValue::Float64(f)) => assert_eq!(*f, 3.14),
                    _ => panic!("Expected Float64"),
                }

                // Check Boolean
                match &values[0][2] {
                    Expr::Literal(ScalarValue::Boolean(b)) => assert_eq!(*b, true),
                    _ => panic!("Expected Boolean"),
                }
            }
            _ => panic!("Expected INSERT plan"),
        }
    }

    #[test]
    fn test_insert_without_columns() {
        let parser = SqlParser::new();
        let sql = "INSERT INTO users VALUES (1, 'Alice')";
        let statements = parser.parse(sql).unwrap();

        let planner = LogicalPlanner::new();
        let plan = planner.plan(&statements[0]).unwrap();

        match plan {
            LogicalPlan::Insert { columns, .. } => {
                // When no columns specified, columns should be empty
                assert!(columns.is_empty());
            }
            _ => panic!("Expected INSERT plan"),
        }
    }
}