implemented values command

Author: belchior

src/behavior.rs

@@ -92,6 +92,27 @@ pub trait ConcatMethods<'a, Clause: PartialEq> {
     concat_raw_before_after(items_raw_before, items_raw_after, query, fmts, clause, sql)
   }
 
+  fn concat_values(
+    &self,
+    items_raw_before: &Vec<(Clause, String)>,
+    items_raw_after: &Vec<(Clause, String)>,
+    query: String,
+    fmts: &fmt::Formatter,
+    clause: Clause,
+    items: &Vec<String>,
+  ) -> String {
+    let fmt::Formatter { comma, lb, space, .. } = 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}")
+    } else {
+      "".to_owned()
+    };
+
+    concat_raw_before_after(items_raw_before, items_raw_after, query, fmts, clause, sql)
+  }
+
   fn concat_where(
     &self,
     items_raw_before: &Vec<(Clause, String)>,

src/insert.rs

@@ -236,7 +236,14 @@ impl Concat for InsertBuilder<'_> {
     }
     query = self.concat_insert_into(query, &fmts);
     query = self.concat_overriding(query, &fmts);
-    query = self.concat_values(query, &fmts);
+    query = self.concat_values(
+      &self._raw_before,
+      &self._raw_after,
+      query,
+      &fmts,
+      InsertClause::Values,
+      &self._values,
+    );
     query = self.concat_select(query, &fmts);
 
     #[cfg(feature = "postgresql")]
@@ -312,25 +319,6 @@ impl InsertBuilder<'_> {
       sql,
     )
   }
-
-  fn concat_values(&self, query: String, fmts: &fmt::Formatter) -> String {
-    let fmt::Formatter { comma, lb, space, .. } = fmts;
-    let sql = if self._values.is_empty() == false {
-      let values = self._values.join(comma);
-      format!("VALUES{space}{values}{space}{lb}")
-    } else {
-      "".to_owned()
-    };
-
-    concat_raw_before_after(
-      &self._raw_before,
-      &self._raw_after,
-      query,
-      fmts,
-      InsertClause::Values,
-      sql,
-    )
-  }
 }
 
 impl std::fmt::Display for InsertBuilder<'_> {

src/lib.rs

@@ -7,7 +7,9 @@ mod insert;
 mod select;
 mod structure;
 mod update;
+mod values;
 
 pub use crate::structure::{
   DeleteBuilder, DeleteClause, InsertBuilder, InsertClause, SelectBuilder, SelectClause, UpdateBuilder, UpdateClause,
+  ValuesBuilder, ValuesClause,
 };

src/select.rs

@@ -377,7 +377,12 @@ impl Concat for SelectBuilder<'_> {
 
 impl SelectBuilder<'_> {
   #[cfg(feature = "postgresql")]
