Merge pull request #20 from belchior/adds-methods-window-and-where_and

adds methods window and where_and

Author: belchior

Cargo.toml

@@ -4,7 +4,7 @@ description = "Write SQL queries in a simple and composable way"
 documentation = "https://docs.rs/sql_query_builder"
 repository = "https://github.com/belchior/sql_query_builder"
 authors = ["Belchior Oliveira <[email protected]>"]
-version = "2.0.0"
+version = "2.1.0"
 edition = "2021"
 rust-version = "1.62"
 license = "MIT"

README.md

@@ -41,7 +41,7 @@ SQL Query Builder comes with the following optional features:
 You can enable features like
 
 ```toml
-## Cargo.toml
+# Cargo.toml
 
 sql_query_builder = { version = "2.x.x", features = ["postgresql"] }
 ```
@@ -125,7 +125,7 @@ Composition is very welcome to write complex queries, this feature makes the lib
 use sql_query_builder as sql;
 
 fn project(select: sql::Select) -> sql::Select {
-select
+  select
     .select("u.id, u.name as user_name, u.login")
     .select("a.name as addresses_name")
     .select("o.name as product_name")

src/delete/delete.rs

@@ -107,6 +107,7 @@ impl Delete {
   /// ```
   /// # use sql_query_builder as sql;
   /// let raw_query = "delete from users";
+  ///
   /// let delete_query = sql::Delete::new()
   ///   .raw(raw_query)
   ///   .where_clause("login = 'foo'")
@@ -133,6 +134,7 @@ impl Delete {
   /// ```
   /// # use sql_query_builder as sql;
   /// let raw = "where name = 'Foo'";
+  ///
   /// let delete_query = sql::Delete::new()
   ///   .delete_from("users")
   ///   .raw_after(sql::DeleteClause::DeleteFrom, raw)
@@ -159,6 +161,7 @@ impl Delete {
   /// ```
   /// # use sql_query_builder as sql;
   /// let raw = "delete from users";
+  ///
   /// let delete_query = sql::Delete::new()
   ///   .raw_before(sql::DeleteClause::Where, raw)
   ///   .where_clause("name = 'Bar'")
@@ -178,6 +181,35 @@ impl Delete {
     self
   }
 
+  /// This method is un alias of `where_clause`. The `where_and` will concatenate mulltiples calls using the `and` operator.
+  /// The intention is to enable more idiomatic concatenation of conditions.
+  ///
+  /// # Example
+  ///
+  /// ```
+  /// # use sql_query_builder as sql;
+  /// let delete_query = sql::Delete::new()
+  ///   .where_clause("login = $1")
+  ///   .where_and("product_id = $2")
+  ///   .where_and("created_at >= current_date")
+  ///   .as_string();
+  ///
+  /// # let expected = "WHERE login = $1 AND product_id = $2 AND created_at >= current_date";
+  /// # assert_eq!(delete_query, expected);
+  /// ```
+  ///
+  /// Outputs
+  ///
+  /// ```sql
+  /// WHERE
+  ///   login = $1
+  ///   AND product_id = $2
+  ///   AND created_at >= current_date
+  /// ```
+  pub fn where_and(self, condition: &str) -> Self {
+    self.where_clause(condition)
+  }
+
   /// The `where` clause, this method will concatenate mulltiples calls using the `and` operator.
   /// If you intended to use the `or` operator you should use the [where_or](Delete::where_or) method
   ///
@@ -237,7 +269,7 @@ impl Delete {
 
 #[cfg(any(doc, feature = "postgresql", feature = "sqlite"))]
 impl Delete {
-  /// The `returning` clause, this method can be used enabling a feature flag
+  /// The `returning` clause, this method can be used enabling one of the feature flags `postgresql` or `sqlite`
   ///
   /// # Example
   ///
@@ -265,7 +297,7 @@ impl Delete {
     self
   }
 
-  /// The `with` clause, this method can be used enabling a feature flag
+  /// The `with` clause, this method can be used enabling one of the feature flags `postgresql` or `sqlite`
   ///
   /// # Example
   ///

src/insert/insert.rs

@@ -224,6 +224,7 @@ impl Insert {
   /// ```
   /// # use sql_query_builder as sql;
   /// let raw_query = "insert into users (login, name)";
+  ///
   /// let insert_query = sql::Insert::new()
   ///   .raw(raw_query)
   ///   .values("('foo', 'Foo')")
@@ -250,6 +251,7 @@ impl Insert {
   /// ```
   /// # use sql_query_builder as sql;
   /// let raw = "values ('foo', 'Foo')";
+  ///
   /// let insert_query = sql::Insert::new()
   ///   .insert_into("users (login, name)")
   ///   .raw_after(sql::InsertClause::InsertInto, raw)
@@ -276,6 +278,7 @@ impl Insert {
   /// ```
   /// # use sql_query_builder as sql;
   /// let raw = "insert into users (login, name)";
+  ///
   /// let insert_query = sql::Insert::new()
   ///   .raw_before(sql::InsertClause::Values, raw)
   ///   .values("('bar', 'Bar')")
@@ -324,7 +327,7 @@ impl Insert {
 
 #[cfg(any(doc, feature = "postgresql", feature = "sqlite"))]
 impl Insert {
-  /// The `returning` clause, this method can be used enabling a feature flag
+  /// The `returning` clause, this method can be used enabling one of the feature flags `postgresql` or `sqlite`
   ///
   /// # Example
   ///
@@ -353,7 +356,7 @@ impl Insert {
     self
   }
 
-  /// The `with` clause, this method can be used enabling a feature flag
+  /// The `with` clause, this method can be used enabling one of the feature flags `postgresql` or `sqlite`
   ///
   /// # Example
   ///

src/select/select.rs

@@ -294,6 +294,7 @@ impl Select {
   /// ```
   /// # use sql_query_builder as sql;
   /// let raw_query = "select * from users";
+  ///
   /// let select_query = sql::Select::new()
   ///   .raw(raw_query)
   ///   .where_clause("users.login = 'foo'")
@@ -320,6 +321,7 @@ impl Select {
   /// ```
   /// # use sql_query_builder as sql;
   /// let raw_join = "inner join addresses addr on u.login = addr.owner_login";
+  ///
   /// let select_query = sql::Select::new()
   ///   .from("users u")
   ///   .raw_after(sql::SelectClause::From, raw_join)
@@ -353,6 +355,7 @@ impl Select {
   /// ```
   /// # use sql_query_builder as sql;
   /// let raw_query = "from users";
+  ///
   /// let select_query = sql::Select::new()
   ///   .raw_before(sql::SelectClause::Where, raw_query)
   ///   .where_clause("users.login = 'foo'")
@@ -393,6 +396,37 @@ impl Select {
     self
   }
 
+  /// This method is un alias of `where_clause`. The `where_and` will concatenate mulltiples calls using the `and` operator.
+  /// The intention is to enable more idiomatic concatenation of conditions.
+  ///
+  /// # Example
+  ///
+  /// ```
+  /// # use sql_query_builder as sql;
+  /// let select_query = sql::Select::new()
+  ///   .from("carts")
+  ///   .where_clause("login = $1")
+  ///   .where_and("session_id = $2")
+  ///   .where_and("created_at >= current_date")
+  ///   .as_string();
+  ///
+  /// # let expected = "FROM carts WHERE login = $1 AND session_id = $2 AND created_at >= current_date";
+  /// # assert_eq!(select_query, expected);
+  /// ```
+  ///
+  /// Outputs
+  ///
+  /// ```sql
+  /// FROM carts
+  /// WHERE
+  ///   login = $1
+  ///   AND session_id = $2
+  ///   AND created_at >= current_date
+  /// ```
+  pub fn where_and(self, condition: &str) -> Self {
+    self.where_clause(condition)
+  }
+
   /// The `where` clause, this method will concatenate mulltiples calls using the `and` operator.
   /// If you intended to use the `or` operator you should use the [where_or](Select::where_or) method
   ///
@@ -498,11 +532,35 @@ impl Select {
     push_unique(&mut self._where, (LogicalOperator::Or, condition.trim().to_string()));
     self
   }
+
+  /// The `window` clause
+  ///
+  /// # Example
+  ///
+  /// ```
+  /// # use sql_query_builder as sql;
+  /// let select_query = sql::Select::new()
+  ///   .window("win as (partition by department)")
+  ///   .as_string();
+  ///
+  /// # let expected = "WINDOW win as (partition by department)";
+  /// # assert_eq!(select_query, expected);
+  /// ```
+  ///
+  /// Output
+  ///
+  /// ```sql
+  /// WINDOW win as (partition by department)
+  /// ```
+  pub fn window(mut self, name: &str) -> Self {
+    push_unique(&mut self._window, name.trim().to_string());
+    self
+  }
 }
 
 #[cfg(any(doc, feature = "postgresql", feature = "sqlite"))]
 impl Select {
-  /// The `except` clause, this method can be used enabling a feature flag
+  /// The `except` clause, this method can be used enabling one of the feature flags `postgresql` or `sqlite`
   ///
   /// # Example
   ///
@@ -542,7 +600,7 @@ impl Select {
     self
   }
 
-  /// The `intersect` clause, this method can be used enabling a feature flag
+  /// The `intersect` clause, this method can be used enabling one of the feature flags `postgresql` or `sqlite`
   ///
   /// # Example
   ///
@@ -582,7 +640,7 @@ impl Select {
     self
   }
 
-  /// The `limit` clause, this method overrides the previous value, this method can be used enabling a feature flag
+  /// The `limit` clause, this method overrides the previous value, this method can be used enabling one of the feature flags `postgresql` or `sqlite`
   ///
   /// # Example
   ///
@@ -606,7 +664,7 @@ impl Select {
     self
   }
 
-  /// The `offset` clause, this method overrides the previous value, this method can be used enabling a feature flag
+  /// The `offset` clause, this method overrides the previous value, this method can be used enabling one of the feature flags `postgresql` or `sqlite`
   ///
   /// # Example
   ///
@@ -630,7 +688,7 @@ impl Select {
     self
   }
 
-  /// The `union` clause, this method can be used enabling a feature flag
+  /// The `union` clause, this method can be used enabling one of the feature flags `postgresql` or `sqlite`
   ///
   /// # Example
   ///
@@ -670,7 +728,7 @@ impl Select {
     self
   }
 
-  /// The `with` clause, this method can be used enabling a feature flag
+  /// The `with` clause, this method can be used enabling one of the feature flags `postgresql` or `sqlite`
   ///
   /// # Example
   ///

src/select/select_internal.rs

@@ -45,6 +45,7 @@ impl Concat for Select {
     );
     query = self.concat_group_by(query, &fmts);
     query = self.concat_having(query, &fmts);
+    query = self.concat_window(query, &fmts);
     query = self.concat_order_by(query, &fmts);
 
     #[cfg(any(feature = "postgresql", feature = "sqlite"))]
@@ -160,6 +161,25 @@ impl Select {
       sql,
     )
   }
+
+  fn concat_window(&self, query: String, fmts: &fmt::Formatter) -> String {
+    let fmt::Formatter { comma, lb, space, .. } = fmts;
+    let sql = if self._window.is_empty() == false {
+      let columns = self._window.join(comma);
+      format!("WINDOW{space}{columns}{space}{lb}")
+    } else {
+      "".to_string()
+    };
+
+    concat_raw_before_after(
+      &self._raw_before,
+      &self._raw_after,
+      query,
+      fmts,
+      SelectClause::Window,
+      sql,
+    )
+  }
 }
 
 #[cfg(any(feature = "postgresql", feature = "sqlite"))]

src/structure.rs

@@ -33,6 +33,7 @@ pub struct Delete {
 /// # use sql_query_builder as sql;
 ///
 /// let raw = "where name = 'Foo'";
+///
 /// let delete_query = sql::Delete::new()
 ///   .delete_from("users")
 ///   .raw_after(sql::DeleteClause::DeleteFrom, raw)
@@ -88,6 +89,7 @@ pub(crate) enum InsertVars {
 /// # use sql_query_builder as sql;
 ///
 /// let raw = "values ('foo', 'Foo')";
+///
 /// let insert_query = sql::Insert::new()
 ///   .insert_into("users (login, name)")
 ///   .raw_after(sql::InsertClause::InsertInto, raw)
@@ -132,6 +134,7 @@ pub struct Select {
   pub(crate) _raw: Vec<String>,
   pub(crate) _select: Vec<String>,
   pub(crate) _where: Vec<(LogicalOperator, String)>,
+  pub(crate) _window: Vec<String>,
 
   #[cfg(any(feature = "postgresql", feature = "sqlite"))]
   pub(crate) _except: Vec<Self>,
@@ -172,6 +175,7 @@ pub enum SelectClause {
   OrderBy,
   Select,
   Where,
+  Window,
 
   #[cfg(any(feature = "postgresql", feature = "sqlite"))]
   Except,
@@ -259,6 +263,7 @@ pub(crate) enum UpdateVars {
 /// # use sql_query_builder as sql;
 ///
 /// let raw = "set name = 'Foo'";
+///
 /// let update_query = sql::Update::new()
 ///   .update("users")
 ///   .raw_after(sql::UpdateClause::Update, raw)