Added and method to Delete and Update builder

Author: belchior

src/delete.rs

@@ -5,6 +5,20 @@ use crate::{
 };
 
 impl<'a> DeleteBuilder<'a> {
+  /// The same as `where_clause` method, useful to write more idiomatic SQL query
+  /// ```
+  /// use sql_query_builder::DeleteBuilder;
+  ///
+  /// let delete = DeleteBuilder::new()
+  ///   .delete_from("users")
+  ///   .where_clause("created_at < $1")
+  ///   .and("active = false");
+  /// ```
+  pub fn and(mut self, condition: &'a str) -> Self {
+    self = self.where_clause(condition);
+    self
+  }
+
   /// Gets the current state of the DeleteBuilder and returns it as string
   pub fn as_string(&self) -> String {
     let fmts = fmt::Formatter::one_line();
@@ -136,6 +150,13 @@ impl<'a> DeleteBuilder<'a> {
   }
 
   /// The where clause
+  /// ```
+  /// use sql_query_builder::DeleteBuilder;
+  ///
+  /// let delete = DeleteBuilder::new()
+  ///   .delete_from("users")
+  ///   .where_clause("login = 'foo'");
+  /// ```
   pub fn where_clause(mut self, condition: &'a str) -> Self {
     push_unique(&mut self._where, condition.trim().to_owned());
     self

src/select.rs

@@ -260,25 +260,32 @@ impl<'a> SelectBuilder<'a> {
     self
   }
 
-  /// The select by clause
+  /// The select clause
   pub fn select(mut self, column: &'a str) -> Self {
     push_unique(&mut self._select, column.trim().to_owned());
     self
   }
 
-  /// The union by clause
+  /// The union clause
   pub fn union(mut self, select: Self) -> Self {
     self._union.push(select);
     self
   }
 
-  /// The where by clause
+  /// The where clause
+  /// ```
+  /// use sql_query_builder::SelectBuilder;
+  ///
+  /// let select = SelectBuilder::new()
+  ///   .from("users")
+  ///   .where_clause("login = $1");
+  /// ```
   pub fn where_clause(mut self, condition: &'a str) -> Self {
     push_unique(&mut self._where, condition.trim().to_owned());
     self
   }
 
-  /// The with by clause
+  /// The with clause
   pub fn with(mut self, name: &'a str, select: Self) -> Self {
     self._with.push((name.trim(), select));
     self

src/update.rs

@@ -5,6 +5,21 @@ use crate::{
 };
 
 impl<'a> UpdateBuilder<'a> {
+  /// The same as `where_clause` method, useful to write more idiomatic SQL query
+  /// ```
+  /// use sql_query_builder::UpdateBuilder;
+  ///
+  /// let update = UpdateBuilder::new()
+  ///   .update("users")
+  ///   .set("name = $1")
+  ///   .where_clause("login = $2")
+  ///   .and("active = true");
+  /// ```
+  pub fn and(mut self, condition: &'a str) -> Self {
+    self = self.where_clause(condition);
+    self
+  }
+
   /// Gets the current state of the UpdateBuilder and returns it as string
   pub fn as_string(&self) -> String {
     let fmts = fmt::Formatter::one_line();
@@ -142,6 +157,14 @@ impl<'a> UpdateBuilder<'a> {
   }
 
   /// The where clause
+  /// ```
+  /// use sql_query_builder::UpdateBuilder;
+  ///
+  /// let update = UpdateBuilder::new()
+  ///   .update("users")
+  ///   .set("name = $1")
+  ///   .where_clause("login = $2");
+  /// ```
   pub fn where_clause(mut self, condition: &'a str) -> Self {
     push_unique(&mut self._where, condition.trim().to_owned());
     self

tests/delete_builder_api_spec.rs

@@ -106,6 +106,19 @@ mod builder_methods {
   }
 }
 
+mod and_clause {
+  use super::*;
+  use pretty_assertions::assert_eq;
+
+  #[test]
+  fn method_and_should_be_an_alias_to_where_clause() {
+    let query = DeleteBuilder::new().and("login = 'foo'").as_string();
+    let expected_query = "WHERE login = 'foo'";
+
+    assert_eq!(query, expected_query);
+  }
+}
+
 mod delete_clause {
   use super::*;
   use pretty_assertions::assert_eq;

tests/select_builder_api_spec.rs

@@ -140,7 +140,7 @@ mod and_clause {
   use pretty_assertions::assert_eq;
 
   #[test]
-  fn method_and_should_add_a_where_clause() {
+  fn method_and_should_be_an_alias_to_where_clause() {
     let query = SelectBuilder::new().and("login = 'foo'").as_string();
     let expected_query = "WHERE login = 'foo'";
 

tests/update_builder_api_spec.rs

@@ -103,6 +103,18 @@ mod builder_methods {
   }
 }
 
+mod and_clause {
+  use super::*;
+  use pretty_assertions::assert_eq;
+
+  #[test]
+  fn method_and_should_be_an_alias_to_where_clause() {
+    let query = UpdateBuilder::new().and("login = 'foo'").as_string();
+    let expected_query = "WHERE login = 'foo'";
+
+    assert_eq!(query, expected_query);
+  }
+}
 mod set_clause {
   use super::*;
   use pretty_assertions::assert_eq;