Use SeaRc

src/connector/paginator.rs

@@ -24,7 +24,8 @@ where
 {
     /// Fetch a specific page
     pub async fn fetch_page(&self, page: usize) -> Result<Vec<S::Item>, QueryErr> {
-        let query = self.query
+        let query = self
+            .query
             .clone()
             .limit(self.page_size as u64)
             .offset((self.page_size * page) as u64)

src/entity/column.rs

@@ -1,8 +1,6 @@
 use crate::{EntityName, IdenStatic, Iterable};
 pub use sea_query::ColumnType;
-use sea_query::{Expr, Iden, SimpleExpr, Value};
+use sea_query::{DynIden, Expr, SeaRc, SimpleExpr, Value};
-
-use std::rc::Rc;
 
 macro_rules! bind_oper {
     ( $op: ident ) => {
@@ -41,12 +39,12 @@ pub trait ColumnTrait: IdenStatic + Iterable {
 
     fn def(&self) -> ColumnType;
 
-    fn entity_name(&self) -> Rc<dyn Iden> {
+    fn entity_name(&self) -> DynIden {
-        Rc::new(Self::EntityName::default()) as Rc<dyn Iden>
+        SeaRc::new(Self::EntityName::default()) as DynIden
     }
 
-    fn as_column_ref(&self) -> (Rc<dyn Iden>, Rc<dyn Iden>) {
+    fn as_column_ref(&self) -> (DynIden, DynIden) {
-        (self.entity_name(), Rc::new(*self) as Rc<dyn Iden>)
+        (self.entity_name(), SeaRc::new(*self) as DynIden)
     }
 
     bind_oper!(eq);

src/entity/identity.rs

@@ -1,12 +1,11 @@
 use crate::IdenStatic;
-use sea_query::{Iden, IntoIden};
+use sea_query::{DynIden, IntoIden};
-use std::rc::Rc;
 
 #[derive(Debug, Clone)]
 pub enum Identity {
-    Unary(Rc<dyn Iden>),
+    Unary(DynIden),
-    Binary(Rc<dyn Iden>, Rc<dyn Iden>),
+    Binary(DynIden, DynIden),
-    // Ternary(Rc<dyn Iden>, Rc<dyn Iden>, Rc<dyn Iden>),
+    // Ternary(DynIden, DynIden, DynIden),
 }
 
 pub trait IntoIdentity {

src/entity/relation.rs

@@ -1,8 +1,7 @@
 use crate::{EntityTrait, Identity, IntoIdentity, Iterable, Select, SelectHelper};
 use core::marker::PhantomData;
-use sea_query::{Iden, IntoIden, JoinType};
+use sea_query::{DynIden, IntoIden, JoinType};
 use std::fmt::Debug;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub enum RelationType {
@@ -31,8 +30,8 @@ where
 
 pub struct RelationDef {
     pub rel_type: RelationType,
-    pub from_tbl: Rc<dyn Iden>,
+    pub from_tbl: DynIden,
-    pub to_tbl: Rc<dyn Iden>,
+    pub to_tbl: DynIden,
     pub from_col: Identity,
     pub to_col: Identity,
 }
@@ -44,8 +43,8 @@ where
 {
     entities: PhantomData<(E, R)>,
     rel_type: RelationType,
-    from_tbl: Rc<dyn Iden>,
+    from_tbl: DynIden,
-    to_tbl: Rc<dyn Iden>,
+    to_tbl: DynIden,
     from_col: Option<Identity>,
     to_col: Option<Identity>,
 }

src/query/combine.rs

@@ -1,8 +1,7 @@
 use crate::{EntityTrait, IntoSimpleExpr, Iterable, QueryTrait, Select, SelectTwo};
 use core::marker::PhantomData;
 pub use sea_query::JoinType;
-use sea_query::{Alias, ColumnRef, Iden, SelectExpr, SelectStatement, SimpleExpr};
+use sea_query::{Alias, ColumnRef, Iden, SeaRc, SelectExpr, SelectStatement, SimpleExpr};
-use std::rc::Rc;
 
 pub const SELECT_A: &str = "A_";
 pub const SELECT_B: &str = "B_";
@@ -16,7 +15,7 @@ where
             match &sel.alias {
                 Some(alias) => {
                     let alias = format!("{}{}", pre, alias.to_string().as_str());
-                    sel.alias = Some(Rc::new(Alias::new(&alias)));
+                    sel.alias = Some(SeaRc::new(Alias::new(&alias)));
                 }
                 None => {
                     let col = match &sel.expr {
@@ -27,7 +26,7 @@ where
                         _ => panic!("cannot apply alias for expr other than Column"),
                     };
                     let alias = format!("{}{}", pre, col.to_string().as_str());
-                    sel.alias = Some(Rc::new(Alias::new(&alias)));
+                    sel.alias = Some(SeaRc::new(Alias::new(&alias)));
                 }
             };
         });
@@ -61,7 +60,7 @@ where
             let alias = format!("{}{}", SELECT_B, col.to_string().as_str());
             self.query.expr(SelectExpr {
                 expr: col.into_simple_expr(),
-                alias: Some(Rc::new(Alias::new(&alias))),
+                alias: Some(SeaRc::new(Alias::new(&alias))),
             });
         }
         self

src/query/helper.rs

@@ -3,8 +3,7 @@ use crate::{
     RelationDef,
 };
 use sea_query::{Alias, Expr, IntoCondition, SelectExpr, SelectStatement, SimpleExpr};
-pub use sea_query::{Condition, ConditionalStatement, JoinType, Order};
+pub use sea_query::{Condition, ConditionalStatement, DynIden, JoinType, Order, SeaRc};
-use std::rc::Rc;
 
 pub trait SelectHelper: Sized {
     fn query(&mut self) -> &mut SelectStatement;
@@ -55,7 +54,7 @@ pub trait SelectHelper: Sized {
     {
         self.query().expr(SelectExpr {
             expr: col.into_simple_expr(),
-            alias: Some(Rc::new(Alias::new(alias))),
+            alias: Some(SeaRc::new(Alias::new(alias))),
         });
         self
     }
@@ -243,11 +242,11 @@ fn join_condition(rel: RelationDef) -> SimpleExpr {
 
     match (owner_keys, foreign_keys) {
         (Identity::Unary(o1), Identity::Unary(f1)) => {
-            Expr::tbl(Rc::clone(&from_tbl), o1).equals(Rc::clone(&to_tbl), f1)
+            Expr::tbl(SeaRc::clone(&from_tbl), o1).equals(SeaRc::clone(&to_tbl), f1)
         }
-        (Identity::Binary(o1, o2), Identity::Binary(f1, f2)) => Expr::tbl(Rc::clone(&from_tbl), o1)
+        (Identity::Binary(o1, o2), Identity::Binary(f1, f2)) => Expr::tbl(SeaRc::clone(&from_tbl), o1)
-            .equals(Rc::clone(&to_tbl), f1)
+            .equals(SeaRc::clone(&to_tbl), f1)
-            .and(Expr::tbl(Rc::clone(&from_tbl), o2).equals(Rc::clone(&to_tbl), f2)),
+            .and(Expr::tbl(SeaRc::clone(&from_tbl), o2).equals(SeaRc::clone(&to_tbl), f2)),
         _ => panic!("Owner key and foreign key mismatch"),
     }
 }

src/query/select.rs

@@ -2,8 +2,7 @@ use crate::{ColumnTrait, EntityTrait, Iterable, QueryFilter, QueryTrait, SelectH
 use core::fmt::Debug;
 use core::marker::PhantomData;
 pub use sea_query::JoinType;
-use sea_query::{Iden, IntoColumnRef, IntoIden, SelectStatement, SimpleExpr};
+use sea_query::{DynIden, IntoColumnRef, IntoIden, SeaRc, SelectStatement, SimpleExpr};
-use std::rc::Rc;
 
 #[derive(Clone, Debug)]
 pub struct Select<E>
@@ -103,8 +102,8 @@ where
         self
     }
 
-    fn column_list(&self) -> Vec<(Rc<dyn Iden>, E::Column)> {
+    fn column_list(&self) -> Vec<(DynIden, E::Column)> {
-        let table = Rc::new(E::default()) as Rc<dyn Iden>;
+        let table = SeaRc::new(E::default()) as DynIden;
         E::Column::iter().map(|col| (table.clone(), col)).collect()
     }