From 5245156827efc9817c20ae4406ac35caa9172747 Mon Sep 17 00:00:00 2001
From: Belchior Oliveira <belchior@outlook.com>
Date: Wed, 23 Jul 2025 09:01:43 -0300
Subject: [PATCH] Insert builder: fix mutually exclusive methods

---
 src/insert/insert.rs          |  67 ++++++++++-
 src/insert/insert_internal.rs | 148 +++++++++++++++--------
 src/structure.rs              |  14 ++-
 tests/command_insert_spec.rs  | 220 ++++++++++++++++++++++++++--------
 4 files changed, 348 insertions(+), 101 deletions(-)

diff --git a/src/insert/insert.rs b/src/insert/insert.rs
index adb7e35..e0ac44f 100644
--- a/src/insert/insert.rs
+++ b/src/insert/insert.rs
@@ -6,6 +6,9 @@ use crate::{
   utils::push_unique,
 };
 
+#[cfg(feature = "mysql")]
+use crate::structure::MySqlVariance;
+
 impl TransactionQuery for Insert {}
 
 impl Insert {
@@ -206,6 +209,12 @@ impl Insert {
   /// ```
   pub fn select(mut self, select: Select) -> Self {
     self._select = Some(select);
+
+    #[cfg(feature = "mysql")]
+    {
+      self._mysql_variance = MySqlVariance::InsertSelect;
+    }
+
     self
   }
 
@@ -311,12 +320,67 @@ impl Insert {
   /// ```sql
   /// INSERT INTO users (login, name) VALUES ('foo', 'Foo'), ('bar', 'Bar')
   /// ```
+  ///
+  /// # Composable methods
+  /// The methods [Insert::values], [Insert::row] are composable, when both was used each line will receive the contructor clause row.
+  ///
+  /// # Example
+  /// ```
+  /// # #[cfg(feature = "mysql")]
+  /// # {
+  /// # use sql_query_builder as sql;
+  /// let query = sql::Insert::new()
+  ///   .values("('foo', 'Foo')")
+  ///   .row("('bar', 'Bar')")
+  ///   .as_string();
+  /// # let expected = "VALUES ROW('foo', 'Foo'), ROW('bar', 'Bar')";
+  /// # assert_eq!(expected, query);
+  /// # }
+  /// ```
+  ///
+  /// Output
+  ///
+  /// ```sql
+  /// VALUES ROW('foo', 'Foo'), ROW('bar', 'Bar')
+  /// ```
+  ///
+  /// # Mutually exclusive methods
+  /// The methods [Insert::values]/[Insert::row], [Insert::select] and [Insert::set] are mutually exclusive, the last called will overrides the previous ones.
+  /// [Insert::row] and [Insert::set] are available on crate feature `mysql` only.
+  ///
+  /// # Example
+  /// ```
+  /// # #[cfg(feature = "mysql")]
+  /// # {
+  /// # use sql_query_builder as sql;
+  /// let query = sql::Insert::new()
+  ///   .values("('foo', 'Foo')")
+  ///   .row("('bar', 'Bar')")
+  ///   .set("login = 'foo'")
+  ///   .set("name = 'Foo'")
+  ///   .as_string();
+  /// # let expected = "SET login = 'foo', name = 'Foo'";
+  /// # assert_eq!(expected, query);
+  /// # }
+  /// ```
+  ///
+  /// Output
+  ///
+  /// ```sql
+  /// SET login = 'foo', name = 'Foo'
+  /// ```
   pub fn values(mut self, expression: &str) -> Self {
     push_unique(&mut self._values, expression.trim().to_string());
+
     #[cfg(not(feature = "mysql"))]
     {
       self._default_values = false
     }
+
+    #[cfg(feature = "mysql")]
+    {
+      self._mysql_variance = MySqlVariance::InsertValues;
+    }
     self
   }
 }
@@ -689,7 +753,7 @@ impl Insert {
   /// ```
   pub fn row(mut self, expression: &str) -> Self {
     push_unique(&mut self._values, expression.trim().to_string());
-    self._use_row = true;
+    self._mysql_variance = MySqlVariance::InsertValuesRow;
     self
   }
 
@@ -717,6 +781,7 @@ impl Insert {
   /// ```
   pub fn set(mut self, assignment: &str) -> Self {
     push_unique(&mut self._set, assignment.trim().to_string());
+    self._mysql_variance = MySqlVariance::InsertSet;
     self
   }
 }
diff --git a/src/insert/insert_internal.rs b/src/insert/insert_internal.rs
index 20bab9f..cd2fbc4 100644
--- a/src/insert/insert_internal.rs
+++ b/src/insert/insert_internal.rs
@@ -4,14 +4,26 @@ use crate::{
   structure::{Insert, InsertClause},
 };
 
+#[cfg(feature = "mysql")]
+use crate::structure::MySqlVariance;
+
 impl Concat for Insert {
   fn concat(&self, fmts: &fmt::Formatter) -> String {
     let mut query = "".to_string();
 
-    query = self.concat_raw(query, &fmts, &self._raw);
+    #[cfg(not(any(feature = "postgresql", feature = "sqlite", feature = "mysql")))]
+    {
+      query = self.concat_raw(query, &fmts, &self._raw);
+      query = self.concat_insert_into(query, &fmts);
+      query = self.concat_overriding(query, &fmts);
+      query = self.concat_default_values(query, &fmts);
+      query = self.concat_values(query, &fmts);
+      query = self.concat_select(query, &fmts);
+    }
 
-    #[cfg(any(feature = "postgresql", feature = "sqlite"))]
+    #[cfg(feature = "postgresql")]
     {
+      query = self.concat_raw(query, &fmts, &self._raw);
       query = self.concat_with(
         &self._raw_before,
         &self._raw_after,
@@ -20,77 +32,101 @@ impl Concat for Insert {
         InsertClause::With,
         &self._with,
       );
-    }
-
-    query = self.concat_insert_into(query, &fmts);
-
-    #[cfg(feature = "sqlite")]
-    {
-      query = self.concat_insert_or(query, &fmts);
-      query = self.concat_replace_into(query, &fmts);
-    }
-
-    #[cfg(feature = "mysql")]
-    {
-      query = self.concat_insert(query, &fmts);
-      query = self.concat_into(query, &fmts);
-      query = self.concat_partition(
+      query = self.concat_insert_into(query, &fmts);
+      query = self.concat_overriding(query, &fmts);
+      query = self.concat_default_values(query, &fmts);
+      query = self.concat_values(query, &fmts);
+      query = self.concat_select(query, &fmts);
+      query = self.concat_on_conflict(query, &fmts);
+      query = self.concat_returning(
         &self._raw_before,
         &self._raw_after,
         query,
         &fmts,
-        InsertClause::Partition,
-        &self._partition,
+        InsertClause::Returning,
+        &self._returning,
       );
-      query = self.concat_column(
+    }
+
+    #[cfg(feature = "sqlite")]
+    {
+      query = self.concat_raw(query, &fmts, &self._raw);
+      query = self.concat_with(
         &self._raw_before,
         &self._raw_after,
         query,
         &fmts,
-        InsertClause::Column,
-        &self._column,
+        InsertClause::With,
+        &self._with,
       );
-      query = self.concat_set(
+      query = self.concat_insert_into(query, &fmts);
+      query = self.concat_insert_or(query, &fmts);
+      query = self.concat_replace_into(query, &fmts);
+      query = self.concat_default_values(query, &fmts);
+      query = self.concat_values(query, &fmts);
+      query = self.concat_select(query, &fmts);
+      query = self.concat_on_conflict(query, &fmts);
+      query = self.concat_returning(
         &self._raw_before,
         &self._raw_after,
         query,
         &fmts,
-        InsertClause::Set,
-        &self._set,
+        InsertClause::Returning,
+        &self._returning,
       );
     }
 
-    #[cfg(not(any(feature = "sqlite", feature = "mysql")))]
-    {
-      query = self.concat_overriding(query, &fmts);
-    }
-
-    #[cfg(not(any(feature = "mysql")))]
-    {
-      query = self.concat_default_values(query, &fmts);
-    }
-
-    query = self.concat_values(query, &fmts);
-
-    query = self.concat_select(query, &fmts);
-
     #[cfg(feature = "mysql")]
     {
-      query = self.concat_on_duplicate_key_update(query, &fmts);
-    }
-
-    #[cfg(any(feature = "postgresql", feature = "sqlite"))]
-    {
-      query = self.concat_on_conflict(query, &fmts);
-
-      query = self.concat_returning(
+      query = self.concat_raw(query, &fmts, &self._raw);
+      query = self.concat_insert_into(query, &fmts);
+      query = self.concat_insert(query, &fmts);
+      query = self.concat_into(query, &fmts);
+      query = self.concat_partition(
         &self._raw_before,
         &self._raw_after,
         query,
         &fmts,
-        InsertClause::Returning,
-        &self._returning,
+        InsertClause::Partition,
+        &self._partition,
       );
+
+      match self._mysql_variance {
+        MySqlVariance::InsertSelect => {
+          query = self.concat_column(
+            &self._raw_before,
+            &self._raw_after,
+            query,
+            &fmts,
+            InsertClause::Column,
+            &self._column,
+          );
+          query = self.concat_select(query, &fmts);
+        }
+        MySqlVariance::InsertSet => {
+          query = self.concat_set(
+            &self._raw_before,
+            &self._raw_after,
+            query,
+            &fmts,
+            InsertClause::Set,
+            &self._set,
+          );
+        }
+        MySqlVariance::InsertValues | MySqlVariance::InsertValuesRow => {
+          query = self.concat_column(
+            &self._raw_before,
+            &self._raw_after,
+            query,
+            &fmts,
+            InsertClause::Column,
+            &self._column,
+          );
+          query = self.concat_values(query, &fmts);
+        }
+      }
+
+      query = self.concat_on_duplicate_key_update(query, &fmts);
     }
 
     query.trim_end().to_string()
@@ -184,11 +220,19 @@ impl Insert {
         .iter()
         .filter(|item| item.is_empty() == false)
         .map(|item| {
-          if self._use_row {
-            format!("ROW{item}")
-          } else {
+          #[cfg(not(feature = "mysql"))]
+          {
             item.clone()
           }
+
+          #[cfg(feature = "mysql")]
+          {
+            if self._mysql_variance == MySqlVariance::InsertValuesRow {
+              format!("ROW{item}")
+            } else {
+              item.clone()
+            }
+          }
         })
         .collect::<Vec<_>>()
         .join(&sep);
diff --git a/src/structure.rs b/src/structure.rs
index 9537bd8..5f50c82 100644
--- a/src/structure.rs
+++ b/src/structure.rs
@@ -437,7 +437,6 @@ pub struct Insert {
   pub(crate) _raw: Vec<String>,
   pub(crate) _select: Option<Select>,
   pub(crate) _values: Vec<String>,
-  pub(crate) _use_row: bool,
 
   #[cfg(any(feature = "postgresql", feature = "sqlite"))]
   pub(crate) _on_conflict: String,
@@ -469,6 +468,9 @@ pub struct Insert {
   #[cfg(feature = "mysql")]
   pub(crate) _into: String,
 
+  #[cfg(feature = "mysql")]
+  pub(crate) _mysql_variance: MySqlVariance,
+
   #[cfg(feature = "mysql")]
   pub(crate) _on_duplicate_key_update: Vec<String>,
 
@@ -532,6 +534,16 @@ pub enum InsertClause {
   Set,
 }
 
+#[cfg(feature = "mysql")]
+#[derive(Default, PartialEq, Clone)]
+pub enum MySqlVariance {
+  #[default]
+  InsertValues,
+  InsertSelect,
+  InsertSet,
+  InsertValuesRow,
+}
+
 #[derive(Clone, PartialEq)]
 pub(crate) enum LogicalOperator {
   And,
diff --git a/tests/command_insert_spec.rs b/tests/command_insert_spec.rs
index 60a4eea..37bf223 100644
--- a/tests/command_insert_spec.rs
+++ b/tests/command_insert_spec.rs
@@ -97,10 +97,10 @@ mod full_api {
       .into("users")
       .column("login, name")
       // one of is required
+      .set("name = 'Bar'")
+      .select(sql::Select::new().select("login, name"))
       .values("(1, 'one')")
       .row("('foo', 'Foo')")
-      .select(sql::Select::new().select("login, name"))
-      .set("name = 'Bar'")
       // optional
       .partition("p1")
       .on_duplicate_key_update("c = c+1")
@@ -111,9 +111,7 @@ mod full_api {
       INTO users \
       PARTITION (p1) \
       (login, name) \
-      SET name = 'Bar' \
       VALUES ROW(1, 'one'), ROW('foo', 'Foo') \
-      SELECT login, name \
       ON DUPLICATE KEY UPDATE c = c+1\
     ";
 
@@ -1044,108 +1042,236 @@ mod mysql_insert_variances {
   use sql_query_builder as sql;
 
   #[test]
-  fn methods_insert_into_column_partition() {
+  fn insert_basic_values() {
     let query = sql::Insert::new()
-      .insert("low_priority")
-      .into("users")
-      .partition("p1")
-      .column("name")
+      .insert_into("users (login, name)")
+      .values("('foo', 'Foo')")
       .as_string();
-    let expected_query = "INSERT low_priority INTO users PARTITION (p1) (name)";
+    let expected_query = "INSERT INTO users (login, name) VALUES ('foo', 'Foo')";
 
     assert_eq!(expected_query, query);
   }
 
   #[test]
-  fn method_insert_into_and_method_insert_the_last_call_should_override_the_previous_one() {
+  fn insert_basic_values_row() {
     let query = sql::Insert::new()
-      .insert_into("users (name)")
-      .insert("low_priority")
+      .insert_into("users (login, name)")
+      .row("('foo', 'Foo')")
       .as_string();
-    let expected_query = "INSERT low_priority";
+    let expected_query = "INSERT INTO users (login, name) VALUES ROW('foo', 'Foo')";
 
     assert_eq!(expected_query, query);
+  }
 
+  #[test]
+  fn insert_basic_set() {
     let query = sql::Insert::new()
-      .insert("low_priority")
-      .insert_into("users (name)")
+      .insert_into("users")
+      .set("login = 'foo'")
+      .set("name = 'Foo'")
       .as_string();
-    let expected_query = "INSERT INTO users (name)";
+    let expected_query = "INSERT INTO users SET login = 'foo', name = 'Foo'";
 
     assert_eq!(expected_query, query);
   }
 
   #[test]
-  fn method_insert_into_and_method_into_the_last_call_should_override_the_previous_one() {
+  fn insert_basic_select() {
     let query = sql::Insert::new()
-      .insert_into("users (name)")
-      .into("employees")
+      .insert_into("users (login, name)")
+      .select(
+        sql::Select::new()
+          .select("login, name")
+          .from("users_old")
+          .where_clause("login = 'foo'"),
+      )
       .as_string();
-    let expected_query = "INTO employees";
+    let expected_query = "INSERT INTO users (login, name) SELECT login, name FROM users_old WHERE login = 'foo'";
 
     assert_eq!(expected_query, query);
+  }
 
+  #[test]
+  fn insert_splited_values() {
     let query = sql::Insert::new()
-      .into("employees")
-      .insert_into("users (name)")
+      .insert("high_priority")
+      .into("users")
+      .column("login, name")
+      .values("('foo', 'Foo')")
       .as_string();
-    let expected_query = "INSERT INTO users (name)";
+    let expected_query = "INSERT high_priority INTO users (login, name) VALUES ('foo', 'Foo')";
 
     assert_eq!(expected_query, query);
   }
 
   #[test]
-  fn method_insert_into_and_method_partition_the_last_call_should_override_the_previous_one() {
+  fn insert_splited_values_row() {
     let query = sql::Insert::new()
-      .insert_into("users (name)")
-      .partition("p1")
+      .insert("high_priority")
+      .into("users")
+      .column("login, name")
+      .row("('foo', 'Foo')")
       .as_string();
-    let expected_query = "PARTITION (p1)";
+    let expected_query = "INSERT high_priority INTO users (login, name) VALUES ROW('foo', 'Foo')";
 
     assert_eq!(expected_query, query);
+  }
 
+  #[test]
+  fn insert_splited_set() {
     let query = sql::Insert::new()
-      .partition("p1")
-      .insert_into("users (name)")
+      .insert("high_priority")
+      .into("users")
+      .set("login = 'foo'")
+      .set("name = 'Foo'")
       .as_string();
-    let expected_query = "INSERT INTO users (name)";
+    let expected_query = "INSERT high_priority INTO users SET login = 'foo', name = 'Foo'";
 
     assert_eq!(expected_query, query);
   }
 
   #[test]
-  fn method_insert_into_and_method_column_the_last_call_should_override_the_previous_one() {
+  fn insert_splited_select() {
     let query = sql::Insert::new()
-      .insert_into("users (name)")
-      .column("login")
+      .insert("high_priority")
+      .into("users")
+      .column("login, name")
+      .select(
+        sql::Select::new()
+          .select("login, name")
+          .from("users_old")
+          .where_clause("login = 'foo'"),
+      )
       .as_string();
-    let expected_query = "(login)";
+    let expected_query = "\
+      INSERT high_priority INTO users (login, name) \
+      SELECT login, name FROM users_old WHERE login = 'foo'\
+    ";
 
     assert_eq!(expected_query, query);
+  }
+
+  /*
+   * Whe the variances are mixed the last one should overrides the previous ones
+   */
 
+  #[test]
+  fn insert_basic_and_splited_the_last_call_should_override_the_previous_one() {
     let query = sql::Insert::new()
-      .column("login")
-      .insert_into("users (name)")
+      // basic
+      .insert_into("users (login, name)")
+      // splited
+      .insert("high_priority")
+      .into("users")
+      .column("login, name")
       .as_string();
-    let expected_query = "INSERT INTO users (name)";
+    let expected_query = "INSERT high_priority INTO users (login, name)";
 
     assert_eq!(expected_query, query);
-  }
-}
 
-#[cfg(feature = "mysql")]
-mod values_and_row_methods_mixed {
-  use pretty_assertions::assert_eq;
-  use sql_query_builder as sql;
+    let query = sql::Insert::new()
+      // splited
+      .insert("high_priority")
+      .into("users")
+      .column("login, name")
+      // basic
+      .insert_into("users (login, name)")
+      .as_string();
+    let expected_query = "INSERT INTO users (login, name)";
+
+    assert_eq!(expected_query, query);
+  }
 
   #[test]
-  fn when_has_at_least_one_call_to_row_method_all_lines_should_receive_the_constructor_clause_row() {
+  fn insert_values_and_values_row_are_composable_and_the_constructor_clause_row_should_be_added_to_each_line() {
     let query = sql::Insert::new()
-      .values("('baz', 'Baz')")
       .values("('foo', 'Foo')")
+      .values("('bar', 'Bar')")
       .row("('max', 'Max')")
       .as_string();
-    let expected_query = "VALUES ROW('baz', 'Baz'), ROW('foo', 'Foo'), ROW('max', 'Max')";
+    let expected_query = "VALUES ROW('foo', 'Foo'), ROW('bar', 'Bar'), ROW('max', 'Max')";
+
+    assert_eq!(expected_query, query);
+  }
+
+  #[test]
+  fn insert_set_is_the_last_call_and_should_override_the_previous_ones() {
+    let query = sql::Insert::new()
+      // insert_values/insert_values_row
+      .values("('foo', 'Foo')")
+      .row("('bar', 'Bar')")
+      // insert_select
+      .select(
+        sql::Select::new()
+          .select("login, name")
+          .from("users_old")
+          .where_clause("login = 'foo'"),
+      )
+      // insert_set
+      .set("login = 'foo'")
+      .set("name = 'Foo'")
+      .as_string();
+    let expected_query = "SET login = 'foo', name = 'Foo'";
+
+    assert_eq!(expected_query, query);
+  }
+
+  #[test]
+  fn insert_values_insert_values_row_are_the_last_call_and_should_override_the_previous_ones() {
+    let query = sql::Insert::new()
+      // insert_set
+      .set("login = 'foo'")
+      .set("name = 'Foo'")
+      // insert_select
+      .select(
+        sql::Select::new()
+          .select("login, name")
+          .from("users_old")
+          .where_clause("login = 'foo'"),
+      )
+      // insert_values/insert_values_row
+      .values("('foo', 'Foo')")
+      .row("('bar', 'Bar')")
+      .as_string();
+    let expected_query = "VALUES ROW('foo', 'Foo'), ROW('bar', 'Bar')";
+
+    assert_eq!(expected_query, query);
+  }
+
+  #[test]
+  fn insert_select_is_the_last_call_and_should_override_the_previous_ones() {
+    let query = sql::Insert::new()
+      // insert_set
+      .set("login = 'foo'")
+      .set("name = 'Foo'")
+      // insert_values/insert_values_row
+      .values("('foo', 'Foo')")
+      .row("('bar', 'Bar')")
+      // insert_select
+      .select(
+        sql::Select::new()
+          .select("login, name")
+          .from("users_old")
+          .where_clause("login = 'foo'"),
+      )
+      .as_string();
+    let expected_query = "SELECT login, name FROM users_old WHERE login = 'foo'";
+
+    assert_eq!(expected_query, query);
+  }
+
+  #[test]
+  fn insert_set_should_overrides_the_column_and_values_clauses() {
+    let query = sql::Insert::new()
+      .column("login, name")
+      // insert_values/insert_values_row
+      .values("('foo', 'Foo')")
+      .row("('bar', 'Bar')")
+      // insert_set
+      .set("login = 'foo'")
+      .set("name = 'Foo'")
+      .as_string();
+    let expected_query = "SET login = 'foo', name = 'Foo'";
 
     assert_eq!(expected_query, query);
   }