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

Author: TheRustifyer

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

@@ -5,13 +5,21 @@ use std::error::Error;
 use crate::query::bounds::{FieldIdentifier, FieldValueIdentifier, TableMetadata};
 use crate::query::operators::Comp;
 use crate::query::parameters::QueryParameter;
+use crate::query::querybuilder::syntax::column::ColumnRef;
 
 pub trait DeleteQueryBuilderOps<'a>: QueryBuilderOps<'a> {}
 
 pub trait UpdateQueryBuilderOps<'a>: QueryBuilderOps<'a> {
     /// Creates an SQL `SET` clause by specifying the columns that must be updated in the sentence,
-    /// but without adding any [`QueryParameter`] value to the internal querybuilder
-    fn set(self, columns: &'a [String]) -> Result<Self, Box<dyn Error + Send + Sync + 'a>>
+    /// but without adding any [`QueryParameter`] value to the internal querybuilder.
+    /// 
+    /// Is it the responsibility of the callee to pass the query values that will match the generated
+    /// sql placeholders
+    /// 
+    /// Note: If there's values already on the querybuilder, and the only placeholders api is called,
+    /// UB (provisionally) will occur, since we're refactoring the API's and these are subject to change
+    /// at any time while in the v0.x.x
+    fn set<I: Into<ColumnRef<'a>>>(self, columns: Vec<I>) -> Result<Self, Box<dyn Error + Send + Sync + 'a>>
           where Self: Sized;
 
     /// Similar to [`Self::set`] but storing the underlying update values for each column in the
@@ -26,7 +34,7 @@ pub trait UpdateQueryBuilderOps<'a>: QueryBuilderOps<'a> {
 pub trait SelectQueryBuilderOps<'a>: QueryBuilderOps<'a> {
     /// Adds the column names that must be added to the query in order to retrieve the correct mapped fields
     /// If this method isn't invoked, the querybuilder will create a SELECT * FROM query
-    fn with_columns(self, columns: &'a [String]) -> Self;
+    fn with_columns<I: Into<ColumnRef<'a>>>(self, columns: Vec<I>) -> Self;
 
     /// Adds a *LEFT JOIN* SQL statement to the underlying
     /// `Sql Statement` held by the [`QueryBuilder`], where:
@@ -121,16 +129,16 @@ pub trait SelectQueryBuilderOps<'a>: QueryBuilderOps<'a> {
 pub trait QueryBuilderOps<'a> {
     /// Returns a read-only reference to the underlying SQL sentence,
     /// with the same lifetime as self
-    fn read_sql(&'a self) -> &'a str;
-
-    /// Public interface for append the content of a slice to the end of
-    /// the underlying SQL sentence.
-    ///
-    /// This mutator will allow the user to wire SQL code to the already
-    /// generated one
-    ///
-    /// * `sql` - The [`&str`] to be wired in the SQL
-    fn push_sql(self, sql: &str);
+    // fn read_sql(&'a self) -> &'a str;
+
+    // /// Public interface for append the content of a slice to the end of
+    // /// the underlying SQL sentence.
+    // ///
+    // /// This mutator will allow the user to wire SQL code to the already
+    // /// generated one
+    // ///
+    // /// * `sql` - The [`&str`] to be wired in the SQL
+    // fn push_sql(self, sql: &str);
 
     /// Generates a `WHERE` SQL clause for constraint the query.
     ///

canyon_core/src/query/querybuilder/mod.rs

@@ -1,6 +1,5 @@
 pub mod contracts;
 pub mod types;
 pub mod syntax;
-mod ast;
 
 pub use self::{contracts::*, types::*};

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

@@ -0,0 +1,29 @@
+use crate::query::querybuilder::syntax::emitter::{AstProcessor, EmitFrom, EmitKind};
+use crate::query::querybuilder::syntax::table_metadata::TableMetadata;
+use crate::query::querybuilder::syntax::tokens::{SqlToken, ToSqlTokens};
+
+pub struct DeleteAst {}
+
+impl AstProcessor for DeleteAst {}
+
+impl<'a> EmitKind<'a> for DeleteAst {
+    fn emit_kind(&self, out: &mut Vec<SqlToken<'a>>) {
+        out.push(SqlToken::new_keyword("DELETE"));
+    }
+}
+impl<'a> EmitFrom<'a> for DeleteAst {
+    fn emit_from<'b>(&self, meta: &TableMetadata<'b>, out: &mut Vec<SqlToken<'b>>) {
+        out.push(SqlToken::new_keyword("FROM"));
+        meta.to_tokens(out);
+    }
+}
+
+impl Default for DeleteAst {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl DeleteAst {
+    pub fn new() -> Self { Self{} }
+}

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

@@ -0,0 +1,49 @@
+use std::borrow::Cow;
+use crate::query::parameters::QueryParameter;
+use crate::query::querybuilder::syntax::emitter::{EmitBody, EmitFrom, EmitKind};
+use crate::query::querybuilder::syntax::table_metadata::TableMetadata;
+use crate::query::querybuilder::syntax::tokens::{SqlToken, Symbol, ToSqlTokens};
+use crate::query::querybuilder::syntax::tokens::Symbol::{Comma, LParen, RParen};
+
+pub struct InsertAst<'a> {
+    pub columns: Vec<&'a str>,
+    pub values: Vec<&'a dyn QueryParameter>,
+}
+
+impl<'a> EmitKind<'a> for InsertAst<'a> {
+    fn emit_kind(&self, out: &mut Vec<SqlToken<'a>>) {
+        out.push(SqlToken::new_keyword("INSERT"));
+    }
+}
+impl<'a> EmitFrom<'a> for InsertAst<'a> {
+    fn emit_from<'b>(&self, meta: &TableMetadata<'b>, out: &mut Vec<SqlToken<'b>>) {
+        if !self.columns.is_empty() { // this can't be emitted here
+            // TODO: can we create like a pre-validator trait a-la-emit-kind but for checking invariants?
+            out.push(SqlToken::new_ident("INTO"));
+            meta.to_tokens(out);
+            out.push(SqlToken::Symbol(LParen));
+            for (i, c) in self.columns.iter().enumerate() {
+                if i > 0 { out.push(SqlToken::Symbol(Symbol::Comma)); }
+                //out.push(SqlToken::new_ident(c));
+            }
+            out.push(SqlToken::Symbol(Symbol::RParen));
+        }
+    }
+}
+impl<'a> EmitBody<'a> for InsertAst<'a> {
+    fn emit_body(&self, out: &mut Vec<SqlToken<'a>>) {
+        out.push(SqlToken::Keyword(Cow::Borrowed("VALUES")));
+        out.push(SqlToken::Symbol(LParen));
+        // for i in 0..self.values_count {
+        //     if i > 0 { out.push(SqlToken::Symbol(Comma)); }
+        //     // out.push(SqlToken::PlaceholderNext); self as the real type and call a custom impl
+        // }
+        out.push(SqlToken::Symbol(RParen));
+    }
+}
+
+impl<'a> InsertAst<'a> {
+    pub fn new() -> Self {
+        Self { columns: Vec::new(), values: Vec::new() }
+    }
+}

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

@@ -1,60 +1,22 @@
-pub mod select;
+pub(crate) mod select;
+pub(crate) mod insert;
+pub(crate) mod update;
+pub(crate) mod delete;
 
-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 {
+    pub fn new(table: impl Into<TableMetadata<'a>>) -> Self {
         Self {
-            kind,
-            table,
+            table: table.into(),
             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) }
-    }
-}

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

@@ -1,18 +1,14 @@
 use std::borrow::Cow;
-use crate::connection::database_type::DatabaseType;
-use crate::query::querybuilder::syntax::ast::BaseAst;
 use crate::query::querybuilder::syntax::column::ColumnRef;
 use crate::query::querybuilder::syntax::emitter::{AstProcessor, EmitBody, EmitFrom, EmitKind};
 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::query_kind::QueryKind;
 use crate::query::querybuilder::syntax::table_metadata::TableMetadata;
 use crate::query::querybuilder::syntax::tokens::{SqlToken, Symbol, ToSqlTokens};
 
 #[derive(Default)]
 pub struct SelectAst<'a> {
-    pub base: BaseAst<'a>,
     pub columns: Vec<ColumnRef<'a>>,
     pub joins: Vec<JoinClause<'a>>,
     pub group_by: Vec<&'a str>,
@@ -23,9 +19,8 @@ pub struct SelectAst<'a> {
 }
 
 impl<'a> SelectAst<'a> {
-    pub fn new(table: TableMetadata<'a>, db: DatabaseType) -> Self {
+    pub fn new() -> Self {
         Self {
-            base: BaseAst::new(QueryKind::Select, table, db),
             columns: Vec::new(),
             joins: Vec::new(),
             group_by: Vec::new(),
@@ -46,7 +41,7 @@ impl<'a> EmitKind<'a> for SelectAst<'a> {
 }
 
 impl<'a> EmitFrom<'a> for SelectAst<'a> {
-    fn emit_from<'b: 'a>(&'b self, meta: &'b TableMetadata<'b>, out: &mut Vec<SqlToken<'b>>)  {
+    fn emit_from<'b>(&self, meta: &TableMetadata<'b>, out: &mut Vec<SqlToken<'b>>)  {
         // columns
         if self.columns.is_empty() {
             out.push(SqlToken::Symbol(Symbol::Asterisk));
@@ -59,7 +54,7 @@ impl<'a> EmitFrom<'a> for SelectAst<'a> {
         // FROM
         out.push(SqlToken::new_keyword("FROM"));
         meta.to_tokens(out);
-        
+
         // joins (simplified)
         for j in &self.joins {
             out.push(SqlToken::new_keyword("LEFT JOIN")); // TODO: actual placeholder until

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

@@ -0,0 +1,40 @@
+use crate::query::querybuilder::syntax::column::ColumnRef;
+use crate::query::querybuilder::syntax::emitter::{AstProcessor, EmitBody, EmitKind};
+use crate::query::querybuilder::syntax::tokens::SqlToken;
+
+pub struct UpdateAst<'a> {
+    pub columns: Vec<ColumnRef<'a>>,
+}
+
+impl<'a> AstProcessor for UpdateAst<'a> {}
+
+impl<'a> EmitKind<'a> for UpdateAst<'a> {
+    fn emit_kind(&self, out: &mut Vec<SqlToken<'a>>) {
+        out.push(SqlToken::new_keyword("UPDATE"));
+    }
+}
+
+impl<'a> EmitBody<'a> for UpdateAst<'a> {
+    fn emit_body(&self, out: &mut Vec<SqlToken<'a>>) {
+        out.push(SqlToken::new_keyword("SET"));
+
+        // for (i, (col, _val)) in self.columns.iter().enumerate() {
+        //     if i > 0 { out.push(SqlToken::Symbol(",")); }
+        //     out.push(SqlToken::Ident(col));
+        //     out.push(SqlToken::Symbol("="));
+        //     out.push(SqlToken::PlaceholderNext);
+        // }
+    }
+}
+
+impl<'a> Default for UpdateAst<'a> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<'a> UpdateAst<'a> {
+    pub fn new() -> Self {
+        Self { columns: Vec::new() }
+    }
+}

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

@@ -1,16 +1,37 @@
 #[derive(Debug, Clone)]
 pub struct ColumnRef<'a> {
-    pub name: &'a str,
+    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 alias: Option<&'a str>,
 }
 
+impl<'a> From<&'a str> for ColumnRef<'a> {
+    fn from(value: &'a str) -> Self {
+        Self::new(value)
+    }
+}
+
 impl<'a> ColumnRef<'a> {
-    pub fn new(name: &'a str) -> Self {
-        Self { name, alias: None }
+    pub fn new(column_name: &'a str) -> Self {
+        Self { column: column_name, table: None, alias: None }
     }
-    pub fn aliased(name: &'a str, alias: &'a str) -> Self {
-        Self { name, alias: Some(alias) }
+
+    /// mutator that allows to modify a [`ColumnRef`] to have a <table>.<column> format
+    ///
+    /// Ex: SELECT * FROM <table>.<column> as <alias>
+    pub fn table(mut self, table: &'a str) -> Self {
+        self.table = Some(table);
+        self
+    }
+
+    /// mutator that allows to modify a [`ColumnRef`] to have a AS clause for
+    /// specify a SQL alias
+    ///
+    /// Ex: SELECT * FROM <table>.<column> as <alias>
+    pub fn alias(mut self, alias: &'a str) -> Self {
+        self.alias = Some(alias);
+        self
     }
 }