refactor(WIP)!: querybuilder now is made of AST types for query generation

Author: TheRustifyer

canyon_core/src/connection/database_type.rs

@@ -27,7 +27,7 @@ use std::fmt::Display;
 /// let builder = QueryBuilder::new_for(table, columns, DatabaseType::Deferred)?;
 /// let query = builder.build()?; // will resolve to the default DB type
 /// ```
-#[derive(Deserialize, Debug, Eq, PartialEq, Clone, Copy)]
+#[derive(Deserialize, Debug, Eq, PartialEq, Clone, Copy, Default)]
 pub enum DatabaseType {
     /// The Postgres database backend.
     #[cfg(feature = "postgres")]
@@ -70,7 +70,7 @@ pub enum DatabaseType {
     /// .where_("id", Comp::Eq, &42)
     /// .build()?; // resolved dynamically to the active database type
     /// ```
-    Deferred,
+    #[default] Deferred,
 }
 
 impl Display for DatabaseType {

canyon_core/src/query/bounds.rs

@@ -37,7 +37,7 @@ pub trait Inspectionable<'a> {
     ) -> Result<(), Box<dyn std::error::Error + Send + Sync>>;
 }
 
-pub trait TableMetadata: std::fmt::Display {
+pub trait TableMetadata<'a>: std::fmt::Display {
     fn as_str(&self) -> &'static str;
 }
 

canyon_core/src/query/operators.rs

