refactors to_string and pub(crate)

Author: belchior

src/behavior.rs

@@ -7,7 +7,13 @@ pub trait Concat {
   fn concat(&self, fmts: &fmt::Formatter) -> String;
 }
 
-pub trait ConcatSqlStandard<Clause: PartialEq> {
+/// Represents all commands that can be used in a transaction
+pub trait TransactionQuery: Concat {}
+
+/// Represents all commands that can be used inside the with method
+pub trait WithQuery: Concat {}
+
+pub(crate) trait ConcatSqlStandard<Clause: PartialEq> {
   fn concat_from(
     &self,
     items_raw_before: &Vec<(Clause, String)>,
@@ -22,7 +28,7 @@ pub trait ConcatSqlStandard<Clause: PartialEq> {
       let tables = items.join(comma);
       format!("FROM{space}{tables}{space}{lb}")
     } else {
-      "".to_owned()
+      "".to_string()
     };
 
     concat_raw_before_after(items_raw_before, items_raw_after, query, fmts, clause, sql)
@@ -53,7 +59,7 @@ pub trait ConcatSqlStandard<Clause: PartialEq> {
       let values = items.join(&sep);
       format!("VALUES{space}{lb}{values}{space}{lb}")
     } else {
-      "".to_owned()
+      "".to_string()
     };
 
     concat_raw_before_after(items_raw_before, items_raw_after, query, fmts, clause, sql)
@@ -79,15 +85,15 @@ pub trait ConcatSqlStandard<Clause: PartialEq> {
 
       format!("WHERE{space}{conditions}{space}{lb}")
     } else {
-      "".to_owned()
+      "".to_string()
     };
 
     concat_raw_before_after(items_raw_before, items_raw_after, query, fmts, clause, sql)
   }
 }
 
 #[cfg(any(feature = "postgresql", feature = "sqlite"))]
-pub trait ConcatCommon<Clause: PartialEq> {
+pub(crate) trait ConcatCommon<Clause: PartialEq> {
   fn concat_returning(
     &self,
     items_raw_before: &Vec<(Clause, String)>,
@@ -102,7 +108,7 @@ pub trait ConcatCommon<Clause: PartialEq> {
       let output_names = items.join(comma);
       format!("RETURNING{space}{output_names}{space}{lb}")
     } else {
-      "".to_owned()
+      "".to_string()
     };
 
     concat_raw_before_after(items_raw_before, items_raw_after, query, fmts, clause, sql)
@@ -125,7 +131,7 @@ pub trait ConcatCommon<Clause: PartialEq> {
       ..
     } = fmts;
     let sql = if items.is_empty() == false {
-      let with = items.iter().fold("".to_owned(), |acc, item| {
+      let with = items.iter().fold("".to_string(), |acc, item| {
         let (name, query) = item;
         let inner_lb = format!("{lb}{indent}");
         let inner_fmts = fmt::Formatter {
@@ -143,15 +149,15 @@ pub trait ConcatCommon<Clause: PartialEq> {
 
       format!("WITH{space}{lb}{with}{space}{lb}")
     } else {
-      "".to_owned()
+      "".to_string()
     };
 
     concat_raw_before_after(items_raw_before, items_raw_after, query, fmts, clause, sql)
   }
 }
 
 #[cfg(feature = "sqlite")]
-pub trait ConcatSqlite {
+pub(crate) trait ConcatSqlite {
   fn concat_insert(
     &self,
     items_raw_before: &Vec<(InsertClause, String)>,
@@ -163,13 +169,13 @@ pub trait ConcatSqlite {
     let fmt::Formatter { lb, space, .. } = fmts;
 
     let (clause, sql) = match insert {
-      (InsertVars::InsertInto, exp) if exp.is_empty() => (InsertClause::InsertInto, "".to_owned()),
+      (InsertVars::InsertInto, exp) if exp.is_empty() => (InsertClause::InsertInto, "".to_string()),
       (InsertVars::InsertInto, exp) => (InsertClause::InsertInto, format!("INSERT INTO{space}{exp}{space}{lb}")),
 
-      (InsertVars::InsertOr, exp) if exp.is_empty() => (InsertClause::InsertOr, "".to_owned()),
+      (InsertVars::InsertOr, exp) if exp.is_empty() => (InsertClause::InsertOr, "".to_string()),
       (InsertVars::InsertOr, exp) => (InsertClause::InsertOr, format!("INSERT OR{space}{exp}{space}{lb}")),
 
-      (InsertVars::ReplaceInto, exp) if exp.is_empty() => (InsertClause::ReplaceInto, "".to_owned()),
+      (InsertVars::ReplaceInto, exp) if exp.is_empty() => (InsertClause::ReplaceInto, "".to_string()),
       (InsertVars::ReplaceInto, exp) => (
         InsertClause::ReplaceInto,
         format!("REPLACE INTO{space}{exp}{space}{lb}"),
@@ -193,7 +199,7 @@ pub trait ConcatSqlite {
       let joins = join.join(format!("{space}{lb}").as_str());
       format!("{joins}{space}{lb}")
     } else {
-      "".to_owned()
+      "".to_string()
     };
 
     concat_raw_before_after(&items_raw_before, &items_raw_after, query, fmts, clause, sql)
@@ -240,19 +246,13 @@ pub trait ConcatSqlite {
       let values = values.join(&sep);
       (InsertClause::Values, format!("VALUES{space}{lb}{values}{space}{lb}"))
     } else {
-      (InsertClause::Values, "".to_owned())
+      (InsertClause::Values, "".to_string())
     };
 
     concat_raw_before_after(items_raw_before, items_raw_after, query, fmts, clause, sql)
   }
 }
 
-/// Represents all commands that can be used in a transaction
-pub trait TransactionQuery: Concat {}
-
-/// Represents all commands that can be used inside the with method
-pub trait WithQuery: Concat {}
-
 impl std::fmt::Display for LogicalOperator {
   fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
     let v = match self {
@@ -263,7 +263,7 @@ impl std::fmt::Display for LogicalOperator {
   }
 }
 
-pub fn concat_raw_before_after<Clause: PartialEq>(
+pub(crate) fn concat_raw_before_after<Clause: PartialEq>(
   items_before: &Vec<(Clause, String)>,
   items_after: &Vec<(Clause, String)>,
   query: String,
@@ -280,14 +280,14 @@ pub fn concat_raw_before_after<Clause: PartialEq>(
   format!("{query}{raw_before}{space_before}{sql}{raw_after}{space_after}")
 }
 
-pub fn push_unique<T: PartialEq>(list: &mut Vec<T>, value: T) {
+pub(crate) fn push_unique<T: PartialEq>(list: &mut Vec<T>, value: T) {
   let prev_item = list.iter().find(|&item| *item == value);
   if prev_item.is_none() {
     list.push(value);
   }
 }
 
-pub fn raw_queries<Clause: PartialEq>(raw_list: &Vec<(Clause, String)>, clause: &Clause) -> Vec<String> {
+pub(crate) fn raw_queries<Clause: PartialEq>(raw_list: &Vec<(Clause, String)>, clause: &Clause) -> Vec<String> {
   raw_list
     .iter()
     .filter(|item| item.0 == *clause)

src/delete/delete.rs

@@ -83,7 +83,7 @@ impl Delete {
   /// # assert_eq!(delete.to_string(), expected);
   /// ```
   pub fn delete_from(mut self, table_name: &str) -> Self {
-    self._delete_from = table_name.trim().to_owned();
+    self._delete_from = table_name.trim().to_string();
     self
   }
 
@@ -122,7 +122,7 @@ impl Delete {
   /// delete from users WHERE login = 'foo'
   /// ```
   pub fn raw(mut self, raw_sql: &str) -> Self {
-    push_unique(&mut self._raw, raw_sql.trim().to_owned());
+    push_unique(&mut self._raw, raw_sql.trim().to_string());
     self
   }
 
@@ -148,7 +148,7 @@ impl Delete {
   /// DELETE FROM users where name = 'Foo'
   /// ```
   pub fn raw_after(mut self, clause: DeleteClause, raw_sql: &str) -> Self {
-    self._raw_after.push((clause, raw_sql.trim().to_owned()));
+    self._raw_after.push((clause, raw_sql.trim().to_string()));
     self
   }
 
@@ -174,7 +174,7 @@ impl Delete {
   /// delete from users WHERE name = 'Bar'
   /// ```
   pub fn raw_before(mut self, clause: DeleteClause, raw_sql: &str) -> Self {
-    self._raw_before.push((clause, raw_sql.trim().to_owned()));
+    self._raw_before.push((clause, raw_sql.trim().to_string()));
     self
   }
 
@@ -202,7 +202,7 @@ impl Delete {
   ///   AND status = 'deactivated'
   /// ```
   pub fn where_clause(mut self, condition: &str) -> Self {
-    push_unique(&mut self._where, (LogicalOperator::And, condition.trim().to_owned()));
+    push_unique(&mut self._where, (LogicalOperator::And, condition.trim().to_string()));
     self
   }
 
@@ -230,7 +230,7 @@ impl Delete {
   ///   OR login = 'bar'
   /// ```
   pub fn where_or(mut self, condition: &str) -> Self {
-    push_unique(&mut self._where, (LogicalOperator::Or, condition.trim().to_owned()));
+    push_unique(&mut self._where, (LogicalOperator::Or, condition.trim().to_string()));
     self
   }
 }
@@ -261,7 +261,7 @@ impl Delete {
   /// DELETE FROM users RETURNING id, login
   /// ```
   pub fn returning(mut self, output_name: &str) -> Self {
-    push_unique(&mut self._returning, output_name.trim().to_owned());
+    push_unique(&mut self._returning, output_name.trim().to_string());
     self
   }
 
@@ -305,7 +305,7 @@ impl Delete {
   /// WHERE id in (select * from deactivated_users)
   /// ```
   pub fn with(mut self, name: &str, query: impl WithQuery + 'static) -> Self {
-    self._with.push((name.trim().to_owned(), std::sync::Arc::new(query)));
+    self._with.push((name.trim().to_string(), std::sync::Arc::new(query)));
     self
   }
 }

src/delete/delete_internal.rs

@@ -15,7 +15,7 @@ impl Delete {
       let table_name = &self._delete_from;
       format!("DELETE FROM{space}{table_name}{space}{lb}")
     } else {
-      "".to_owned()
+      "".to_string()
     };
 
     concat_raw_before_after(
@@ -31,7 +31,7 @@ impl Delete {
 
 impl Concat for Delete {
   fn concat(&self, fmts: &fmt::Formatter) -> String {
-    let mut query = "".to_owned();
+    let mut query = "".to_string();
 
     query = self.concat_raw(query, &fmts, &self._raw);
     #[cfg(any(feature = "postgresql", feature = "sqlite"))]
@@ -66,7 +66,7 @@ impl Concat for Delete {
       );
     }
 
-    query.trim_end().to_owned()
+    query.trim_end().to_string()
   }
 }
 

src/insert/insert.rs

@@ -86,7 +86,7 @@ impl Insert {
   /// ```
   #[cfg(not(feature = "sqlite"))]
   pub fn insert_into(mut self, table_name: &str) -> Self {
-    self._insert_into = table_name.trim().to_owned();
+    self._insert_into = table_name.trim().to_string();
     self
   }
 
@@ -116,7 +116,7 @@ impl Insert {
   /// INSERT INTO users (login) ON CONFLICT do nothing
   /// ```
   pub fn on_conflict(mut self, conflict: &str) -> Self {
-    self._on_conflict = conflict.trim().to_owned();
+    self._on_conflict = conflict.trim().to_string();
     self
   }
 
@@ -142,7 +142,7 @@ impl Insert {
   /// ```
   #[cfg(not(feature = "sqlite"))]
   pub fn overriding(mut self, option: &str) -> Self {
-    self._overriding = option.trim().to_owned();
+    self._overriding = option.trim().to_string();
     self
   }
 
@@ -214,7 +214,7 @@ impl Insert {
   /// insert into users (login, name) VALUES ('foo', 'Foo')
   /// ```
   pub fn raw(mut self, raw_sql: &str) -> Self {
-    push_unique(&mut self._raw, raw_sql.trim().to_owned());
+    push_unique(&mut self._raw, raw_sql.trim().to_string());
     self
   }
 
@@ -240,7 +240,7 @@ impl Insert {
   /// INSERT INTO users (login, name) values ('foo', 'Foo')
   /// ```
   pub fn raw_after(mut self, clause: InsertClause, raw_sql: &str) -> Self {
-    self._raw_after.push((clause, raw_sql.trim().to_owned()));
+    self._raw_after.push((clause, raw_sql.trim().to_string()));
     self
   }
 
@@ -266,7 +266,7 @@ impl Insert {
   /// insert into users (login, name) VALUES ('bar', 'Bar')
   /// ```
   pub fn raw_before(mut self, clause: InsertClause, raw_sql: &str) -> Self {
-    self._raw_before.push((clause, raw_sql.trim().to_owned()));
+    self._raw_before.push((clause, raw_sql.trim().to_string()));
     self
   }
 
@@ -292,7 +292,7 @@ impl Insert {
   /// INSERT INTO users (login, name) VALUES ('foo', 'Foo'), ('bar', 'Bar')
   /// ```
   pub fn values(mut self, value: &str) -> Self {
-    push_unique(&mut self._values, value.trim().to_owned());
+    push_unique(&mut self._values, value.trim().to_string());
     self
   }
 }
@@ -324,7 +324,7 @@ impl Insert {
   /// INSERT INTO users RETURNING id, login
   /// ```
   pub fn returning(mut self, output_name: &str) -> Self {
-    push_unique(&mut self._returning, output_name.trim().to_owned());
+    push_unique(&mut self._returning, output_name.trim().to_string());
     self
   }
 
@@ -374,7 +374,7 @@ impl Insert {
   /// FROM active_users
   /// ```
   pub fn with(mut self, name: &str, query: impl WithQuery + 'static) -> Self {
-    self._with.push((name.trim().to_owned(), std::sync::Arc::new(query)));
+    self._with.push((name.trim().to_string(), std::sync::Arc::new(query)));
     self
   }
 }
@@ -412,7 +412,7 @@ impl Insert {
   /// The `insert into` clause, this method overrides the previous value and can be used enabling the feature flag `sqlite`
   #[cfg(not(doc))]
   pub fn insert_into(mut self, expression: &str) -> Self {
-    self._insert = (InsertVars::InsertInto, expression.trim().to_owned());
+    self._insert = (InsertVars::InsertInto, expression.trim().to_string());
     self
   }
 
@@ -445,7 +445,7 @@ impl Insert {
   /// INSERT OR abort into users (login, name)
   /// ```
   pub fn insert_or(mut self, expression: &str) -> Self {
-    self._insert = (InsertVars::InsertOr, expression.trim().to_owned());
+    self._insert = (InsertVars::InsertOr, expression.trim().to_string());
     self
   }
 
@@ -471,7 +471,7 @@ impl Insert {
   /// REPLACE INTO users (login, name)
   /// ```
   pub fn replace_into(mut self, expression: &str) -> Self {
-    self._insert = (InsertVars::ReplaceInto, expression.trim().to_owned());
+    self._insert = (InsertVars::ReplaceInto, expression.trim().to_string());
     self
   }
 }