IF ELSE statements

src/backend/mysql/query.rs

@@ -147,6 +147,12 @@ impl QueryBuilder for MysqlQueryBuilder {
     fn insert_default_keyword(&self) -> &str {
         "()"
     }
+
+    /// Prefix of the ELSEIF (MySQL)
+    fn elseif_keyword_prefix(&self) -> &str {
+        "ELSE"
+    }
+
 }
 
 impl MysqlQueryBuilder {

src/backend/postgres/query.rs

@@ -174,6 +174,11 @@ impl QueryBuilder for PostgresQueryBuilder {
     fn if_null_function(&self) -> &str {
         "COALESCE"
     }
+
+    /// Prefix of the ELSIF (Postgres)
+    fn elseif_keyword_prefix(&self) -> &str {
+        "ELS"
+    }
 }
 
 fn is_pg_comparison(b: &BinOper) -> bool {

src/backend/query_builder.rs

@@ -387,9 +387,36 @@ pub trait QueryBuilder:
             SimpleExpr::Constant(val) => {
                 self.prepare_constant(val, sql);
             }
+            SimpleExpr::IfElse(val) => {
+                self.prepare_if_else_statement(val, sql);
+            }
         }
     }
 
+    /// Prefix of the ELSEIF (MySQL) vs ELSIF (Postgres) keyword
+    fn elseif_keyword_prefix(&self) -> &str {
+        panic!("ELSEIF/ELSIF keyword prefix not implemented for this backend");
+    }
+
+    fn prepare_if_else_statement(&self, val: &Box<IfElseStatement>, sql: &mut dyn SqlWriter) {
+        write!(sql, "IF ").unwrap();
+        self.prepare_simple_expr(&val.when, sql);
+        write!(sql, " THEN\n").unwrap();
+        self.prepare_simple_expr(&val.then, sql);
+        match &val.otherwise {
+            Some(SimpleExpr::IfElse(value)) => {
+                write!(sql, "\n{}", self.elseif_keyword_prefix()).unwrap();
+                self.prepare_if_else_statement(value, sql);
+            },
+            Some(otherwise) => {
+                write!(sql, "\nELSE\n").unwrap();
+                self.prepare_simple_expr(otherwise, sql);
+                write!(sql, "\nEND IF").unwrap();
+            },
+            None => write!(sql, "\nEND IF").unwrap()
+        };
+    }
+
     /// Translate [`CaseStatement`] into SQL statement.
     fn prepare_case_statement(&self, stmts: &CaseStatement, sql: &mut dyn SqlWriter) {
         write!(sql, "(CASE").unwrap();

src/backend/sqlite/query.rs

@@ -84,4 +84,8 @@ impl QueryBuilder for SqliteQueryBuilder {
         // SQLite doesn't support inserting multiple rows with default values
         write!(sql, "DEFAULT VALUES").unwrap()
     }
+
+    fn prepare_if_else_statement(&self, _val: &Box<IfElseStatement>, _sql: &mut dyn SqlWriter) {
+        panic!("Sqlite doesn't support if-else statements")
+    }
 }

src/expr.rs

@@ -4,7 +4,7 @@
 //!
 //! [`SimpleExpr`] is the expression common among select fields, where clauses and many other places.
 
-use crate::{func::*, query::*, types::*, value::*};
+use crate::{func::*, query::*, types::*, value::*, if_else::*};
 
 /// Helper to build a [`SimpleExpr`].
 #[derive(Debug, Clone)]
@@ -35,6 +35,7 @@ pub enum SimpleExpr {
     AsEnum(DynIden, Box<SimpleExpr>),
     Case(Box<CaseStatement>),
     Constant(Value),
+    IfElse(Box<IfElseStatement>),
 }
 
 /// "Operator" methods for building complex expressions.

src/if_else.rs

