kip-sql 0.0.1-alpha.8

build the SQL layer of KipDB database
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

use sqlparser::ast::{AlterTableOperation, ObjectName};

use std::sync::Arc;

use super::{is_valid_identifier, Binder};
use crate::binder::{lower_case_name, split_name, BindError};
use crate::planner::operator::alter_table::add_column::AddColumnOperator;
use crate::planner::operator::alter_table::drop_column::DropColumnOperator;
use crate::planner::operator::scan::ScanOperator;
use crate::planner::operator::Operator;
use crate::planner::LogicalPlan;
use crate::storage::Transaction;

impl<'a, T: Transaction> Binder<'a, T> {
    pub(crate) fn bind_alter_table(
        &mut self,
        name: &ObjectName,
        operation: &AlterTableOperation,
    ) -> Result<LogicalPlan, BindError> {
        let table_name: Arc<String> = Arc::new(split_name(&lower_case_name(name))?.to_string());

        if let Some(table) = self.context.table(table_name.clone()) {
            let plan = match operation {
                AlterTableOperation::AddColumn {
                    column_keyword: _,
                    if_not_exists,
                    column_def,
                } => {
                    let plan = ScanOperator::build(table_name.clone(), table);
                    let column = self.bind_column(column_def)?;

                    if !is_valid_identifier(column.name()) {
                        return Err(BindError::InvalidColumn(
                            "illegal column naming".to_string(),
                        ));
                    }
                    LogicalPlan {
                        operator: Operator::AddColumn(AddColumnOperator {
                            table_name,
                            if_not_exists: *if_not_exists,
                            column,
                        }),
                        childrens: vec![plan],
                    }
                }
                AlterTableOperation::DropColumn {
                    column_name,
                    if_exists,
                    ..
                } => {
                    let plan = ScanOperator::build(table_name.clone(), table);
                    let column_name = column_name.value.clone();

                    LogicalPlan {
                        operator: Operator::DropColumn(DropColumnOperator {
                            table_name,
                            if_exists: *if_exists,
                            column_name,
                        }),
                        childrens: vec![plan],
                    }
                }
                AlterTableOperation::DropPrimaryKey => todo!(),
                AlterTableOperation::RenameColumn {
                    old_column_name: _,
                    new_column_name: _,
                } => todo!(),
                AlterTableOperation::RenameTable { table_name: _ } => todo!(),
                AlterTableOperation::ChangeColumn {
                    old_name: _,
                    new_name: _,
                    data_type: _,
                    options: _,
                } => todo!(),
                AlterTableOperation::AlterColumn {
                    column_name: _,
                    op: _,
                } => todo!(),
                _ => todo!(),
            };

            Ok(plan)
        } else {
            Err(BindError::InvalidTable(format!(
                "not found table {}",
                table_name
            )))
        }
    }
}