moves limit and offset methods to postgres syntax

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 = "1.0.3"
+version = "1.0.4"
 edition = "2021"
 rust-version = "1.58"
 license = "MIT"

README.md

@@ -47,6 +47,7 @@ sql_query_builder = { version = "1.x.x", features = ["postgresql"] }
 
 
 ## How it's works
+
 In simple terms this library will not try to understand what you are writing inside the arguments, this is good
 because it's removes a lot of complexity and verbosity to generate a SQL query, in contrast debugging tends to be more difficult and silly error can araise.
 The lib has the [debug()](https://docs.rs/sql_query_builder/latest/sql_query_builder/struct.Select.html#method.debug) method with a nice output to minimize the effort to debug a complex query.
@@ -67,7 +68,7 @@ let select = sql::Select::new()
 
 Methods like `limit` and `offset` will override the previous value, the two select is equivalent
 
-```rust
+```text
 use sql_query_builder as sql;
 
 let select = sql::Select::new()

src/select/select.rs

@@ -4,7 +4,7 @@ use crate::{
   structure::{Select, SelectClause},
 };
 
-impl<'a> Select<'a> {
+impl Select<'_> {
   /// The same as [where_clause](Select::where_clause) method, useful to write more idiomatic SQL query
   ///
   /// # Examples
@@ -142,47 +142,11 @@ impl<'a> Select<'a> {
     self
   }
 
-  /// The limit clause. This method overrides the previous value
-  ///
-  /// # Examples
-  /// ```
-  /// use sql_query_builder as sql;
-  ///
-  /// let select = sql::Select::new()
-  ///   .limit("123");
-  ///
-  /// let select = sql::Select::new()
-  ///   .limit("1000")
-  ///   .limit("123");
-  /// ```
-  pub fn limit(mut self, num: &'a str) -> Self {
-    self._limit = num.trim();
-    self
-  }
-
   /// Create Select's instance
   pub fn new() -> Self {
     Self::default()
   }
 
-  /// The offset clause. This method overrides the previous value
-  ///
-  /// # Examples
-  /// ```
-  /// use sql_query_builder as sql;
-  ///
-  /// let select = sql::Select::new()
-  ///   .offset("1500");
-  ///
-  /// let select = sql::Select::new()
-  ///   .offset("1000")
-  ///   .offset("1500");
-  /// ```
-  pub fn offset(mut self, num: &'a str) -> Self {
-    self._offset = num.trim();
-    self
-  }
-
   /// The order by clause
   pub fn order_by(mut self, column: &str) -> Self {
     push_unique(&mut self._order_by, column.trim().to_owned());
@@ -311,6 +275,42 @@ impl<'a> Select<'a> {
     self
   }
 
+  /// The limit clause. This method overrides the previous value, this method can be used enabling the feature flag `postgresql`
+  ///
+  /// # Examples
+  /// ```text
+  /// use sql_query_builder as sql;
+  ///
+  /// let select = sql::Select::new()
+  ///   .limit("123");
+  ///
+  /// let select = sql::Select::new()
+  ///   .limit("1000")
+  ///   .limit("123");
+  /// ```
+  pub fn limit(mut self, num: &'a str) -> Self {
+    self._limit = num.trim();
+    self
+  }
+
+  /// The offset clause. This method overrides the previous value, this method can be used enabling the feature flag `postgresql`
+  ///
+  /// # Examples
+  /// ```text
+  /// use sql_query_builder as sql;
+  ///
+  /// let select = sql::Select::new()
+  ///   .offset("1500");
+  ///
+  /// let select = sql::Select::new()
+  ///   .offset("1000")
+  ///   .offset("1500");
+  /// ```
+  pub fn offset(mut self, num: &'a str) -> Self {
+    self._offset = num.trim();
+    self
+  }
+
   /// The union clause, this method can be used enabling the feature flag `postgresql`
   pub fn union(mut self, select: Self) -> Self {
     self._union.push(select);

src/select/select_internal.rs

@@ -59,14 +59,12 @@ impl Select<'_> {
 
     format!("{left_stmt}{right_stmt}{raw_after}{space_after}")
   }
-}
 
-impl Select<'_> {
-  fn concat_group_by(&self, query: String, fmts: &fmt::Formatter) -> String {
-    let fmt::Formatter { comma, lb, space, .. } = fmts;
-    let sql = if self._group_by.is_empty() == false {
-      let columns = self._group_by.join(comma);
-      format!("GROUP BY{space}{columns}{space}{lb}")
+  fn concat_limit(&self, query: String, fmts: &fmt::Formatter) -> String {
+    let fmt::Formatter { lb, space, .. } = fmts;
+    let sql = if self._limit.is_empty() == false {
+      let count = self._limit;
+      format!("LIMIT{space}{count}{space}{lb}")
     } else {
       "".to_owned()
     };
@@ -76,16 +74,16 @@ impl Select<'_> {
       &self._raw_after,
       query,
       fmts,
-      SelectClause::GroupBy,
+      SelectClause::Limit,
       sql,
     )
   }
 
-  fn concat_having(&self, query: String, fmts: &fmt::Formatter) -> String {
+  fn concat_offset(&self, query: String, fmts: &fmt::Formatter) -> String {
     let fmt::Formatter { lb, space, .. } = fmts;
-    let sql = if self._having.is_empty() == false {
-      let conditions = self._having.join(" AND ");
-      format!("HAVING{space}{conditions}{space}{lb}")
+    let sql = if self._offset.is_empty() == false {
+      let start = self._offset;
+      format!("OFFSET{space}{start}{space}{lb}")
     } else {
       "".to_owned()
     };
@@ -95,16 +93,18 @@ impl Select<'_> {
       &self._raw_after,
       query,
       fmts,
-      SelectClause::Having,
+      SelectClause::Offset,
       sql,
     )
   }
+}
 
-  fn concat_join(&self, query: String, fmts: &fmt::Formatter) -> String {
-    let fmt::Formatter { lb, space, .. } = fmts;
-    let sql = if self._join.is_empty() == false {
-      let joins = self._join.join(format!("{space}{lb}").as_str());
-      format!("{joins}{space}{lb}")
+impl Select<'_> {
+  fn concat_group_by(&self, query: String, fmts: &fmt::Formatter) -> String {
+    let fmt::Formatter { comma, lb, space, .. } = fmts;
+    let sql = if self._group_by.is_empty() == false {
+      let columns = self._group_by.join(comma);
+      format!("GROUP BY{space}{columns}{space}{lb}")
     } else {
       "".to_owned()
     };
@@ -114,16 +114,16 @@ impl Select<'_> {
       &self._raw_after,
       query,
       fmts,
-      SelectClause::Join,
+      SelectClause::GroupBy,
       sql,
     )
   }
 
-  fn concat_limit(&self, query: String, fmts: &fmt::Formatter) -> String {
+  fn concat_having(&self, query: String, fmts: &fmt::Formatter) -> String {
     let fmt::Formatter { lb, space, .. } = fmts;
-    let sql = if self._limit.is_empty() == false {
-      let count = self._limit;
-      format!("LIMIT{space}{count}{space}{lb}")
+    let sql = if self._having.is_empty() == false {
+      let conditions = self._having.join(" AND ");
+      format!("HAVING{space}{conditions}{space}{lb}")
     } else {
       "".to_owned()
     };
@@ -133,16 +133,16 @@ impl Select<'_> {
       &self._raw_after,
       query,
       fmts,
-      SelectClause::Limit,
+      SelectClause::Having,
       sql,
     )
   }
 
-  fn concat_offset(&self, query: String, fmts: &fmt::Formatter) -> String {
+  fn concat_join(&self, query: String, fmts: &fmt::Formatter) -> String {
     let fmt::Formatter { lb, space, .. } = fmts;
-    let sql = if self._offset.is_empty() == false {
-      let start = self._offset;
-      format!("OFFSET{space}{start}{space}{lb}")
+    let sql = if self._join.is_empty() == false {
+      let joins = self._join.join(format!("{space}{lb}").as_str());
+      format!("{joins}{space}{lb}")
     } else {
       "".to_owned()
     };
@@ -152,7 +152,7 @@ impl Select<'_> {
       &self._raw_after,
       query,
       fmts,
-      SelectClause::Offset,
+      SelectClause::Join,
       sql,
     )
   }
@@ -234,8 +234,12 @@ impl Concat for Select<'_> {
     query = self.concat_group_by(query, &fmts);
     query = self.concat_having(query, &fmts);
     query = self.concat_order_by(query, &fmts);
-    query = self.concat_limit(query, &fmts);
-    query = self.concat_offset(query, &fmts);
+
+    #[cfg(feature = "postgresql")]
+    {
+      query = self.concat_limit(query, &fmts);
+      query = self.concat_offset(query, &fmts);
+    }
 
     #[cfg(feature = "postgresql")]
     {

src/structure.rs

@@ -1,3 +1,5 @@
+use std::marker::PhantomData;
+
 #[cfg(feature = "postgresql")]
 pub enum Combinator {
   Except,
@@ -94,20 +96,23 @@ pub struct Select<'a> {
   pub(crate) _group_by: Vec<String>,
   pub(crate) _having: Vec<String>,
   pub(crate) _join: Vec<String>,
-  pub(crate) _limit: &'a str,
-  pub(crate) _offset: &'a str,
   pub(crate) _order_by: Vec<String>,
   pub(crate) _raw_after: Vec<(SelectClause, String)>,
   pub(crate) _raw_before: Vec<(SelectClause, String)>,
   pub(crate) _raw: Vec<String>,
   pub(crate) _select: Vec<String>,
   pub(crate) _where: Vec<String>,
+  _not_used: PhantomData<&'a ()>, // exist only to accept a lifetime without feature flag
 
   #[cfg(feature = "postgresql")]
   pub(crate) _except: Vec<Self>,
   #[cfg(feature = "postgresql")]
   pub(crate) _intersect: Vec<Self>,
   #[cfg(feature = "postgresql")]
+  pub(crate) _limit: &'a str,
+  #[cfg(feature = "postgresql")]
+  pub(crate) _offset: &'a str,
+  #[cfg(feature = "postgresql")]
   pub(crate) _union: Vec<Self>,
   #[cfg(feature = "postgresql")]
   pub(crate) _with: Vec<(&'a str, std::sync::Arc<dyn crate::behavior::WithQuery>)>,