@@ -0,0 +1,35 @@
+use crate::{QueryBuilder, SimpleExpr};
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct IfElseStatement {
+    pub when: SimpleExpr,
+    pub then: SimpleExpr,
+    pub otherwise: Option<SimpleExpr>
+}
+
+impl IfElseStatement {
+
+    pub fn new(when: SimpleExpr, then: SimpleExpr, otherwise: Option<SimpleExpr>) -> Self {
+        Self {
+            when,
+            then,
+            otherwise
+        }
+    }
+
+    pub fn to_string<T: QueryBuilder>(&self, query_builder: T) -> String {
+        let mut sql = String::with_capacity(256);
+        query_builder.prepare_if_else_statement(&Box::new(self.clone()), &mut sql);
+        sql
+    }
+
+}
+pub trait IfElseStatementBuilder {
+    /// Build corresponding SQL statement for certain database backend and return SQL string
+    fn build<T: QueryBuilder>(&self, query_builder: T) -> String;
+
+    /// Build corresponding SQL statement for certain database backend and return SQL string
+    fn to_string<T: QueryBuilder>(&self, query_builder: T) -> String {
+        self.build(query_builder)
+    }
+}

src/lib.rs

@@ -826,6 +826,7 @@ pub mod table;
 pub mod token;
 pub mod types;
 pub mod value;
+pub mod if_else;
 
 #[doc(hidden)]
 #[cfg(feature = "tests-cfg")]
@@ -843,6 +844,7 @@ pub use table::*;
 pub use token::*;
 pub use types::*;
 pub use value::*;
+pub use if_else::*;
 
 #[cfg(feature = "derive")]
 pub use sea_query_derive::{enum_def, Iden, IdenStatic};

tests/mysql/if_else.rs

@@ -0,0 +1,94 @@
+use super::*;
+use pretty_assertions::assert_eq;
+
+#[test]
+fn if_without_else() {
+    let query = Query::select().column(Asterisk).from(Glyph::Table).take();
+    let then = SimpleExpr::SubQuery(None, Box::new(query.into_sub_query_statement()));
+    let if_statement = IfElseStatement::new(
+        Expr::col(Glyph::Id).eq(1),
+        then,
+        None
+    );
+    assert_eq!(
+        if_statement.to_string(MysqlQueryBuilder),
+        [
+            "IF `id` = 1 THEN",
+            "(SELECT * FROM `glyph`)",
+            "END IF"
+        ].join("\n")
+    )
+}
+
+#[test]
+fn if_with_else() {
+    let query = Query::select().column(Asterisk).from(Glyph::Table).take();
+    let then = SimpleExpr::SubQuery(None, Box::new(query.into_sub_query_statement()));
+    let if_statement = IfElseStatement::new(
+        Expr::col(Glyph::Id).eq(1),
+        then,
+        Some(Expr::val("23").into())
+    );
+    assert_eq!(
+        if_statement.to_string(MysqlQueryBuilder),
+        [
+            "IF `id` = 1 THEN",
+            "(SELECT * FROM `glyph`)",
+            "ELSE",
+            "'23'",
+            "END IF"
+        ].join("\n")
+    )
+}
+
+#[test]
+fn if_with_elseif() {
+    let query = Query::select().column(Asterisk).from(Glyph::Table).take();
+    let then = SimpleExpr::SubQuery(None, Box::new(query.into_sub_query_statement()));
+    let if_statement = IfElseStatement::new(
+        Expr::col(Glyph::Id).eq(1),
+        then,
+        Some(SimpleExpr::IfElse(Box::new(IfElseStatement::new(
+            Expr::col(Glyph::Id).eq(2),
+            Expr::val("42").into(),
+            None
+        ))))
+    );
+    assert_eq!(
+        if_statement.to_string(MysqlQueryBuilder),
+        [
+            "IF `id` = 1 THEN",
+            "(SELECT * FROM `glyph`)",
+            "ELSEIF `id` = 2 THEN",
+            "'42'",
+            "END IF"
+        ].join("\n")
+    )
+}
+
+#[test]
+fn if_with_elseif_and_else() {
+    let query = Query::select().column(Asterisk).from(Glyph::Table).take();
+    let then = SimpleExpr::SubQuery(None, Box::new(query.into_sub_query_statement()));
+    let if_statement = IfElseStatement::new(
+        Expr::col(Glyph::Id).eq(1),
+        then,
+        Some(SimpleExpr::IfElse(Box::new(IfElseStatement::new(
+            Expr::col(Glyph::Id).eq(2),
+            Expr::val("42").into(),
+            Some(Expr::val("9000").into())
+        ))))
+    );
+    assert_eq!(
+        if_statement.to_string(MysqlQueryBuilder),
+        [
+            "IF `id` = 1 THEN",
+            "(SELECT * FROM `glyph`)",
+            "ELSEIF `id` = 2 THEN",
+            "'42'",
+            "ELSE",
+            "'9000'",
+            "END IF"
+        ].join("\n")
+    );
+}

