gluesql_core/plan/
statement.rs

1mod ddl;
2mod expr;
3mod projection;
4mod query;
5
6pub use {
7    ddl::AlterTableOperationPlan,
8    expr::{
9        AggregateExprPlan, AggregateFunctionPlan, CountArgExprPlan, ExprPlan, FunctionExprPlan,
10        plan_scalar_expr,
11    },
12    projection::{ProjectionPlan, SelectItemPlan},
13    query::{
14        AggregationInputPlan, AggregationPlan, DerivedSourcePlan, DictionarySourcePlan,
15        DistinctInputPlan, DistinctPlan, FilterInputPlan, FilterPlan, HashJoinInputPlan,
16        HashJoinPlan, HavingPlan, IndexPredicatePlan, InnerJoinInputPlan, InnerJoinPlan,
17        JoinConditionInputPlan, JoinConditionPlan, LeftOuterJoinInputPlan, LeftOuterJoinPlan,
18        LimitInputPlan, LimitPlan, NestedLoopJoinInputPlan, NestedLoopJoinPlan, OffsetInputPlan,
19        OffsetPlan, OrderByExprPlan, ProjectInputPlan, ProjectPlan, QueryPlan, SelectOrderByPlan,
20        SeriesSourcePlan, SourcePlan, TableAccessPlan, TableAliasPlan, TableSourcePlan,
21        ValuesOrderByPlan, ValuesPlan,
22    },
23};
24
25use {
26    crate::ast::{self, ForeignKey, Variable},
27    serde::{Deserialize, Serialize},
28};
29
30#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
31pub enum StatementPlan {
32    ShowColumns {
33        table_name: String,
34    },
35    Query(QueryPlan),
36    Insert {
37        table_name: String,
38        columns: Vec<String>,
39        source: QueryPlan,
40    },
41    Update {
42        table_name: String,
43        assignments: Vec<AssignmentPlan>,
44        selection: Option<ExprPlan>,
45    },
46    Delete {
47        table_name: String,
48        selection: Option<ExprPlan>,
49    },
50    CreateTable {
51        if_not_exists: bool,
52        name: String,
53        columns: Option<Vec<ast::ColumnDef>>,
54        source: Option<Box<QueryPlan>>,
55        engine: Option<String>,
56        foreign_keys: Vec<ForeignKey>,
57        comment: Option<String>,
58    },
59    CreateFunction {
60        or_replace: bool,
61        name: String,
62        args: Vec<ast::OperateFunctionArg>,
63        return_: ast::Expr,
64    },
65    AlterTable {
66        name: String,
67        operation: AlterTableOperationPlan,
68    },
69    DropTable {
70        if_exists: bool,
71        names: Vec<String>,
72        cascade: bool,
73    },
74    DropFunction {
75        if_exists: bool,
76        names: Vec<String>,
77    },
78    CreateIndex {
79        name: String,
80        table_name: String,
81        column: ast::OrderByExpr,
82    },
83    DropIndex {
84        name: String,
85        table_name: String,
86    },
87    StartTransaction,
88    Commit,
89    Rollback,
90    ShowVariable(Variable),
91    ShowIndexes(String),
92}
93
94#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
95pub struct AssignmentPlan {
96    pub id: String,
97    pub value: ExprPlan,
98}
99
100impl From<ast::Statement> for StatementPlan {
101    fn from(statement: ast::Statement) -> Self {
102        match statement {
103            ast::Statement::ShowColumns { table_name } => Self::ShowColumns { table_name },
104            ast::Statement::Query(query) => Self::Query(query.into()),
105            ast::Statement::Insert {
106                table_name,
107                columns,
108                source,
109            } => Self::Insert {
110                table_name,
111                columns,
112                source: source.into(),
113            },
114            ast::Statement::Update {
115                table_name,
116                assignments,
117                selection,
118            } => Self::Update {
119                table_name,
120                assignments: assignments.into_iter().map(Into::into).collect(),
121                selection: selection.map(Into::into),
122            },
123            ast::Statement::Delete {
124                table_name,
125                selection,
126            } => Self::Delete {
127                table_name,
128                selection: selection.map(Into::into),
129            },
130            ast::Statement::CreateTable {
131                if_not_exists,
132                name,
133                columns,
134                source,
135                engine,
136                foreign_keys,
137                comment,
138            } => Self::CreateTable {
139                if_not_exists,
140                name,
141                columns,
142                source: source.map(|query| Box::new((*query).into())),
143                engine,
144                foreign_keys,
145                comment,
146            },
147            ast::Statement::CreateFunction {
148                or_replace,
149                name,
150                args,
151                return_,
152            } => Self::CreateFunction {
153                or_replace,
154                name,
155                args,
156                return_,
157            },
158            ast::Statement::AlterTable { name, operation } => Self::AlterTable {
159                name,
160                operation: operation.into(),
161            },
162            ast::Statement::DropTable {
163                if_exists,
164                names,
165                cascade,
166            } => Self::DropTable {
167                if_exists,
168                names,
169                cascade,
170            },
171            ast::Statement::DropFunction { if_exists, names } => {
172                Self::DropFunction { if_exists, names }
173            }
174            ast::Statement::CreateIndex {
175                name,
176                table_name,
177                column,
178            } => Self::CreateIndex {
179                name,
180                table_name,
181                column,
182            },
183            ast::Statement::DropIndex { name, table_name } => Self::DropIndex { name, table_name },
184            ast::Statement::StartTransaction => Self::StartTransaction,
185            ast::Statement::Commit => Self::Commit,
186            ast::Statement::Rollback => Self::Rollback,
187            ast::Statement::ShowVariable(variable) => Self::ShowVariable(variable),
188            ast::Statement::ShowIndexes(table_name) => Self::ShowIndexes(table_name),
189        }
190    }
191}
192
193impl From<ast::Assignment> for AssignmentPlan {
194    fn from(assignment: ast::Assignment) -> Self {
195        let ast::Assignment { id, value } = assignment;
196
197        Self {
198            id,
199            value: value.into(),
200        }
201    }
202}
gluesql_core/plan/statement.rs

gluesql_core/plan/
statement.rs
