refactor(WIP)!: rollback the introduction of the querybuilder on the crud operations macros

Author: TheRustifyer

canyon_core/src/connection/clients/mssql.rs

@@ -153,6 +153,7 @@ pub(crate) mod sqlserver_query_launcher {
         params: &[&'a dyn QueryParameter],
     ) -> Query<'a> {
         let mut stmt = String::from(stmt);
+        println!("Detected query mssql: {stmt}");
         if stmt.contains("RETURNING") {
             // TODO: when the InsertQuerybuilder with a api on the builder for the returning clause
             let c = stmt.clone();

canyon_core/src/connection/clients/postgresql.rs

@@ -34,6 +34,7 @@ impl DbConnection for PostgresConnector {
         stmt: &str,
         params: &[&'_ dyn QueryParameter],
     ) -> Result<CanyonRows, Box<dyn Error + Send + Sync>> {
+        println!("Postgres query rows: {:?}", stmt);
         let r = self
             .get_pooled()
             .await?
@@ -70,6 +71,7 @@ impl DbConnection for PostgresConnector {
     where
         R: RowMapper,
     {
+        println!("Postgres query one: {}", stmt);
         let result = self
             .get_pooled()
             .await?

canyon_core/src/query/operators.rs

@@ -7,7 +7,7 @@ pub trait Operator: Display {
 
 /// Enumerated type for represent the comparison operations
 /// in SQL sentences
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Copy, Clone)]
 pub enum Comp {
     /// Operator "=" equals
     Eq,
@@ -41,7 +41,7 @@ impl Display for Comp {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Copy, Clone)]
 pub enum LikeKind {
     /// Operator "LIKE"  as '%pattern%'
     Full,

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

@@ -2,10 +2,11 @@
 //! of the behaviour of the Canyon-SQL QueryBuilder
 
 use std::error::Error;
-use crate::query::bounds::{FieldIdentifier, FieldValueIdentifier, TableMetadata};
+use crate::query::bounds::{FieldIdentifier, FieldValueIdentifier};
 use crate::query::operators::Comp;
 use crate::query::parameters::QueryParameter;
 use crate::query::querybuilder::syntax::column::ColumnRef;
+use crate::query::querybuilder::syntax::table_metadata::TableMetadata;
 
 pub trait DeleteQueryBuilderOps<'a>: QueryBuilderOps<'a> {}
 
@@ -46,9 +47,9 @@ pub trait SelectQueryBuilderOps<'a>: QueryBuilderOps<'a> {
     /// > Note: The order on the column parameters is irrelevant
     fn left_join(
         self,
-        join_table: impl TableMetadata<'a>,
-        col1: impl FieldIdentifier,
-        col2: impl FieldIdentifier,
+        join_table: impl Into<TableMetadata<'a>>,
+        col1: impl Into<ColumnRef<'a>>,
+        col2: impl Into<ColumnRef<'a>>,
     ) -> Self;
 
     /// Adds a *INNER JOIN* SQL statement to the underlying
@@ -61,9 +62,9 @@ pub trait SelectQueryBuilderOps<'a>: QueryBuilderOps<'a> {
     /// > Note: The order on the column parameters is irrelevant
     fn inner_join(
         self,
-        join_table: impl TableMetadata<'a>,
-        col1: impl FieldIdentifier,
-        col2: impl FieldIdentifier,
+        join_table: impl Into<TableMetadata<'a>>,
+        col1: impl Into<ColumnRef<'a>>,
+        col2: impl Into<ColumnRef<'a>>,
     ) -> Self;
 
     /// Adds a *RIGHT JOIN* SQL statement to the underlying
@@ -76,9 +77,9 @@ pub trait SelectQueryBuilderOps<'a>: QueryBuilderOps<'a> {
     /// > Note: The order on the column parameters is irrelevant
     fn right_join(
         self,
-        join_table: impl TableMetadata<'a>,
-        col1: impl FieldIdentifier,
-        col2: impl FieldIdentifier,
+        join_table: impl Into<TableMetadata<'a>>,
+        col1: impl Into<ColumnRef<'a>>,
+        col2: impl Into<ColumnRef<'a>>,
     ) -> Self;
 
     /// Adds a *FULL JOIN* SQL statement to the underlying
@@ -91,10 +92,16 @@ pub trait SelectQueryBuilderOps<'a>: QueryBuilderOps<'a> {
     /// > Note: The order on the column parameters is irrelevant
     fn full_join(
         self,
-        join_table: impl TableMetadata<'a>,
-        col1: impl FieldIdentifier,
-        col2: impl FieldIdentifier,
+        join_table: impl Into<TableMetadata<'a>>,
+        col1: impl Into<ColumnRef<'a>>,
+        col2: impl Into<ColumnRef<'a>>,
     ) -> Self;
+
+    /// Generates a `ORDER BY` SQL clause for constraint the query.
+    ///
+    /// * `order_by` - A [`FieldIdentifier`] that will provide the target  column name
+    /// * `desc` - a boolean indicating if the generated `ORDER_BY` must be in ascending or descending order
+    fn order_by<Z: FieldIdentifier + Into<ColumnRef<'a>>>(self, order_by: Z, desc: bool) -> Self;
 }
 
 /// The [`QueryBuilder`] trait is the root of a kind of hierarchy
@@ -145,8 +152,11 @@ pub trait QueryBuilderOps<'a> {
     /// * `column` - An [`&str`] that will provide the target column name
     /// * `op` - Any element that implements [`Operator`] for create the comparison
     ///   or equality binary operator
-    ///  * `value` - Any implementor of [`QueryParameter] that will be the value to filter
-    fn r#where(self, column: &'a str, op: Comp, value: &'a dyn QueryParameter) -> Self;
+    ///
+    ///  It will generate a SQL statement with the where constraint value generated as a placeholder,
+    /// depending on the underlying database driver and the number of elements already added to the
+    /// querybuilder
+    fn r#where(self, column: &'a str, op: Comp) -> Self;
 
     /// Generates a `WHERE` SQL clause for constraint the query.
     ///
@@ -198,10 +208,4 @@ pub trait QueryBuilderOps<'a> {
     /// * `op` - Any element that implements [`Operator`] for create the comparison
     ///   or equality binary operator
     fn or<Z: FieldValueIdentifier>(self, column: &'a Z, op: Comp) -> Self;
-
-    /// Generates a `ORDER BY` SQL clause for constraint the query.
-    ///
-    /// * `order_by` - A [`FieldIdentifier`] that will provide the target  column name
-    /// * `desc` - a boolean indicating if the generated `ORDER_BY` must be in ascending or descending order
-    fn order_by<Z: FieldIdentifier>(self, order_by: Z, desc: bool) -> Self;
 }

canyon_core/src/query/querybuilder/syntax/ast/select.rs

@@ -4,28 +4,29 @@ use crate::query::querybuilder::syntax::emitter::{AsEmitBody, AsEmitFrom, AsEmit
 use crate::query::querybuilder::syntax::having::HavingClause;
 use crate::query::querybuilder::syntax::join::JoinClause;
 use crate::query::querybuilder::syntax::order::OrderByClause;
+use crate::query::querybuilder::syntax::symbol::Symbol;
 use crate::query::querybuilder::syntax::table_metadata::TableMetadata;
-use crate::query::querybuilder::syntax::tokens::{SqlToken, Symbol, ToSqlTokens};
+use crate::query::querybuilder::syntax::tokens::{SqlToken, ToSqlTokens};
 
 #[derive(Default)]
 pub struct SelectAst<'a> {
     pub columns: Vec<ColumnRef<'a>>,
     pub joins: Vec<JoinClause<'a>>,
-    pub group_by: Vec<&'a str>,
-    pub having: Vec<HavingClause<'a>>,
-    pub order_by: Vec<OrderByClause<'a>>,
+    pub order_by: Option<OrderByClause<'a>>,
+    pub having: Option<HavingClause<'a>>,
+    pub group_by: Vec<ColumnRef<'a>>, // TODO: ColumnRef
     pub limit: Option<u64>, // TODO: strong typing
     pub offset: Option<u64>,
 }
 
 impl<'a> SelectAst<'a> {
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self {
             columns: Vec::new(),
             joins: Vec::new(),
+            order_by: None,
             group_by: Vec::new(),
-            having: Vec::new(),
-            order_by: Vec::new(),
+            having: None,
             limit: None,
             offset: None,
         }

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

@@ -1,16 +1,13 @@
 use crate::query::operators::Comp;
-use crate::query::parameters::QueryParameter;
-use crate::query::querybuilder::syntax::tokens::SqlToken;
+use crate::query::querybuilder::syntax::column::ColumnRef;
 
-pub struct ConditionClause<'a> {
-    // TODO: where are missing complex where usages, like in joins, so we should consider to add the table
-    // to the column like where table.column = ...
+#[derive(Clone)] pub struct ConditionClause<'a> {
     pub(crate) kind: ConditionClauseKind,
-    pub(crate) column_name: SqlToken<'a>,
+    pub(crate) column_name: ColumnRef<'a>,
     pub(crate) operator: Comp,
-    pub(crate) value: &'a dyn QueryParameter
+    pub(crate) value_index: usize,
 }
-#[derive(Eq, PartialEq)]
+#[derive(Eq, PartialEq, Clone)]
 pub enum ConditionClauseKind {
     Where,
     And,

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

@@ -1,12 +1,10 @@
+use crate::query::querybuilder::syntax::symbol::Symbol::Dot;
 use crate::query::querybuilder::syntax::tokens::{SqlToken, ToSqlTokens};
-use crate::query::querybuilder::syntax::tokens::Symbol::Dot;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct ColumnRef<'a> {
-    pub column: &'a str,
     pub table: Option<&'a str>,
-    // TODO: we need the table <table.column> no?
-    // TODO: so we need a ColumnRefBuilder, to avoid have 70 new different new methods?
+    pub column: &'a str,
     pub alias: Option<&'a str>,
 }
 

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

@@ -1,14 +1,15 @@
 use crate::query::operators::Comp;
 use crate::query::parameters::QueryParameter;
+use crate::query::querybuilder::syntax::column::ColumnRef;
 
 pub struct HavingClause<'a> {
-    pub column: &'a str,
+    pub column: ColumnRef<'a>,
     pub operator: Comp,
     pub value: &'a dyn QueryParameter, // TODO: shouldn't this be a placeholder?
 }
 
 impl<'a> HavingClause<'a> {
-    pub fn new(column: &'a str, operator: Comp, value: &'a dyn QueryParameter) -> Self {
-        Self { column, operator, value }
+    pub fn new<I: Into<ColumnRef<'a>>>(column: I, operator: Comp, value: &'a dyn QueryParameter) -> Self {
+        Self { column: column.into(), operator, value }
     }
 }

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

@@ -1,5 +1,7 @@
 use crate::query::operators::Comp;
+use crate::query::querybuilder::syntax::column::ColumnRef;
 use crate::query::querybuilder::syntax::table_metadata::TableMetadata;
+use crate::query::querybuilder::syntax::tokens::{SqlToken, ToSqlTokens};
 
 #[derive(Debug, Clone, Copy)]
 pub enum JoinKind {
@@ -22,14 +24,53 @@ impl JoinKind {
 
 pub struct JoinClause<'a> {
     pub kind: JoinKind,
-    pub table: TableMetadata<'a>, // TODO: this should be the target table, and the origin table
-    pub left: &'a str,  // e.g. "t1.id" // TODO: we need to filter and check the syntax
+    pub target_table: TableMetadata<'a>, // TODO: this should be the target table, and the origin table
+    pub left: ColumnRef<'a>,  // e.g. "t1.id" // TODO: we need to filter and check the syntax
     pub operator: Comp, // usually Eq
-    pub right: &'a str, // e.g. "t2.t1_id"
+    pub right: ColumnRef<'a>, // e.g. "t2.t1_id" // TODO: this is always the base or the previous (at least, in one of the sides)
+    // so we could look in the vector for the previous clause and auto-add the join
 }
 
 impl<'a> JoinClause<'a> {
-    pub fn new(kind: JoinKind, table: TableMetadata<'a>, left: &'a str, operator: Comp, right: &'a str) -> Self {
-        Self { kind, table, left, operator, right }
+    pub fn new<I: Into<ColumnRef<'a>>>(kind: JoinKind, target_table: TableMetadata<'a>, left: I, operator: Comp, right: I) -> Self {
+        Self { kind, target_table, left: left.into(), operator, right: right.into() }
     }
 }
+
+impl<'a> ToSqlTokens<'a> for JoinClause<'a> {
+    fn to_tokens(&self, out: &mut Vec<SqlToken<'a>>) {
+        out.push(SqlToken::new_ident(self.kind.as_str()));
+        self.target_table.to_tokens(out);
+
+
+    }
+}
+#[test]
+fn test_join_clause_basic() {
+    use crate::query::operators::Comp;
+    use crate::query::querybuilder::syntax::tokens::{SqlToken, Symbol};
+
+    let mock_value = 99;
+
+    let join = JoinClause {
+        kind: JoinKind::Inner,
+        target_table: TableMetadata::new("target_table"),
+        left: "t.id".into(),
+        operator: Comp::Eq,
+        right: "users.team_id".into()
+    };
+
+    let mut tokens = Vec::new();
+    join.to_tokens(&mut tokens);
+
+    let expected = vec![
+        SqlToken::Keyword("INNER JOIN".into()),
+        SqlToken::Ident("users".into()),
+        SqlToken::Keyword("ON".into()),
+        SqlToken::Ident("t.id".into()),
+        SqlToken::Symbol(Symbol::Equals),
+        SqlToken::Ident("users.team_id".into()),
+    ];
+
+    assert_eq!(tokens, expected);
+}

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

@@ -0,0 +1,3 @@
+pub enum Keyword {
+    
+}