tests/mysql/mod.rs

@@ -4,6 +4,7 @@ mod foreign_key;
 mod index;
 mod query;
 mod table;
+mod if_else;
 
 #[path = "../common.rs"]
 mod common;

tests/postgres/if_else.rs

@@ -0,0 +1,67 @@
+use super::*;
+use pretty_assertions::assert_eq;
+
+#[test]
+fn if_without_else() {
+    let query = Query::select().column(Asterisk).from(Glyph::Table).take();
+    let then = SimpleExpr::SubQuery(None, Box::new(query.into_sub_query_statement()));
+    let if_statement = IfElseStatement::new(
+        Expr::col(Glyph::Id).eq(1),
+        then,
+        None
+    );
+    assert_eq!(
+        if_statement.to_string(MysqlQueryBuilder),
+        [
+            "IF `id` = 1 THEN",
+            "(SELECT * FROM `glyph`)",
+            "END IF"
+        ].join("\n")
+    )
+}
+
+#[test]
+fn if_with_else() {
+    let query = Query::select().column(Asterisk).from(Glyph::Table).take();
+    let then = SimpleExpr::SubQuery(None, Box::new(query.into_sub_query_statement()));
+    let if_statement = IfElseStatement::new(
+        Expr::col(Glyph::Id).eq(1),
+        then,
+        Some(Expr::val("23").into())
+    );
+    assert_eq!(
+        if_statement.to_string(PostgresQueryBuilder),
+        [
+            "IF \"id\" = 1 THEN",
+            "(SELECT * FROM \"glyph\")",
+            "ELSE",
+            "'23'",
+            "END IF"
+        ].join("\n")
+    )
+}
+
+#[test]
+fn if_with_elseif() {
+    let query = Query::select().column(Asterisk).from(Glyph::Table).take();
+    let then = SimpleExpr::SubQuery(None, Box::new(query.into_sub_query_statement()));
+    let if_statement = IfElseStatement::new(
+        Expr::col(Glyph::Id).eq(1),
+        then,
+        Some(SimpleExpr::IfElse(Box::new(IfElseStatement::new(
+            Expr::col(Glyph::Id).eq(2),
+            Expr::val("123").into(),
+            None
+        ))))
+    );
+    assert_eq!(
+        if_statement.to_string(PostgresQueryBuilder),
+        [
+            "IF \"id\" = 1 THEN",
+            "(SELECT * FROM \"glyph\")",
+            "ELSIF \"id\" = 2 THEN",
+            "'123'",
+            "END IF"
+        ].join("\n")
+    )
+}

tests/postgres/mod.rs

@@ -5,6 +5,7 @@ mod index;
 mod query;
 mod table;
 mod types;
+mod if_else;
 
 #[path = "../common.rs"]
 mod common;

tests/sqlite/mod.rs

@@ -4,6 +4,7 @@ mod foreign_key;
 mod index;
 mod query;
 mod table;
+mod unsupported;
 
 #[path = "../common.rs"]
 mod common;

tests/sqlite/unsupported.rs

@@ -0,0 +1,12 @@
+use super::*;
+
+#[test]
+#[should_panic]
+fn if_else_statement_is_unsupported() {
+    let if_statement = IfElseStatement::new(
+        Expr::col(Glyph::Id).eq(1),
+        Expr::val("23").into(),
+        None
+    );
+    if_statement.to_string(SqliteQueryBuilder);
+}