Merge pull request #42 from belchior/mysql-insert

Adds MySQL syntax to Insert builder

Author: belchior

src/concat/mysql.rs

@@ -1,5 +1,5 @@
 #[cfg(feature = "mysql")]
-use crate::{concat::concat_raw_before_after, fmt};
+use crate::{concat::concat_raw_before_after, fmt, utils};
 
 #[cfg(feature = "mysql")]
 pub(crate) trait ConcatPartition<Clause: PartialEq> {
@@ -15,12 +15,7 @@ pub(crate) trait ConcatPartition<Clause: PartialEq> {
     let fmt::Formatter { comma, lb, space, .. } = fmts;
 
     let sql = if items.is_empty() == false {
-      let column_names = items
-        .iter()
-        .filter(|column| column.is_empty() == false)
-        .map(|column| column.as_str())
-        .collect::<Vec<_>>()
-        .join(comma);
+      let column_names = utils::join(items, comma);
 
       if column_names.is_empty() == false {
         format!("PARTITION{space}({column_names}){space}{lb}")

src/concat/non_standard.rs

@@ -1,5 +1,5 @@
 #[cfg(any(feature = "postgresql", feature = "sqlite", feature = "mysql"))]
-use crate::{behavior::WithQuery, concat::concat_raw_before_after, fmt};
+use crate::{behavior::WithQuery, concat::concat_raw_before_after, fmt, utils};
 
 #[cfg(any(feature = "postgresql", feature = "sqlite", feature = "mysql"))]
 pub(crate) trait ConcatLimit<Clause: PartialEq> {
@@ -36,12 +36,7 @@ pub(crate) trait ConcatReturning<Clause: PartialEq> {
   ) -> String {
     let fmt::Formatter { lb, space, comma, .. } = fmts;
     let sql = if items.is_empty() == false {
-      let output_names = items
-        .iter()
-        .filter(|item| item.is_empty() == false)
-        .map(|item| item.as_str())
-        .collect::<Vec<_>>()
-        .join(comma);
+      let output_names = utils::join(items, comma);
       format!("RETURNING{space}{output_names}{space}{lb}")
     } else {
       "".to_string()
@@ -98,3 +93,31 @@ pub(crate) trait ConcatWith<Clause: PartialEq> {
     concat_raw_before_after(items_raw_before, items_raw_after, query, fmts, clause, sql)
   }
 }
+
+#[cfg(feature = "mysql")]
+pub(crate) trait ConcatColumn<Clause: PartialEq> {
+  fn concat_column(
+    &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 { lb, comma, space, .. } = fmts;
+
+    let sql = if items.is_empty() == false {
+      let column_names = utils::join(&items, comma);
+      if column_names.is_empty() == false {
+        format!("({column_names}){space}{lb}")
+      } else {
+        "".to_string()
+      }
+    } else {
+      "".to_string()
+    };
+
+    concat_raw_before_after(items_raw_before, items_raw_after, query, fmts, clause, sql)
+  }
+}

src/concat/sql_standard.rs

@@ -1,4 +1,4 @@
-use crate::{concat::concat_raw_before_after, fmt, structure::LogicalOperator};
+use crate::{concat::concat_raw_before_after, fmt, structure::LogicalOperator, utils};
 
 pub(crate) trait ConcatFrom<Clause: PartialEq> {
   fn concat_from(
@@ -12,12 +12,7 @@ pub(crate) trait ConcatFrom<Clause: PartialEq> {
   ) -> String {
     let fmt::Formatter { comma, lb, space, .. } = fmts;
     let sql = if items.is_empty() == false {
-      let tables = items
-        .iter()
-        .filter(|item| item.is_empty() == false)
-        .map(|item| item.as_str())
-        .collect::<Vec<_>>()
-        .join(comma);
+      let tables = utils::join(items, comma);
       format!("FROM{space}{tables}{space}{lb}")
     } else {
       "".to_string()
@@ -61,12 +56,7 @@ pub(crate) trait ConcatOrderBy<Clause: PartialEq> {
   ) -> String {
     let fmt::Formatter { comma, lb, space, .. } = fmts;
     let sql = if items.is_empty() == false {
-      let columns = items
-        .iter()
-        .filter(|item| item.is_empty() == false)
-        .map(|item| item.as_str())
-        .collect::<Vec<_>>()
-        .join(comma);
+      let columns = utils::join(items, comma);
 
       format!("ORDER BY{space}{columns}{space}{lb}")
     } else {
@@ -77,6 +67,28 @@ pub(crate) trait ConcatOrderBy<Clause: PartialEq> {
   }
 }
 
+pub(crate) trait ConcatSet<Clause: PartialEq> {
+  fn concat_set(
+    &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 values = utils::join(items, comma);
+      format!("SET{space}{values}{space}{lb}")
+    } else {
+      "".to_string()
+    };
+
+    concat_raw_before_after(items_raw_before, items_raw_after, query, fmts, clause, sql)
+  }
+}
+
 pub(crate) trait ConcatWhere<Clause: PartialEq> {
   fn concat_where(
     &self,

src/concat/sqlite.rs

@@ -2,39 +2,9 @@
 use crate::{
   concat::concat_raw_before_after,
   fmt,
-  structure::{InsertClause, InsertVars, UpdateClause, UpdateVars},
+  structure::{UpdateClause, UpdateVars},
 };
 
-#[cfg(feature = "sqlite")]
-pub(crate) trait ConcatInsert {
-  fn concat_insert(
-    &self,
-    items_raw_before: &Vec<(InsertClause, String)>,
-    items_raw_after: &Vec<(InsertClause, String)>,
-    query: String,
-    fmts: &fmt::Formatter,
-    insert: &(InsertVars, String),
-  ) -> String {
-    let fmt::Formatter { lb, space, .. } = fmts;
-
-    let (clause, sql) = match insert {
-      (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_string()),
-      (InsertVars::InsertOr, exp) => (InsertClause::InsertOr, format!("INSERT OR{space}{exp}{space}{lb}")),
-
-      (InsertVars::ReplaceInto, exp) if exp.is_empty() => (InsertClause::ReplaceInto, "".to_string()),
-      (InsertVars::ReplaceInto, exp) => (
-        InsertClause::ReplaceInto,
-        format!("REPLACE INTO{space}{exp}{space}{lb}"),
-      ),
-    };
-
-    concat_raw_before_after(items_raw_before, items_raw_after, query, fmts, clause, sql)
-  }
-}
-
 #[cfg(feature = "sqlite")]
 pub(crate) trait ConcatUpdate {
   fn concat_update(