-  fn concat_combinator(&self, query: String, fmts: &fmt::Formatter, combinator: crate::structure::Combinator) -> String {
+  fn concat_combinator(
+    &self,
+    query: String,
+    fmts: &fmt::Formatter,
+    combinator: crate::structure::Combinator,
+  ) -> String {
     use crate::behavior::raw_queries;
     use crate::structure::Combinator;
 

src/structure.rs

@@ -145,3 +145,18 @@ pub enum UpdateClause {
   #[cfg(feature = "postgresql")]
   With,
 }
+
+/// Builder to contruct a values command
+#[derive(Default, Clone)]
+pub struct ValuesBuilder {
+  pub(crate) _raw_after: Vec<(ValuesClause, String)>,
+  pub(crate) _raw_before: Vec<(ValuesClause, String)>,
+  pub(crate) _raw: Vec<String>,
+  pub(crate) _values: Vec<String>,
+}
+
+/// All available clauses to be used in `raw_before` and `raw_after` methods of the ValuesBuilder
+#[derive(PartialEq, Clone)]
+pub enum ValuesClause {
+  Values,
+}

src/values.rs

@@ -0,0 +1,164 @@
+use crate::{
+  behavior::{push_unique, Concat, ConcatMethods, WithQuery},
+  fmt,
+  structure::{ValuesBuilder, ValuesClause},
+};
+
+impl ValuesBuilder {
+  /// Gets the current state of the ValuesBuilder and returns it as string
+  pub fn as_string(&self) -> String {
+    let fmts = fmt::Formatter::one_line();
+    self.concat(&fmts)
+  }
+
+  /// Prints the current state of the ValuesBuilder into console output in a more ease to read version.
+  /// This method is useful to debug complex queries or just to print the generated SQL while you type
+  /// ```
+  /// use sql_query_builder::ValuesBuilder;
+  ///
+  /// let values = ValuesBuilder::new()
+  ///   .values("(1, 'one'), (2, 'two')")
+  ///   .values("(3, 'three')")
+  ///   .debug();
+  /// ```
+  ///
+  /// Output
+  ///
+  /// ```sql
+  /// VALUES (1, 'one'), (2, 'two'), (3, 'three')
+  /// ```
+  pub fn debug(self) -> Self {
+    let fmts = fmt::Formatter::multi_line();
+    println!("{}", fmt::colorize(self.concat(&fmts)));
+    self
+  }
+
+  /// Create ValuesBuilder's instance
+  pub fn new() -> Self {
+    Self::default()
+  }
+
+  /// Prints the current state of the ValuesBuilder into console output similar to debug method,
+  /// the difference is that this method prints in one line.
+  pub fn print(self) -> Self {
+    let fmts = fmt::Formatter::one_line();
+    println!("{}", fmt::colorize(self.concat(&fmts)));
+    self
+  }
+
+  /// Adds at the beginning a raw SQL query.
+  ///
+  /// ```
+  /// use sql_query_builder::ValuesBuilder;
+  ///
+  /// let raw_query = "insert into my_table(nun, txt)";
+  /// let values = ValuesBuilder::new()
+  ///   .raw(raw_query)
+  ///   .values("(1, 'one'), (2, 'two')")
+  ///   .debug();
+  /// ```
+  ///
+  /// Output
+  ///
+  /// ```sql
+  /// insert into my_table(num, txt)
+  /// VALUES (1, 'one'), (2, 'two')
+  /// ```
+  pub fn raw(mut self, raw_sql: &str) -> Self {
+    push_unique(&mut self._raw, raw_sql.trim().to_owned());
+    self
+  }
+
+  /// Adds a raw SQL query after a specified clause.
+  ///
+  /// ```
+  /// use sql_query_builder::{ValuesBuilder, ValuesClause};
+  ///
+  /// let raw_query = ", (3, 'three')";
+  /// let values = ValuesBuilder::new()
+  ///   .values("(1, 'one'), (2, 'two')")
+  ///   .raw_after(ValuesClause::Values, raw_query)
+  ///   .debug();
+  /// ```
+  ///
+  /// Output
+  ///
+  /// ```sql
+  /// VALUES (1, 'one'), (2, 'two') , (3, 'three')
+  /// ```
+  pub fn raw_after(mut self, clause: ValuesClause, raw_sql: &str) -> Self {
+    self._raw_after.push((clause, raw_sql.trim().to_owned()));
+    self
+  }
+
+  /// Adds a raw SQL query before a specified clause.
+  ///
+  /// ```
+  /// use sql_query_builder::{ValuesBuilder, ValuesClause};
+  ///
+  /// let raw_query = "/* the values command */";
+  /// let values = ValuesBuilder::new()
+  ///   .raw_before(ValuesClause::Values, raw_query)
+  ///   .values("(1, 'one'), (2, 'two')")
+  ///   .debug();
+  /// ```
+  ///
+  /// Output
+  ///
+  /// ```sql
+  /// /* the values command */
+  /// VALUES (1, 'one'), (2, 'two')
+  /// ```
+  pub fn raw_before(mut self, clause: ValuesClause, raw_sql: &str) -> Self {
+    self._raw_before.push((clause, raw_sql.trim().to_owned()));
+    self
+  }
+
+  /// The values clause
+  /// ```
+  /// use sql_query_builder::ValuesBuilder;
+  ///
+  /// let values = ValuesBuilder::new()
+  ///   .values("(1, 'one'), (2, 'two')")
+  ///   .values("(3, 'three')");
+  /// ```
+  pub fn values(mut self, expression: &str) -> Self {
+    push_unique(&mut self._values, expression.trim().to_owned());
+    self
+  }
+}
+
+impl WithQuery for ValuesBuilder {}
+
+impl<'a> ConcatMethods<'a, ValuesClause> for ValuesBuilder {}
+
+impl Concat for ValuesBuilder {
+  fn concat(&self, fmts: &fmt::Formatter) -> String {
+    let mut query = "".to_owned();
+
+    query = self.concat_raw(query, &fmts, &self._raw);
+    query = self.concat_values(
+      &self._raw_before,
+      &self._raw_after,
+      query,
+      &fmts,
+      ValuesClause::Values,
+      &self._values,
+    );
+
+    query.trim_end().to_owned()
+  }
+}
+
+impl std::fmt::Display for ValuesBuilder {
+  fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    write!(f, "{}", self.as_string())
+  }
+}
+
+impl std::fmt::Debug for ValuesBuilder {
+  fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    let fmts = fmt::Formatter::multi_line();
+    write!(f, "{}", fmt::colorize(self.concat(&fmts)))
+  }
+}

