Cast expression as custom type

src/backend/postgres/query.rs

@@ -77,4 +77,19 @@ impl QueryBuilder for PostgresQueryBuilder {
             _ => self.prepare_function_common(function, sql, collector),
         }
     }
+
+    fn prepare_simple_expr(
+        &self,
+        simple_expr: &SimpleExpr,
+        sql: &mut SqlWriter,
+        collector: &mut dyn FnMut(Value),
+    ) {
+        match simple_expr {
+            SimpleExpr::AsEnum(type_name, expr) => {
+                let simple_expr = expr.clone().cast_as(SeaRc::clone(type_name));
+                self.prepare_simple_expr_common(&simple_expr, sql, collector);
+            }
+            _ => QueryBuilder::prepare_simple_expr_common(self, simple_expr, sql, collector),
+        }
+    }
 }

src/backend/query_builder.rs

@@ -225,6 +225,15 @@ pub trait QueryBuilder: QuotedBuilder {
         simple_expr: &SimpleExpr,
         sql: &mut SqlWriter,
         collector: &mut dyn FnMut(Value),
+    ) {
+        self.prepare_simple_expr_common(simple_expr, sql, collector);
+    }
+
+    fn prepare_simple_expr_common(
+        &self,
+        simple_expr: &SimpleExpr,
+        sql: &mut SqlWriter,
+        collector: &mut dyn FnMut(Value),
     ) {
         match simple_expr {
             SimpleExpr::Column(column_ref) => {
@@ -328,6 +337,9 @@ pub trait QueryBuilder: QuotedBuilder {
             SimpleExpr::Keyword(keyword) => {
                 self.prepare_keyword(keyword, sql, collector);
             }
+            SimpleExpr::AsEnum(_, expr) => {
+                self.prepare_simple_expr(expr, sql, collector);
+            }
         }
     }
 

src/expr.rs

@@ -33,6 +33,7 @@ pub enum SimpleExpr {
     Custom(String),
     CustomWithValues(String, Vec<Value>),
     Keyword(Keyword),
+    AsEnum(DynIden, Box<SimpleExpr>),
 }
 
 impl Expr {
@@ -1424,6 +1425,57 @@ impl Expr {
         self.into()
     }
 
+    /// Express a `AS enum` expression.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use sea_query::{tests_cfg::*, *};
+    ///
+    /// let query = Query::select()
+    ///     .expr(Expr::col(Char::FontSize).as_enum(Alias::new("text")))
+    ///     .from(Char::Table)
+    ///     .to_owned();
+    ///
+    /// assert_eq!(
+    ///     query.to_string(MysqlQueryBuilder),
+    ///     r#"SELECT `font_size` FROM `character`"#
+    /// );
+    /// assert_eq!(
+    ///     query.to_string(PostgresQueryBuilder),
+    ///     r#"SELECT CAST("font_size" AS text) FROM "character""#
+    /// );
+    /// assert_eq!(
+    ///     query.to_string(SqliteQueryBuilder),
+    ///     r#"SELECT `font_size` FROM `character`"#
+    /// );
+    ///
+    /// let query = Query::insert()
+    ///     .into_table(Char::Table)
+    ///     .columns(vec![Char::FontSize])
+    ///     .exprs_panic(vec![Expr::val("large").as_enum(Alias::new("FontSizeEnum"))])
+    ///     .to_owned();
+    ///
+    /// assert_eq!(
+    ///     query.to_string(MysqlQueryBuilder),
+    ///     r#"INSERT INTO `character` (`font_size`) VALUES ('large')"#
+    /// );
+    /// assert_eq!(
+    ///     query.to_string(PostgresQueryBuilder),
+    ///     r#"INSERT INTO "character" ("font_size") VALUES (CAST('large' AS FontSizeEnum))"#
+    /// );
+    /// assert_eq!(
+    ///     query.to_string(SqliteQueryBuilder),
+    ///     r#"INSERT INTO `character` (`font_size`) VALUES ('large')"#
+    /// );
+    /// ```
+    pub fn as_enum<T>(self, type_name: T) -> SimpleExpr
+    where
+        T: IntoIden,
+    {
+        SimpleExpr::AsEnum(type_name.into_iden(), Box::new(self.into()))
+    }
+
     fn func_with_args(func: Function, args: Vec<SimpleExpr>) -> SimpleExpr {
         let mut expr = Expr::new();
         expr.func = Some(func);
@@ -1793,4 +1845,41 @@ impl SimpleExpr {
     {
         self.concatenate(right)
     }
+
+    /// Express a `CAST AS` expression.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use sea_query::{tests_cfg::*, *};
+    ///
+    /// let query = Query::select()
+    ///     .expr(Expr::value("1").cast_as(Alias::new("integer")))
+    ///     .to_owned();
+    ///
+    /// assert_eq!(
+    ///     query.to_string(MysqlQueryBuilder),
+    ///     r#"SELECT CAST('1' AS integer)"#
+    /// );
+    /// assert_eq!(
+    ///     query.to_string(PostgresQueryBuilder),
+    ///     r#"SELECT CAST('1' AS integer)"#
+    /// );
+    /// assert_eq!(
+    ///     query.to_string(SqliteQueryBuilder),
+    ///     r#"SELECT CAST('1' AS integer)"#
+    /// );
+    /// ```
+    pub fn cast_as<T>(self, type_name: T) -> Self
+    where
+        T: IntoIden,
+    {
+        Self::FunctionCall(
+            Function::Cast,
+            vec![self.binary(
+                BinOper::As,
+                Expr::cust(type_name.into_iden().to_string().as_str()),
+            )],
+        )
+    }
 }