refactor's to make the code base more scalable to receive more feature flags

Author: belchior

src/behavior.rs

@@ -16,7 +16,7 @@ pub fn raw_queries<'a, Clause: PartialEq>(raw_list: &'a Vec<(Clause, String)>, c
     .collect::<Vec<_>>()
 }
 
-/// Represents all statements that can be used in the with method
+/// Represents all statements that can be used inside the with method
 pub trait WithQuery: Concat {}
 
 pub trait Concat {
@@ -40,7 +40,7 @@ pub fn concat_raw_before_after<Clause: PartialEq>(
   format!("{query}{raw_before}{space_before}{sql}{raw_after}{space_after}")
 }
 
-pub trait ConcatMethods<'a, Clause: PartialEq> {
+pub trait ConcatSqlStandard<'a, Clause: PartialEq> {
   fn concat_from(
     &self,
     items_raw_before: &Vec<(Clause, String)>,
@@ -71,8 +71,7 @@ pub trait ConcatMethods<'a, Clause: PartialEq> {
     format!("{query}{raw_sql}{space}{lb}")
   }
 
-  #[cfg(feature = "postgresql")]
-  fn concat_returning(
+  fn concat_values(
     &self,
     items_raw_before: &Vec<(Clause, String)>,
     items_raw_after: &Vec<(Clause, String)>,
@@ -81,18 +80,19 @@ pub trait ConcatMethods<'a, Clause: PartialEq> {
     clause: Clause,
     items: &Vec<String>,
   ) -> String {
-    let fmt::Formatter { lb, space, comma, .. } = fmts;
+    let fmt::Formatter { comma, lb, space, .. } = fmts;
     let sql = if items.is_empty() == false {
-      let output_names = items.join(comma);
-      format!("RETURNING{space}{output_names}{space}{lb}")
+      let sep = format!("{comma}{lb}");
+      let values = items.join(&sep);
+      format!("VALUES{space}{lb}{values}{space}{lb}")
     } else {
       "".to_owned()
     };
 
     concat_raw_before_after(items_raw_before, items_raw_after, query, fmts, clause, sql)
   }
 
-  fn concat_values(
+  fn concat_where(
     &self,
     items_raw_before: &Vec<(Clause, String)>,
     items_raw_after: &Vec<(Clause, String)>,
@@ -101,19 +101,21 @@ pub trait ConcatMethods<'a, Clause: PartialEq> {
     clause: Clause,
     items: &Vec<String>,
   ) -> String {
-    let fmt::Formatter { comma, lb, space, .. } = fmts;
+    let fmt::Formatter { lb, space, indent, .. } = fmts;
     let sql = if items.is_empty() == false {
-      let sep = format!("{comma}{lb}");
-      let values = items.join(&sep);
-      format!("VALUES{space}{lb}{values}{space}{lb}")
+      let conditions = items.join(&format!("{space}{lb}{indent}AND{space}"));
+      format!("WHERE{space}{conditions}{space}{lb}")
     } else {
       "".to_owned()
     };
 
     concat_raw_before_after(items_raw_before, items_raw_after, query, fmts, clause, sql)
   }
+}
 
-  fn concat_where(
+#[cfg(feature = "postgresql")]
+pub trait ConcatPostgres<'a, Clause: PartialEq> {
+  fn concat_returning(
     &self,
     items_raw_before: &Vec<(Clause, String)>,
     items_raw_after: &Vec<(Clause, String)>,
@@ -122,18 +124,17 @@ pub trait ConcatMethods<'a, Clause: PartialEq> {
     clause: Clause,
     items: &Vec<String>,
   ) -> String {
-    let fmt::Formatter { lb, space, indent, .. } = fmts;
+    let fmt::Formatter { lb, space, comma, .. } = fmts;
     let sql = if items.is_empty() == false {
-      let conditions = items.join(&format!("{space}{lb}{indent}AND{space}"));
-      format!("WHERE{space}{conditions}{space}{lb}")
+      let output_names = items.join(comma);
+      format!("RETURNING{space}{output_names}{space}{lb}")
     } else {
       "".to_owned()
     };
 
     concat_raw_before_after(items_raw_before, items_raw_after, query, fmts, clause, sql)
   }
 
-  #[cfg(feature = "postgresql")]
   fn concat_with(
     &self,
     items_raw_before: &Vec<(Clause, String)>,

src/delete/delete.rs

@@ -172,13 +172,6 @@ impl<'a> Delete<'a> {
     self
   }
 
-  /// The returning clause, this method can be used enabling the feature flag `postgresql`
-  #[cfg(any(doc, feature = "postgresql"))]
-  pub fn returning(mut self, output_name: &str) -> Self {
-    push_unique(&mut self._returning, output_name.trim().to_owned());
-    self
-  }
-
   /// The where clause
   ///
   /// # Examples
@@ -193,6 +186,15 @@ impl<'a> Delete<'a> {
     push_unique(&mut self._where, condition.trim().to_owned());
     self
   }
+}
+
+#[cfg(any(doc, feature = "postgresql"))]
+impl<'a> Delete<'a> {
+  /// The returning clause, this method can be used enabling the feature flag `postgresql`
+  pub fn returning(mut self, output_name: &str) -> Self {
+    push_unique(&mut self._returning, output_name.trim().to_owned());
+    self
+  }
 
   /// The with clause, this method can be used enabling the feature flag `postgresql`
   ///
@@ -219,7 +221,6 @@ impl<'a> Delete<'a> {
   /// DELETE FROM users
   /// WHERE id in (select * from deactivated_users)
   /// ```
-  #[cfg(any(doc, feature = "postgresql"))]
   pub fn with(mut self, name: &'a str, query: impl WithQuery + 'static) -> Self {
     self._with.push((name.trim(), std::sync::Arc::new(query)));
     self

src/delete/delete_internal.rs

@@ -1,10 +1,36 @@
+#[cfg(feature = "postgresql")]
+use crate::behavior::ConcatPostgres;
 use crate::{
-  behavior::{concat_raw_before_after, Concat, ConcatMethods},
+  behavior::{concat_raw_before_after, Concat, ConcatSqlStandard},
   fmt,
   structure::{Delete, DeleteClause},
 };
 
-impl<'a> ConcatMethods<'a, DeleteClause> for Delete<'_> {}
+impl<'a> ConcatSqlStandard<'a, DeleteClause> for Delete<'_> {}
+
+#[cfg(feature = "postgresql")]
+impl<'a> ConcatPostgres<'a, DeleteClause> for Delete<'_> {}
+
+impl Delete<'_> {
+  fn concat_delete_from(&self, query: String, fmts: &fmt::Formatter) -> String {
+    let fmt::Formatter { lb, space, .. } = fmts;
+    let sql = if self._delete_from.is_empty() == false {
+      let table_name = self._delete_from;
+      format!("DELETE FROM{space}{table_name}{space}{lb}")
+    } else {
+      "".to_owned()
+    };
+
+    concat_raw_before_after(
+      &self._raw_before,
+      &self._raw_after,
+      query,
+      fmts,
+      DeleteClause::DeleteFrom,
+      sql,
+    )
+  }
+}
 
 impl Concat for Delete<'_> {
   fn concat(&self, fmts: &fmt::Formatter) -> String {
@@ -46,24 +72,3 @@ impl Concat for Delete<'_> {
     query.trim_end().to_owned()
   }
 }
-
-impl Delete<'_> {
-  fn concat_delete_from(&self, query: String, fmts: &fmt::Formatter) -> String {
-    let fmt::Formatter { lb, space, .. } = fmts;
-    let sql = if self._delete_from.is_empty() == false {
-      let table_name = self._delete_from;
-      format!("DELETE FROM{space}{table_name}{space}{lb}")
-    } else {
-      "".to_owned()
-    };
-
-    concat_raw_before_after(
-      &self._raw_before,
-      &self._raw_after,
-      query,
-      fmts,
-      DeleteClause::DeleteFrom,
-      sql,
-    )
-  }
-}

src/insert/insert.rs

@@ -198,18 +198,20 @@ impl<'a> Insert<'a> {
     self
   }
 
-  /// The returning clause, this method can be used enabling the feature flag `postgresql`
-  #[cfg(any(doc, feature = "postgresql"))]
-  pub fn returning(mut self, output_name: &str) -> Self {
-    push_unique(&mut self._returning, output_name.trim().to_owned());
-    self
-  }
-
   /// The values clause
   pub fn values(mut self, value: &str) -> Self {
     push_unique(&mut self._values, value.trim().to_owned());
     self
   }
+}
+
+#[cfg(any(doc, feature = "postgresql"))]
+impl<'a> Insert<'a> {
+  /// The returning clause, this method can be used enabling the feature flag `postgresql`
+  pub fn returning(mut self, output_name: &str) -> Self {
+    push_unique(&mut self._returning, output_name.trim().to_owned());
+    self
+  }
 
   /// The with clause, this method can be used enabling the feature flag `postgresql`
   ///
@@ -237,7 +239,6 @@ impl<'a> Insert<'a> {
   /// SELECT *
   /// FROM active_users
   /// ```
-  #[cfg(any(doc, feature = "postgresql"))]
   pub fn with(mut self, name: &'a str, query: impl WithQuery + 'static) -> Self {
     self._with.push((name.trim(), std::sync::Arc::new(query)));
     self

src/insert/insert_internal.rs

@@ -1,55 +1,15 @@
+#[cfg(feature = "postgresql")]
+use crate::behavior::ConcatPostgres;
 use crate::{
-  behavior::{concat_raw_before_after, Concat, ConcatMethods},
+  behavior::{concat_raw_before_after, Concat, ConcatSqlStandard},
   fmt,
   structure::{Insert, InsertClause},
 };
 
-impl<'a> ConcatMethods<'a, InsertClause> for Insert<'_> {}
+impl<'a> ConcatSqlStandard<'a, InsertClause> for Insert<'_> {}
 
-impl Concat for Insert<'_> {
-  fn concat(&self, fmts: &fmt::Formatter) -> String {
-    let mut query = "".to_owned();
-
-    query = self.concat_raw(query, &fmts, &self._raw);
-    #[cfg(feature = "postgresql")]
-    {
-      query = self.concat_with(
-        &self._raw_before,
-        &self._raw_after,
-        query,
-        &fmts,
-        InsertClause::With,
-        &self._with,
-      );
-    }
-    query = self.concat_insert_into(query, &fmts);
-    query = self.concat_overriding(query, &fmts);
-    query = self.concat_values(
-      &self._raw_before,
-      &self._raw_after,
-      query,
-      &fmts,
-      InsertClause::Values,
-      &self._values,
-    );
-    query = self.concat_select(query, &fmts);
-    query = self.concat_on_conflict(query, &fmts);
-
-    #[cfg(feature = "postgresql")]
-    {
-      query = self.concat_returning(
-        &self._raw_before,
-        &self._raw_after,
-        query,
-        &fmts,
-        InsertClause::Returning,
-        &self._returning,
-      );
-    }
-
-    query.trim_end().to_owned()
-  }
-}
+#[cfg(feature = "postgresql")]
+impl<'a> ConcatPostgres<'a, InsertClause> for Insert<'_> {}
 
 impl Insert<'_> {
   fn concat_insert_into(&self, query: String, fmts: &fmt::Formatter) -> String {
@@ -128,3 +88,48 @@ impl Insert<'_> {
     )
   }
 }
+
+impl Concat for Insert<'_> {
+  fn concat(&self, fmts: &fmt::Formatter) -> String {
+    let mut query = "".to_owned();
+
+    query = self.concat_raw(query, &fmts, &self._raw);
+    #[cfg(feature = "postgresql")]
+    {
+      query = self.concat_with(
+        &self._raw_before,
+        &self._raw_after,
+        query,
+        &fmts,
+        InsertClause::With,
+        &self._with,
+      );
+    }
+    query = self.concat_insert_into(query, &fmts);
+    query = self.concat_overriding(query, &fmts);
+    query = self.concat_values(
+      &self._raw_before,
+      &self._raw_after,
+      query,
+      &fmts,
+      InsertClause::Values,
+      &self._values,
+    );
+    query = self.concat_select(query, &fmts);
+    query = self.concat_on_conflict(query, &fmts);
+
+    #[cfg(feature = "postgresql")]
+    {
+      query = self.concat_returning(
+        &self._raw_before,
+        &self._raw_after,
+        query,
+        &fmts,
+        InsertClause::Returning,
+        &self._returning,
+      );
+    }
+
+    query.trim_end().to_owned()
+  }
+}