Rename & Refactoring

src/backend/postgres/query.rs

@@ -85,8 +85,8 @@ impl QueryBuilder for PostgresQueryBuilder {
         collector: &mut dyn FnMut(Value),
     ) {
         match simple_expr {
-            SimpleExpr::EnumValue(type_name, expr) => {
-                let simple_expr = expr.clone().cast_expr_as(type_name);
+            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

@@ -337,7 +337,7 @@ pub trait QueryBuilder: QuotedBuilder {
             SimpleExpr::Keyword(keyword) => {
                 self.prepare_keyword(keyword, sql, collector);
             }
-            SimpleExpr::EnumValue(_, expr) => {
+            SimpleExpr::AsEnum(_, expr) => {
                 self.prepare_simple_expr(expr, sql, collector);
             }
         }

src/expr.rs

@@ -33,7 +33,7 @@ pub enum SimpleExpr {
     Custom(String),
     CustomWithValues(String, Vec<Value>),
     Keyword(Keyword),
-    EnumValue(String, Box<SimpleExpr>),
+    AsEnum(DynIden, Box<SimpleExpr>),
 }
 
 impl Expr {
@@ -1425,12 +1425,11 @@ impl Expr {
         self.into()
     }
 
-    pub fn enum_value<T, I>(type_name: T, expr: I) -> SimpleExpr
+    pub fn as_enum<T>(self, type_name: T) -> SimpleExpr
     where
-        T: ToString,
-        I: Into<SimpleExpr>,
+        T: IntoIden,
     {
-        SimpleExpr::EnumValue(type_name.to_string(), Box::new(expr.into()))
+        SimpleExpr::AsEnum(type_name.into_iden(), Box::new(self.into()))
     }
 
     fn func_with_args(func: Function, args: Vec<SimpleExpr>) -> SimpleExpr {
@@ -1803,11 +1802,16 @@ impl SimpleExpr {
         self.concatenate(right)
     }
 
-    pub fn cast_expr_as<T>(self, type_name: T) -> Self
+    pub fn cast_as<T>(self, type_name: T) -> Self
     where
-        T: ToString,
+        T: IntoIden,
     {
-        Self::FunctionCall(Function::Cast, vec![self])
-            .binary(BinOper::As, Expr::cust(type_name.to_string().as_str()))
+        Self::FunctionCall(
+            Function::Cast,
+            vec![self.binary(
+                BinOper::As,
+                Expr::cust(type_name.into_iden().to_string().as_str()),
+            )],
+        )
     }
 }