Skip to content

Unify Expr and SimpleExpr #888

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
Huliiiiii wants to merge 1 commit into from
Closed

Unify Expr and SimpleExpr #888

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion src/backend/mod.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -92,7 +92,7 @@ pub trait PrecedenceDecider {
// but dropping parentheses due to these relations can be confusing for readers.
fn inner_expr_well_known_greater_precedence(
&self,
inner: &SimpleExpr,
inner: &Expr,
outer_oper: &Oper,
) -> bool;
}
Expand Down
2 changes: 1 addition & 1 deletion src/backend/mysql/mod.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -30,7 +30,7 @@ impl TableRefBuilder for MysqlQueryBuilder {}
impl PrecedenceDecider for MysqlQueryBuilder {
fn inner_expr_well_known_greater_precedence(
&self,
inner: &SimpleExpr,
inner: &Expr,
outer_oper: &Oper,
) -> bool {
common_inner_expr_well_known_greater_precedence(inner, outer_oper)
Expand Down
8 changes: 4 additions & 4 deletions src/backend/postgres/query.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -12,12 +12,12 @@ impl OperLeftAssocDecider for PostgresQueryBuilder {
impl PrecedenceDecider for PostgresQueryBuilder {
fn inner_expr_well_known_greater_precedence(
&self,
inner: &SimpleExpr,
inner: &Expr,
outer_oper: &Oper,
) -> bool {
let common_answer = common_inner_expr_well_known_greater_precedence(inner, outer_oper);
let pg_specific_answer = match inner {
SimpleExpr::Binary(_, inner_bin_oper, _) => {
Expr::Binary(_, inner_bin_oper, _) => {
let inner_oper: Oper = (*inner_bin_oper).into();
if inner_oper.is_arithmetic() || inner_oper.is_shift() {
is_ilike(inner_bin_oper)
Expand All @@ -38,9 +38,9 @@ impl QueryBuilder for PostgresQueryBuilder {
("$", true)
}

fn prepare_simple_expr(&self, simple_expr: &SimpleExpr, sql: &mut dyn SqlWriter) {
fn prepare_simple_expr(&self, simple_expr: &Expr, sql: &mut dyn SqlWriter) {
match simple_expr {
SimpleExpr::AsEnum(type_name, expr) => {
Expr::AsEnum(type_name, expr) => {
write!(sql, "CAST(").unwrap();
self.prepare_simple_expr_common(expr, sql);
let q = self.quote();
Expand Down
82 changes: 36 additions & 46 deletions src/backend/query_builder.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -351,20 +351,20 @@ pub trait QueryBuilder:
}
}

/// Translate [`SimpleExpr`] into SQL statement.
fn prepare_simple_expr(&self, simple_expr: &SimpleExpr, sql: &mut dyn SqlWriter) {
/// Translate [`Expr`] into SQL statement.
fn prepare_simple_expr(&self, simple_expr: &Expr, sql: &mut dyn SqlWriter) {
self.prepare_simple_expr_common(simple_expr, sql);
}

fn prepare_simple_expr_common(&self, simple_expr: &SimpleExpr, sql: &mut dyn SqlWriter) {
fn prepare_simple_expr_common(&self, simple_expr: &Expr, sql: &mut dyn SqlWriter) {
match simple_expr {
SimpleExpr::Column(column_ref) => {
Expr::Column(column_ref) => {
self.prepare_column_ref(column_ref, sql);
}
SimpleExpr::Tuple(exprs) => {
Expr::Tuple(exprs) => {
self.prepare_tuple(exprs, sql);
}
SimpleExpr::Unary(op, expr) => {
Expr::Unary(op, expr) => {
self.prepare_un_oper(op, sql);
write!(sql, " ").unwrap();
let drop_expr_paren =
Expand All @@ -377,31 +377,31 @@ pub trait QueryBuilder:
write!(sql, ")").unwrap();
}
}
SimpleExpr::FunctionCall(func) => {
Expr::FunctionCall(func) => {
self.prepare_function_name(&func.func, sql);
self.prepare_function_arguments(func, sql);
}
SimpleExpr::Binary(left, op, right) => match (op, right.as_ref()) {
(BinOper::In, SimpleExpr::Tuple(t)) if t.is_empty() => {
Expr::Binary(left, op, right) => match (op, right.as_ref()) {
(BinOper::In, Expr::Tuple(t)) if t.is_empty() => {
self.binary_expr(&1i32.into(), &BinOper::Equal, &2i32.into(), sql)
}
(BinOper::NotIn, SimpleExpr::Tuple(t)) if t.is_empty() => {
(BinOper::NotIn, Expr::Tuple(t)) if t.is_empty() => {
self.binary_expr(&1i32.into(), &BinOper::Equal, &1i32.into(), sql)
}
_ => self.binary_expr(left, op, right, sql),
},
SimpleExpr::SubQuery(oper, sel) => {
Expr::SubQuery(oper, sel) => {
if let Some(oper) = oper {
self.prepare_sub_query_oper(oper, sql);
}
write!(sql, "(").unwrap();
self.prepare_query_statement(sel.deref(), sql);
write!(sql, ")").unwrap();
}
SimpleExpr::Value(val) => {
Expr::Value(val) => {
self.prepare_value(val, sql);
}
SimpleExpr::Values(list) => {
Expr::Values(list) => {
write!(sql, "(").unwrap();
list.iter().fold(true, |first, val| {
if !first {
Expand All @@ -412,10 +412,10 @@ pub trait QueryBuilder:
});
write!(sql, ")").unwrap();
}
SimpleExpr::Custom(s) => {
Expr::Custom(s) => {
write!(sql, "{s}").unwrap();
}
SimpleExpr::CustomWithExpr(expr, values) => {
Expr::CustomWithExpr(expr, values) => {
let (placeholder, numbered) = self.placeholder();
let mut tokenizer = Tokenizer::new(expr).iter().peekable();
let mut count = 0;
Expand All @@ -441,16 +441,16 @@ pub trait QueryBuilder:
};
}
}
SimpleExpr::Keyword(keyword) => {
Expr::Keyword(keyword) => {
self.prepare_keyword(keyword, sql);
}
SimpleExpr::AsEnum(_, expr) => {
Expr::AsEnum(_, expr) => {
self.prepare_simple_expr(expr, sql);
}
SimpleExpr::Case(case_stmt) => {
Expr::Case(case_stmt) => {
self.prepare_case_statement(case_stmt, sql);
}
SimpleExpr::Constant(val) => {
Expr::Constant(val) => {
self.prepare_constant(val, sql);
}
}
Expand Down Expand Up @@ -703,8 +703,8 @@ pub trait QueryBuilder:
write!(sql, " {oper} ").unwrap();
}
let both_binary = match simple_expr {
SimpleExpr::Binary(_, _, right) => {
matches!(right.as_ref(), SimpleExpr::Binary(_, _, _))
Expr::Binary(_, _, right) => {
matches!(right.as_ref(), Expr::Binary(_, _, _))
}
_ => false,
};
Expand Down Expand Up @@ -1028,8 +1028,8 @@ pub trait QueryBuilder:
});
}

/// Translate [`SimpleExpr::Tuple`] into SQL statement.
fn prepare_tuple(&self, exprs: &[SimpleExpr], sql: &mut dyn SqlWriter) {
/// Translate [`Expr::Tuple`] into SQL statement.
fn prepare_tuple(&self, exprs: &[Expr], sql: &mut dyn SqlWriter) {
write!(sql, "(").unwrap();
for (i, expr) in exprs.iter().enumerate() {
if i != 0 {
Expand Down Expand Up @@ -1454,13 +1454,7 @@ pub trait QueryBuilder:

#[doc(hidden)]
/// Translate a binary expr to SQL.
fn binary_expr(
&self,
left: &SimpleExpr,
op: &BinOper,
right: &SimpleExpr,
sql: &mut dyn SqlWriter,
) {
fn binary_expr(&self, left: &Expr, op: &BinOper, right: &Expr, sql: &mut dyn SqlWriter) {
// If left has higher precedence than op, we can drop parentheses around left
let drop_left_higher_precedence =
self.inner_expr_well_known_greater_precedence(left, &(*op).into());
Expand Down Expand Up @@ -1499,7 +1493,7 @@ pub trait QueryBuilder:
&& matches!(right.get_bin_oper(), Some(&BinOper::Escape));

// Due to custom representation of casting AS datatype
let drop_right_as_hack = (op == &BinOper::As) && matches!(right, SimpleExpr::Custom(_));
let drop_right_as_hack = (op == &BinOper::As) && matches!(right, Expr::Custom(_));

let right_paren = !drop_right_higher_precedence
&& !drop_right_escape_hack
Expand Down Expand Up @@ -1615,11 +1609,7 @@ impl OperLeftAssocDecider for CommonSqlQueryBuilder {
}

impl PrecedenceDecider for CommonSqlQueryBuilder {
fn inner_expr_well_known_greater_precedence(
&self,
inner: &SimpleExpr,
outer_oper: &Oper,
) -> bool {
fn inner_expr_well_known_greater_precedence(&self, inner: &Expr, outer_oper: &Oper) -> bool {
common_inner_expr_well_known_greater_precedence(inner, outer_oper)
}
}
Expand Down Expand Up @@ -1649,7 +1639,7 @@ impl TableRefBuilder for CommonSqlQueryBuilder {}
allow(unreachable_code, unused_variables)
)]
pub(crate) fn common_inner_expr_well_known_greater_precedence(
inner: &SimpleExpr,
inner: &Expr,
outer_oper: &Oper,
) -> bool {
match inner {
Expand All @@ -1658,15 +1648,15 @@ pub(crate) fn common_inner_expr_well_known_greater_precedence(
// We do not need to wrap with parentheses:
// Columns, tuples (already wrapped), constants, function calls, values,
// keywords, subqueries (already wrapped), case (already wrapped)
SimpleExpr::Column(_)
| SimpleExpr::Tuple(_)
| SimpleExpr::Constant(_)
| SimpleExpr::FunctionCall(_)
| SimpleExpr::Value(_)
| SimpleExpr::Keyword(_)
| SimpleExpr::Case(_)
| SimpleExpr::SubQuery(_, _) => true,
SimpleExpr::Binary(_, inner_oper, _) => {
Expr::Column(_)
| Expr::Tuple(_)
| Expr::Constant(_)
| Expr::FunctionCall(_)
| Expr::Value(_)
| Expr::Keyword(_)
| Expr::Case(_)
| Expr::SubQuery(_, _) => true,
Expr::Binary(_, inner_oper, _) => {
#[cfg(feature = "option-more-parentheses")]
{
return false;
Expand Down
2 changes: 1 addition & 1 deletion src/backend/sqlite/mod.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -36,7 +36,7 @@ impl TableRefBuilder for SqliteQueryBuilder {}
impl PrecedenceDecider for SqliteQueryBuilder {
fn inner_expr_well_known_greater_precedence(
&self,
inner: &SimpleExpr,
inner: &Expr,
outer_oper: &Oper,
) -> bool {
common_inner_expr_well_known_greater_precedence(inner, outer_oper)
Expand Down
4 changes: 2 additions & 2 deletions src/backend/table_builder.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -195,14 +195,14 @@ pub trait TableBuilder:
}

/// Translate the check constraint into SQL statement
fn prepare_check_constraint(&self, check: &SimpleExpr, sql: &mut dyn SqlWriter) {
fn prepare_check_constraint(&self, check: &Expr, sql: &mut dyn SqlWriter) {
write!(sql, "CHECK (").unwrap();
QueryBuilder::prepare_simple_expr(self, check, sql);
write!(sql, ")").unwrap();
}

/// Translate the generated column into SQL statement
fn prepare_generated_column(&self, gen: &SimpleExpr, stored: bool, sql: &mut dyn SqlWriter) {
fn prepare_generated_column(&self, gen: &Expr, stored: bool, sql: &mut dyn SqlWriter) {
write!(sql, "GENERATED ALWAYS AS (").unwrap();
QueryBuilder::prepare_simple_expr(self, gen, sql);
write!(sql, ")").unwrap();
Expand Down
Loading