@@ -7,6 +7,7 @@ pub trait Operator: Display {
 
 /// Enumerated type for represent the comparison operations
 /// in SQL sentences
+#[derive(Debug)]
 pub enum Comp {
     /// Operator "=" equals
     Eq,
@@ -20,8 +21,11 @@ pub enum Comp {
     Lt,
     /// Operator "=<" less or equals than value
     LtEq,
+    /// A "LIKE" comp operator
+    Like(LikeKind)
 }
 
+
 impl Display for Comp {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let op = match *self {
@@ -31,25 +35,14 @@ impl Display for Comp {
             Self::GtEq => ">=",
             Self::Lt => "<",
             Self::LtEq => "<=",
+            Self::Like(ref __kind) => "LIKE"
         };
         write!(f, "{}", op)
     }
 }
 
-impl Operator for Comp {
-    fn as_str(&self, placeholder_counter: usize, _with_type: &DatabaseType) -> String {
-        match *self {
-            Self::Eq => format!(" = ${placeholder_counter}"),
-            Self::Neq => format!(" <> ${placeholder_counter}"),
-            Self::Gt => format!(" > ${placeholder_counter}"),
-            Self::GtEq => format!(" >= ${placeholder_counter}"),
-            Self::Lt => format!(" < ${placeholder_counter}"),
-            Self::LtEq => format!(" <= ${placeholder_counter}"),
-        }
-    }
-}
-
-pub enum Like {
+#[derive(Debug)]
+pub enum LikeKind {
     /// Operator "LIKE"  as '%pattern%'
     Full,
     /// Operator "LIKE"  as '%pattern'
@@ -58,7 +51,7 @@ pub enum Like {
     Right,
 }
 
-impl Operator for Like {
+impl Operator for LikeKind {
     fn as_str(&self, placeholder_counter: usize, datasource_type: &DatabaseType) -> String {
         let type_data_to_cast_str = match datasource_type {
             #[cfg(feature = "postgres")]
@@ -71,30 +64,30 @@ impl Operator for Like {
         };
 
         match *self {
-            Like::Full => {
+            Self::Full => {
                 format!(
                     " LIKE CONCAT('%', CAST(${placeholder_counter} AS {type_data_to_cast_str}) ,'%')"
                 )
             }
-            Like::Left => format!(
+            Self::Left => format!(
                 " LIKE CONCAT('%', CAST(${placeholder_counter} AS {type_data_to_cast_str}))"
             ),
-            Like::Right => format!(
+            Self::Right => format!(
                 " LIKE CONCAT(CAST(${placeholder_counter} AS {type_data_to_cast_str}) ,'%')"
             ),
         }
     }
 }
 
-impl Display for Like {
+impl Display for LikeKind {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
             "{}",
             match *self {
-                Like::Full => "Like::Full",
-                Like::Left => "Like::Left",
-                Like::Right => "Like::Right",
+                Self::Full => "Like::Full",
+                Self::Left => "Like::Left",
+                Self::Right => "Like::Right",
             }
         )
     }

canyon_core/src/query/querybuilder/ast.rs

@@ -16,12 +16,11 @@ pub trait UpdateQueryBuilderOps<'a>: QueryBuilderOps<'a> {
 
     /// Similar to [`Self::set`] but storing the underlying update values for each column in the
     /// internal values collection of the [`crate::query::querybuilder::QueryBuilder`]
-    fn set_with_values<Z, Q>(self, columns: &'a [(Z, Q)]) -> Result<Self, Box<dyn Error + Send + Sync + 'a>>
+    fn set_values<Z, Q>(self, columns: &'a [(Z, Q)]) -> Result<Self, Box<dyn Error + Send + Sync + 'a>>
     where
         Z: FieldIdentifier,
         Q: QueryParameter,
-        Self: Sized,
-        Vec<&'a dyn QueryParameter>: Extend<&'a Q>;
+        Self: Sized;
 }
 
 pub trait SelectQueryBuilderOps<'a>: QueryBuilderOps<'a> {
@@ -39,7 +38,7 @@ pub trait SelectQueryBuilderOps<'a>: QueryBuilderOps<'a> {
     /// > Note: The order on the column parameters is irrelevant
     fn left_join(
         self,
-        join_table: impl TableMetadata,
+        join_table: impl TableMetadata<'a>,
         col1: impl FieldIdentifier,
         col2: impl FieldIdentifier,
     ) -> Self;
@@ -54,7 +53,7 @@ pub trait SelectQueryBuilderOps<'a>: QueryBuilderOps<'a> {
     /// > Note: The order on the column parameters is irrelevant
     fn inner_join(
         self,
-        join_table: impl TableMetadata,
+        join_table: impl TableMetadata<'a>,
         col1: impl FieldIdentifier,
         col2: impl FieldIdentifier,
     ) -> Self;
@@ -69,7 +68,7 @@ pub trait SelectQueryBuilderOps<'a>: QueryBuilderOps<'a> {
     /// > Note: The order on the column parameters is irrelevant
     fn right_join(
         self,
-        join_table: impl TableMetadata,
+        join_table: impl TableMetadata<'a>,
         col1: impl FieldIdentifier,
         col2: impl FieldIdentifier,
     ) -> Self;
@@ -84,7 +83,7 @@ pub trait SelectQueryBuilderOps<'a>: QueryBuilderOps<'a> {
     /// > Note: The order on the column parameters is irrelevant
     fn full_join(
         self,
-        join_table: impl TableMetadata,
+        join_table: impl TableMetadata<'a>,
         col1: impl FieldIdentifier,
         col2: impl FieldIdentifier,
     ) -> Self;
@@ -168,8 +167,7 @@ pub trait QueryBuilderOps<'a> {
     where
         Z: FieldIdentifier,
         Q: QueryParameter,
-        Vec<&'a (dyn QueryParameter + 'a)>: Extend<&'a Q>,
-        Self: std::marker::Sized;
+        Self: Sized;
 
     /// Generates an `OR` SQL clause for constraint the query that will create
     /// the filter in conjunction with an `IN` operator that will ac
@@ -183,8 +181,7 @@ pub trait QueryBuilderOps<'a> {
     where
         Z: FieldIdentifier,
         Q: QueryParameter,
-        Vec<&'a (dyn QueryParameter + 'a)>: Extend<&'a Q>,
-        Self: std::marker::Sized;
+        Self: Sized;
 
     /// Generates an `OR` SQL clause for constraint the query.
     ///

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

@@ -0,0 +1,60 @@
+pub mod select;
+
+use crate::connection::database_type::DatabaseType;
+use crate::query::parameters::QueryParameter;
+use crate::query::querybuilder::syntax::clause::ConditionClause;
+use crate::query::querybuilder::syntax::table_metadata::TableMetadata;
+use crate::query::querybuilder::syntax::query_kind::QueryKind;
+
+/// Base AST for common parts
+#[derive(Default)] pub struct BaseAst<'a> {
+    pub kind: QueryKind,
+    pub table: TableMetadata<'a>,
+    pub conditions: Vec<ConditionClause<'a>>,
+}
+
+impl<'a> BaseAst<'a> {
+    pub fn new(kind: QueryKind, table: TableMetadata<'a>, database_type: DatabaseType) -> Self {
+        Self {
+            kind,
+            table,
+            conditions: Vec::new()
+        }
+    }
+}
+
+/// Select AST
+
+
+pub struct InsertAst<'a> {
+    pub base: BaseAst<'a>,
+    pub columns: Vec<&'a str>,
+    pub values: Vec<&'a dyn QueryParameter>,
+}
+
+impl<'a> InsertAst<'a> {
+    pub fn new(table: TableMetadata<'a>, db: DatabaseType) -> Self {
+        Self { base: BaseAst::new(QueryKind::Insert, table, db), columns: Vec::new(), values: Vec::new() }
+    }
+}
+
+pub struct UpdateAst<'a> {
+    pub base: BaseAst<'a>,
+    pub set_clauses: Vec<(&'a str, &'a dyn QueryParameter)>,
+}
+
+impl<'a> UpdateAst<'a> {
+    pub fn new(table: TableMetadata<'a>, db: DatabaseType) -> Self {
+        Self { base: BaseAst::new(QueryKind::Update, table, db), set_clauses: Vec::new() }
+    }
+}
+
+pub struct DeleteAst<'a> {
+    pub base: BaseAst<'a>,
+}
+
+impl<'a> DeleteAst<'a> {
+    pub fn new(table: TableMetadata<'a>, db: DatabaseType) -> Self {
+        Self { base: BaseAst::new(QueryKind::Delete, table, db) }
+    }
+}