tests/feature_flag_postgresql.rs

@@ -288,6 +288,20 @@ mod with_clause {
     use pretty_assertions::assert_eq;
     use sql_query_builder::{DeleteBuilder, DeleteClause};
 
+    #[test]
+    fn method_with_should_accept_delete_builder_as_query_argument() {
+      let query = DeleteBuilder::new()
+        .with("deleted_address", DeleteBuilder::new().delete_from("address"))
+        .delete_from("orders")
+        .as_string();
+      let expected_query = "\
+        WITH deleted_address AS (DELETE FROM address) \
+        DELETE FROM orders\
+      ";
+
+      assert_eq!(query, expected_query);
+    }
+
     #[test]
     fn method_with_should_add_the_with_clause() {
       let deleted_users = DeleteBuilder::new()
@@ -403,6 +417,18 @@ mod with_clause {
     use pretty_assertions::assert_eq;
     use sql_query_builder::{InsertBuilder, InsertClause};
 
+    #[test]
+    fn method_with_should_accept_insert_builder_as_query_argument() {
+      let query = InsertBuilder::new()
+        .with("address", InsertBuilder::new().insert_into("address"))
+        .as_string();
+      let expected_query = "\
+        WITH address AS (INSERT INTO address)\
+      ";
+
+      assert_eq!(query, expected_query);
+    }
+
     #[test]
     fn method_with_should_add_the_with_clause() {
       let inserted_users = InsertBuilder::new()
@@ -518,6 +544,18 @@ mod with_clause {
     use pretty_assertions::assert_eq;
     use sql_query_builder::{SelectBuilder, SelectClause};
 
+    #[test]
+    fn method_with_should_accept_select_builder_as_query_argument() {
+      let query = SelectBuilder::new()
+        .with("address", SelectBuilder::new().select("city"))
+        .as_string();
+      let expected_query = "\
+        WITH address AS (SELECT city)\
+      ";
+
+      assert_eq!(query, expected_query);
+    }
+
     #[test]
     fn method_with_should_add_the_with_clause() {
       let select_users = SelectBuilder::new().select("login").from("users");
@@ -618,6 +656,18 @@ mod with_clause {
     use pretty_assertions::assert_eq;
     use sql_query_builder::{UpdateBuilder, UpdateClause};
 
+    #[test]
+    fn method_with_should_accept_update_builder_as_query_argument() {
+      let query = UpdateBuilder::new()
+        .with("address", UpdateBuilder::new().set("city = 'foo'"))
+        .as_string();
+      let expected_query = "\
+        WITH address AS (SET city = 'foo')\
+      ";
+
+      assert_eq!(query, expected_query);
+    }
+
     #[test]
     fn method_with_should_add_the_with_clause() {
       let update_users = UpdateBuilder::new()
@@ -728,6 +778,23 @@ mod with_clause {
       assert_eq!(query, expected_query);
     }
   }
+
+  mod values_builder {
+    use pretty_assertions::assert_eq;
+    use sql_query_builder::{SelectBuilder, ValuesBuilder};
+
+    #[test]
+    fn method_with_should_accept_values_builder_as_query_argument() {
+      let query = SelectBuilder::new()
+        .with("address", ValuesBuilder::new().values("('foo', 'Foo')"))
+        .as_string();
+      let expected_query = "\
+        WITH address AS (VALUES ('foo', 'Foo'))\
+      ";
+
+      assert_eq!(query, expected_query);
+    }
+  }
 }
 
 #[cfg(feature = "postgresql")]