Skip to content

Commit 13cb9f8

Browse files
Almaz-KGAlmaz-KG
committed
sql_parser: expression parser refactoring (9)
1 parent ae56c92 commit 13cb9f8

27 files changed

+428
-629
lines changed

‎src/parser/alter/mod.rs

+7-9
Original file line numberDiff line numberDiff line change
@@ -380,10 +380,10 @@ mod add_column_with_constraints_tests {
380380
fn add_column_with_check_constraint() {
381381
let expected_statement = column_constraint_statement(ColumnConstraint {
382382
name: Some(Identifier::Single("chk_constraint".to_string())),
383-
constraint_type: ColumnConstraintType::Check(binary_op_expression(
383+
constraint_type: ColumnConstraintType::Check(binary_op(
384384
BinaryOp::GreaterThan,
385-
identifier_expression(&["column_name"]),
386-
numeric_literal_expression("0"),
385+
identifier_expr(&["column_name"]),
386+
numeric_expr("0"),
387387
)),
388388
});
389389

@@ -397,9 +397,7 @@ mod add_column_with_constraints_tests {
397397
fn add_column_with_default_constraint() {
398398
let expected_statement = column_constraint_statement(ColumnConstraint {
399399
name: Some(Identifier::Single("default_constraint".to_string())),
400-
constraint_type: ColumnConstraintType::Default(string_literal_expression(
401-
"'default_value'",
402-
)),
400+
constraint_type: ColumnConstraintType::Default(string_expr("'default_value'")),
403401
});
404402

405403
run_sunny_day_test(
@@ -412,10 +410,10 @@ mod add_column_with_constraints_tests {
412410
fn add_column_with_default_expression_constraint() {
413411
let expected_statement = column_constraint_statement(ColumnConstraint {
414412
name: Some(Identifier::Single("default_constraint".to_string())),
415-
constraint_type: ColumnConstraintType::Default(binary_op_expression(
413+
constraint_type: ColumnConstraintType::Default(binary_op(
416414
BinaryOp::Plus,
417-
identifier_expression(&["column_name"]),
418-
numeric_literal_expression("1"),
415+
identifier_expr(&["column_name"]),
416+
numeric_expr("1"),
419417
)),
420418
});
421419

‎src/parser/create/create_index.rs

+10-13
Original file line numberDiff line numberDiff line change
@@ -43,8 +43,7 @@ impl<'a> CreateIndexStatementParser for Parser<'a> {
4343
#[cfg(test)]
4444
pub mod test_utils {
4545
use crate::{
46-
expression::test_utils::identifier_expression, CreateIndexStatement, Identifier,
47-
IndexedColumn,
46+
expression::test_utils::identifier_expr, CreateIndexStatement, Identifier, IndexedColumn,
4847
};
4948

5049
pub fn create_index_statement() -> CreateIndexStatement {
@@ -54,7 +53,7 @@ pub mod test_utils {
5453
index_name: Identifier::from("index_name"),
5554
table_name: Identifier::from("table_name"),
5655
columns: vec![IndexedColumn {
57-
column: identifier_expression(&["column1"]),
56+
column: identifier_expr(&["column1"]),
5857
ordering: None,
5958
}],
6059
where_clause: None,
@@ -65,9 +64,7 @@ pub mod test_utils {
6564
#[cfg(test)]
6665
mod create_index_tests {
6766
use super::test_utils::create_index_statement;
68-
use crate::expression::test_utils::{
69-
binary_op_expression, identifier_expression, numeric_literal_expression,
70-
};
67+
use crate::expression::test_utils::{binary_op, identifier_expr, numeric_expr};
7168
use crate::{
7269
parser::test_utils::run_sunny_day_test, BinaryOp, Identifier, IndexedColumn, Statement,
7370
};
@@ -102,19 +99,19 @@ mod create_index_tests {
10299
let mut expected = create_index_statement();
103100
expected.columns = vec![
104101
IndexedColumn {
105-
column: identifier_expression(&["column1"]),
102+
column: identifier_expr(&["column1"]),
106103
ordering: None,
107104
},
108105
IndexedColumn {
109-
column: identifier_expression(&["column2"]),
106+
column: identifier_expr(&["column2"]),
110107
ordering: None,
111108
},
112109
IndexedColumn {
113-
column: identifier_expression(&["column3"]),
110+
column: identifier_expr(&["column3"]),
114111
ordering: None,
115112
},
116113
IndexedColumn {
117-
column: identifier_expression(&["column4"]),
114+
column: identifier_expr(&["column4"]),
118115
ordering: None,
119116
},
120117
];
@@ -133,10 +130,10 @@ mod create_index_tests {
133130
fn create_index_with_where_clause() {
134131
let sql = "CREATE INDEX index_name ON table_name (column1) WHERE column1 = 1";
135132
let mut expected = create_index_statement();
136-
expected.where_clause = Some(Box::new(binary_op_expression(
133+
expected.where_clause = Some(Box::new(binary_op(
137134
BinaryOp::Equals,
138-
identifier_expression(&["column1"]),
139-
numeric_literal_expression("1"),
135+
identifier_expr(&["column1"]),
136+
numeric_expr("1"),
140137
)));
141138
run_sunny_day_test(sql, Statement::CreateIndex(expected));
142139
}

‎src/parser/create/create_table.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -194,7 +194,7 @@ pub mod test_utils {
194194
#[cfg(test)]
195195
mod create_table_tests {
196196
use crate::{
197-
expression::test_utils::identifier_expression, parser::test_utils::run_sunny_day_test,
197+
expression::test_utils::identifier_expr, parser::test_utils::run_sunny_day_test,
198198
ColumnConstraint, ColumnConstraintType, ColumnDefinition, ConflictClause,
199199
CreateTableColumnDef, CreateTableOption, DataType, Identifier, IndexedColumn, Ordering,
200200
Statement, TableConstraint, TableConstraintType, TableOption,
@@ -293,7 +293,7 @@ mod create_table_tests {
293293
constraint_name: Some(Identifier::from("pk_column_name1")),
294294
constraint_type: TableConstraintType::PrimaryKey(
295295
vec![IndexedColumn {
296-
column: identifier_expression(&["column_name1"]),
296+
column: identifier_expr(&["column_name1"]),
297297
ordering: Some(Ordering::Asc),
298298
}],
299299
ConflictClause::None,

‎src/parser/create/create_trigger.rs

+4-6
Original file line numberDiff line numberDiff line change
@@ -184,9 +184,7 @@ mod create_trigger_tests {
184184
use std::fmt::Display;
185185

186186
use crate::{
187-
expression::test_utils::{
188-
binary_op_expression, identifier_expression, numeric_literal_expression,
189-
},
187+
expression::test_utils::{binary_op, identifier_expr, numeric_expr},
190188
parser::{
191189
create::create_trigger::test_utils::create_trigger_statement,
192190
delete::test_utils::delete_statement, insert::test_utils::insert_statement,
@@ -338,10 +336,10 @@ mod create_trigger_tests {
338336
#[test]
339337
fn create_trigger_with_when_clause() {
340338
let mut expected = create_trigger_statement();
341-
expected.when_clause = Some(binary_op_expression(
339+
expected.when_clause = Some(binary_op(
342340
BinaryOp::Equals,
343-
identifier_expression(&["col1"]),
344-
numeric_literal_expression("1"),
341+
identifier_expr(&["col1"]),
342+
numeric_expr("1"),
345343
));
346344

347345
run_sunny_day_test(

‎src/parser/create/create_virtual_table.rs

+3-6
Original file line numberDiff line numberDiff line change
@@ -74,8 +74,8 @@ mod create_virtual_table_tests {
7474
use test_utils::create_virtual_table_statement;
7575

7676
use crate::{
77-
expression::test_utils::string_literal_expression, parser::test_utils::run_sunny_day_test,
78-
Identifier, Statement,
77+
expression::test_utils::string_expr, parser::test_utils::run_sunny_day_test, Identifier,
78+
Statement,
7979
};
8080

8181
use super::*;
@@ -114,10 +114,7 @@ mod create_virtual_table_tests {
114114
#[test]
115115
fn create_virtual_table_with_module_arguments() {
116116
let mut stmt = create_virtual_table_statement();
117-
stmt.module_arguments = vec![
118-
string_literal_expression("'arg1'"),
119-
string_literal_expression("'arg2'"),
120-
];
117+
stmt.module_arguments = vec![string_expr("'arg1'"), string_expr("'arg2'")];
121118

122119
run_sunny_day_test(
123120
"CREATE VIRTUAL TABLE test_table USING test_module('arg1', 'arg2')",

‎src/parser/delete/mod.rs

+20-27
Original file line numberDiff line numberDiff line change
@@ -103,8 +103,7 @@ mod delete_statement_tests {
103103
use super::test_utils::delete_statement;
104104
use crate::{
105105
expression::test_utils::{
106-
binary_op_expression, collate_expression, identifier_expression,
107-
numeric_literal_expression, string_literal_expression,
106+
binary_op, collate_expr, identifier_expr, numeric_expr, string_expr,
108107
},
109108
parser::test_utils::run_sunny_day_test,
110109
BinaryOp, Identifier, IndexedType, LimitClause, NullsOrdering, Ordering, OrderingTerm,
@@ -178,7 +177,7 @@ mod delete_statement_tests {
178177
#[test]
179178
fn delete_statement_with_where_clause() {
180179
let mut expected_statement = delete_statement();
181-
expected_statement.where_clause = Some(Box::new(numeric_literal_expression("1")));
180+
expected_statement.where_clause = Some(Box::new(numeric_expr("1")));
182181

183182
run_sunny_day_test(
184183
"DELETE FROM table_name1 WHERE 1",
@@ -189,10 +188,10 @@ mod delete_statement_tests {
189188
#[test]
190189
fn delete_statement_with_where_clause_and_column_expression() {
191190
let mut expected_statement = delete_statement();
192-
expected_statement.where_clause = Some(Box::new(binary_op_expression(
191+
expected_statement.where_clause = Some(Box::new(binary_op(
193192
BinaryOp::Equals,
194-
identifier_expression(&["column_1"]),
195-
string_literal_expression("'abc'"),
193+
identifier_expr(&["column_1"]),
194+
string_expr("'abc'"),
196195
)));
197196

198197
run_sunny_day_test(
@@ -217,11 +216,8 @@ mod delete_statement_tests {
217216
let mut expected_statement = delete_statement();
218217
expected_statement.returning_clause = vec![
219218
ReturningClause::Wildcard,
220-
ReturningClause::Expr(numeric_literal_expression("1")),
221-
ReturningClause::ExprWithAlias(
222-
identifier_expression(&["column_1"]),
223-
"alias_1".to_string(),
224-
),
219+
ReturningClause::Expr(numeric_expr("1")),
220+
ReturningClause::ExprWithAlias(identifier_expr(&["column_1"]), "alias_1".to_string()),
225221
];
226222

227223
run_sunny_day_test(
@@ -235,13 +231,13 @@ mod delete_statement_tests {
235231
let mut expected_statement = delete_statement();
236232
expected_statement.order_by = Some(vec![
237233
OrderingTerm {
238-
expression: Box::new(identifier_expression(&["column_1"])),
234+
expression: Box::new(identifier_expr(&["column_1"])),
239235
ordering: Some(Ordering::Asc),
240236
nulls_ordering: None,
241237
},
242238
OrderingTerm {
243-
expression: Box::new(collate_expression(
244-
identifier_expression(&["column_2"]),
239+
expression: Box::new(collate_expr(
240+
identifier_expr(&["column_2"]),
245241
"binary".to_string(),
246242
)),
247243
ordering: None,
@@ -258,7 +254,7 @@ mod delete_statement_tests {
258254
fn delete_statement_with_limit_clause() {
259255
let mut expected_statement = delete_statement();
260256
expected_statement.limit = Some(LimitClause {
261-
limit: Box::new(numeric_literal_expression("10")),
257+
limit: Box::new(numeric_expr("10")),
262258
offset: None,
263259
additional_limit: None,
264260
});
@@ -269,8 +265,8 @@ mod delete_statement_tests {
269265

270266
let mut expected_statement = delete_statement();
271267
expected_statement.limit = Some(LimitClause {
272-
limit: Box::new(numeric_literal_expression("10")),
273-
offset: Some(Box::new(numeric_literal_expression("4"))),
268+
limit: Box::new(numeric_expr("10")),
269+
offset: Some(Box::new(numeric_expr("4"))),
274270
additional_limit: None,
275271
});
276272
run_sunny_day_test(
@@ -280,9 +276,9 @@ mod delete_statement_tests {
280276

281277
let mut expected_statement = delete_statement();
282278
expected_statement.limit = Some(LimitClause {
283-
limit: Box::new(numeric_literal_expression("10")),
279+
limit: Box::new(numeric_expr("10")),
284280
offset: None,
285-
additional_limit: Some(Box::new(numeric_literal_expression("40"))),
281+
additional_limit: Some(Box::new(numeric_expr("40"))),
286282
});
287283
run_sunny_day_test(
288284
"DELETE FROM table_name1 LIMIT 10, 40",
@@ -298,18 +294,15 @@ mod delete_statement_tests {
298294
alias: Some("alias_1".to_string()),
299295
indexed_type: Some(IndexedType::Indexed("index_1".to_string())),
300296
};
301-
expected_statement.where_clause = Some(Box::new(binary_op_expression(
297+
expected_statement.where_clause = Some(Box::new(binary_op(
302298
BinaryOp::Equals,
303-
identifier_expression(&["column_1"]),
304-
string_literal_expression("'abc'"),
299+
identifier_expr(&["column_1"]),
300+
string_expr("'abc'"),
305301
)));
306302
expected_statement.returning_clause = vec![
307303
ReturningClause::Wildcard,
308-
ReturningClause::Expr(numeric_literal_expression("1")),
309-
ReturningClause::ExprWithAlias(
310-
identifier_expression(&["column_1"]),
311-
"alias_1".to_string(),
312-
),
304+
ReturningClause::Expr(numeric_expr("1")),
305+
ReturningClause::ExprWithAlias(identifier_expr(&["column_1"]), "alias_1".to_string()),
313306
];
314307
expected_statement.order_by = None;
315308
expected_statement.limit = None;

‎src/parser/expression/between_expr.rs

+9-17
Original file line numberDiff line numberDiff line change
@@ -79,9 +79,9 @@ mod between_expression_tests {
7979
run_sunny_day_expression_test(
8080
"SELECT 1 BETWEEN 2 AND 3;",
8181
&between_expression(
82-
numeric_literal_expression("1"),
83-
numeric_literal_expression("2"),
84-
numeric_literal_expression("3"),
82+
numeric_expr("1"),
83+
numeric_expr("2"),
84+
numeric_expr("3"),
8585
false,
8686
),
8787
);
@@ -92,13 +92,9 @@ mod between_expression_tests {
9292
run_sunny_day_expression_test(
9393
"SELECT 1 + 2 BETWEEN 3 AND 4;",
9494
&between_expression(
95-
binary_op_expression(
96-
BinaryOp::Plus,
97-
numeric_literal_expression("1"),
98-
numeric_literal_expression("2"),
99-
),
100-
numeric_literal_expression("3"),
101-
numeric_literal_expression("4"),
95+
binary_op(BinaryOp::Plus, numeric_expr("1"), numeric_expr("2")),
96+
numeric_expr("3"),
97+
numeric_expr("4"),
10298
false,
10399
),
104100
);
@@ -109,13 +105,9 @@ mod between_expression_tests {
109105
run_sunny_day_expression_test(
110106
"SELECT 1 + 2 NOT BETWEEN 3 AND 4;",
111107
&between_expression(
112-
binary_op_expression(
113-
BinaryOp::Plus,
114-
numeric_literal_expression("1"),
115-
numeric_literal_expression("2"),
116-
),
117-
numeric_literal_expression("3"),
118-
numeric_literal_expression("4"),
108+
binary_op(BinaryOp::Plus, numeric_expr("1"), numeric_expr("2")),
109+
numeric_expr("3"),
110+
numeric_expr("4"),
119111
true,
120112
),
121113
);

‎src/parser/expression/case_expr.rs

+14-14
Original file line numberDiff line numberDiff line change
@@ -73,10 +73,10 @@ mod case_expression_tests {
7373
fn test_expression_case_basic() {
7474
let expression = None;
7575
let when_expressions = vec![WhenExpression {
76-
condition: Box::new(numeric_literal_expression("1")),
77-
then_expression: Box::new(numeric_literal_expression("2")),
76+
condition: Box::new(numeric_expr("1")),
77+
then_expression: Box::new(numeric_expr("2")),
7878
}];
79-
let else_expression = Some(Box::new(numeric_literal_expression("3")));
79+
let else_expression = Some(Box::new(numeric_expr("3")));
8080

8181
run_sunny_day_expression_test(
8282
"SELECT CASE WHEN 1 THEN 2 ELSE 3 END;",
@@ -89,15 +89,15 @@ mod case_expression_tests {
8989
let expression = None;
9090
let when_expressions = vec![
9191
WhenExpression {
92-
condition: Box::new(numeric_literal_expression("1")),
93-
then_expression: Box::new(numeric_literal_expression("2")),
92+
condition: Box::new(numeric_expr("1")),
93+
then_expression: Box::new(numeric_expr("2")),
9494
},
9595
WhenExpression {
96-
condition: Box::new(numeric_literal_expression("3")),
97-
then_expression: Box::new(numeric_literal_expression("4")),
96+
condition: Box::new(numeric_expr("3")),
97+
then_expression: Box::new(numeric_expr("4")),
9898
},
9999
];
100-
let else_expression = Some(Box::new(numeric_literal_expression("5")));
100+
let else_expression = Some(Box::new(numeric_expr("5")));
101101

102102
run_sunny_day_expression_test(
103103
"SELECT CASE WHEN 1 THEN 2 WHEN 3 THEN 4 ELSE 5 END;",
@@ -107,16 +107,16 @@ mod case_expression_tests {
107107

108108
#[test]
109109
fn test_expression_case_with_main_expression() {
110-
let expression = Some(Box::new(binary_op_expression(
110+
let expression = Some(Box::new(binary_op(
111111
BinaryOp::EqualsEquals,
112-
numeric_literal_expression("1"),
113-
numeric_literal_expression("1"),
112+
numeric_expr("1"),
113+
numeric_expr("1"),
114114
)));
115115
let when_expressions = vec![WhenExpression {
116-
condition: Box::new(boolean_literal_expression(true)),
117-
then_expression: Box::new(numeric_literal_expression("1")),
116+
condition: Box::new(boolean_expr(true)),
117+
then_expression: Box::new(numeric_expr("1")),
118118
}];
119-
let else_expression = Some(Box::new(numeric_literal_expression("2")));
119+
let else_expression = Some(Box::new(numeric_expr("2")));
120120

121121
run_sunny_day_expression_test(
122122
"SELECT CASE 1 == 1 WHEN TRUE THEN 1 ELSE 2 END;",

0 commit comments

Comments
 (0)