chore: writer.rs doesn't care anymore about creating tokens

Author: TheRustifyer

canyon_core/src/query/operators.rs

@@ -50,7 +50,7 @@ impl Display for Operator {
 
 impl<'a, D: SqlDialect> ToSqlTokens<'a, D> for Operator {
     fn to_tokens(&self) -> impl IntoIterator<Item = SqlToken<'a>> + 'a {
-        let mut out = SqlTokens::with_capacity(16);
+        let mut out = SqlTokens::default();
 
         match *self {
             Self::Eq => out.symbol(Symbol::Equals),
@@ -99,7 +99,6 @@ impl LikeKind {
         out.placeholder();
         out.whitespace();
         out.keyword(Keyword::As);
-        out.whitespace();
         out.ident(Cow::from(<PlaceholderDatatype as Into<&str>>::into(
             D::PLACEHOLDER_DATA_TYPE,
         )));
@@ -124,7 +123,6 @@ impl<'a, D: SqlDialect> ToSqlTokens<'a, D> for LikeKind {
     fn to_tokens(&self) -> impl IntoIterator<Item = SqlToken<'a>> + 'a {
         let mut out = SqlTokens::with_capacity(19);
 
-        out.keyword(Keyword::Like);
         out.whitespace();
         out.keyword(Keyword::Concat);
         out.symbol(Symbol::LParen);

canyon_core/src/query/querybuilder/syntax/clause.rs

@@ -1,4 +1,4 @@
-use crate::query::operators::Operator;
+use crate::query::operators::{LikeKind, Operator};
 use crate::query::querybuilder::syntax::column::ColumnRef;
 use crate::query::querybuilder::syntax::dialect::SqlDialect;
 use crate::query::querybuilder::syntax::emitter::types::helpers::Range;
@@ -10,7 +10,7 @@ pub struct ConditionClause<'a> {
     pub(crate) kind: ConditionClauseKind,
     pub(crate) column_name: ColumnRef<'a>,
     pub(crate) operator: Operator,
-    pub(crate) value_indexes: Range,
+    pub(crate) value_indexes: Option<Range>,
 }
 
 #[derive(Eq, PartialEq, Copy, Clone, Debug)]
@@ -51,25 +51,50 @@ impl<'a, D: SqlDialect> ToSqlTokens<'a, D> for ConditionClause<'a> {
         // Operator
         out.operator(self.operator);
 
-        out.whitespace();
-
-        if self.value_indexes.is_range() {
-            out.symbol(Symbol::LParen);
-            let mut indexes = (&self.value_indexes).into_iter().peekable();
-            while indexes.next().is_some() {
-                out.placeholder();
-                if indexes.peek().is_some() {
-                    out.symbol(Symbol::Comma);
+        match self.operator {
+            Operator::Like(kind) | Operator::NotLike(kind) => {
+                let like_tokens = <LikeKind as ToSqlTokens<'_, D>>::to_tokens(&kind);
+                out.extend(like_tokens);
+            }
+            _ => {
+                if let Some(ref range) = self.value_indexes
+                    && range.is_range()
+                {
+                    __impl::output_range_of_placeholders::<D>(range, &mut out);
+                } else {
                     out.whitespace();
+                    out.placeholder();
                 }
             }
-            out.symbol(Symbol::RParen);
-        } else {
-            out.placeholder();
         }
 
         out.whitespace();
 
         out
     }
 }
+
+mod __impl {
+    use crate::query::operators::Operator;
+    use crate::query::querybuilder::syntax::dialect::SqlDialect;
+    use crate::query::querybuilder::syntax::emitter::types::helpers::Range;
+    use crate::query::querybuilder::syntax::symbol::Symbol;
+    use crate::query::querybuilder::syntax::tokens::{SqlTokens, ToSqlTokens};
+
+    pub(crate) fn output_range_of_placeholders<D: SqlDialect>(
+        range: &Range,
+        out: &mut SqlTokens<'_>,
+    ) {
+        out.whitespace();
+        out.symbol(Symbol::LParen);
+        let mut indexes = range.into_iter().peekable();
+        while indexes.next().is_some() {
+            out.placeholder();
+            if indexes.peek().is_some() {
+                out.symbol(Symbol::Comma);
+                out.whitespace();
+            }
+        }
+        out.symbol(Symbol::RParen);
+    }
+}

canyon_core/src/query/querybuilder/syntax/emitter/types/delete.rs

@@ -131,7 +131,7 @@ mod tests {
             kind: ConditionClauseKind::Where,
             column_name: "id".into(),
             operator: Operator::Eq,
-            value_indexes: Range::new_unbounded(3),
+            value_indexes: Some(Range::new_unbounded(3)),
         });
 
         let sql = render_standard(&ast, &mut base_ast);

canyon_core/src/query/querybuilder/syntax/emitter/types/update.rs

@@ -170,7 +170,7 @@ mod tests {
             kind: ConditionClauseKind::Where,
             column_name: "id".into(),
             operator: Operator::Eq,
-            value_indexes: Range::new_unbounded(3),
+            value_indexes: Some(Range::new_unbounded(3)),
         });
 
         let sql = render_standard(&ast, &mut base_ast);
@@ -212,7 +212,7 @@ mod tests {
             kind: ConditionClauseKind::Where,
             column_name: "id".into(),
             operator: Operator::Eq,
-            value_indexes: Range::new_unbounded(3),
+            value_indexes: Some(Range::new_unbounded(3)),
         });
 
         let sql = render_standard(&ast, &mut base_ast);

canyon_core/src/query/querybuilder/syntax/writer.rs

@@ -51,8 +51,7 @@ mod __impl {
             SqlToken::Symbol(sym) => __detail::render_symbol(sym, f)?,
             SqlToken::Operator(op) => write!(f, "{}", op)?,
             SqlToken::Placeholder => {
-                __detail::write_value_placeholder::<D>(placeholder_counter, f)?;
-                *placeholder_counter += 1;
+                __detail::write_value_placeholder::<D>(placeholder_counter, f)?
             }
             SqlToken::WhiteSpace => write!(f, " ")?,
             SqlToken::Number(num) => write!(f, "{}", num)?,
@@ -62,6 +61,9 @@ mod __impl {
 }
 
 mod __detail {
+    use crate::query::operators::Operator;
+    use crate::query::querybuilder::syntax::tokens::ToSqlTokens;
+    use crate::query::querybuilder::syntax::writer::__impl::output_token_to_string_buffer;
     use crate::{
         connection::database_type::DatabaseType,
         query::querybuilder::syntax::{dialect::SqlDialect, symbol::Symbol},
@@ -103,6 +105,8 @@ mod __detail {
             _ => write!(f, "{}{}", placeholder_symbol, placeholder_counter),
         };
 
+        *placeholder_counter += 1;
+
         Ok(())
     }
 }

canyon_core/src/query/querybuilder/types/mod.rs

@@ -184,7 +184,7 @@ mod __impl {
             kind,
             column_name: column_name.into(),
             operator,
-            value_indexes: Range::new_unbounded(_self.params.len()),
+            value_indexes: Some(Range::new_unbounded(_self.params.len())),
         });
     }
 
@@ -199,7 +199,7 @@ mod __impl {
             kind,
             column_name: column_name.into(),
             operator,
-            value_indexes: value_indexes_range,
+            value_indexes: Some(value_indexes_range),
         });
     }
 }

tests/crud/querybuilder_operations.rs

@@ -89,9 +89,10 @@ fn test_crud_find_with_querybuilder_and_fulllike() {
 
     assert_eq!(
         filtered_leagues_result.build().unwrap().sql,
-        "SELECT * FROM league WHERE name LIKE CONCAT('%', CAST($1 AS VARCHAR) ,'%')"
+        "SELECT * FROM \"league\" WHERE \"name\" LIKE CONCAT ('%', CAST ($1 AS VARCHAR), '%');"
     )
 }
+
 //
 // /// Builds a new SQL statement for retrieves entities of the `T` type, filtered
 // /// with the parameters that modifies the base SQL to SELECT * FROM <entity>