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

Author: TheRustifyer

canyon_core/src/query/querybuilder/mod.rs

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

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

@@ -0,0 +1,30 @@
+use crate::query::operators::Comp;
+use crate::query::parameters::QueryParameter;
+use crate::query::querybuilder::syntax::tokens::SqlToken;
+
+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 = ...
+    pub(crate) kind: ConditionClauseKind,
+    pub(crate) column_name: SqlToken<'a>,
+    pub(crate) operator: Comp,
+    pub(crate) value: &'a dyn QueryParameter
+}
+#[derive(Eq, PartialEq)]
+pub enum ConditionClauseKind {
+    Where,
+    And,
+    Or,
+    In // TODO: should this one be a Comp instead?
+}
+
+impl<'a> AsRef<str> for ConditionClauseKind {
+    fn as_ref(&self) -> &str {
+        match self {
+            ConditionClauseKind::Where => "WHERE",
+            ConditionClauseKind::And => "AND",
+            ConditionClauseKind::In => "IN",
+            ConditionClauseKind::Or => "OR",
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+pub(crate) mod query_kind;
+pub(crate) mod table_metadata;
+pub(crate) mod tokens;
+pub(crate) mod clause;

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

@@ -0,0 +1,27 @@
+use std::borrow::Cow;
+use crate::query::querybuilder::syntax::tokens::{SqlToken, ToSqlTokens};
+
+pub enum QueryKind {
+    Select,
+    Update,
+    Delete,
+}
+
+impl<'a> ToSqlTokens<'a> for QueryKind {
+    fn to_tokens(&self) -> SqlToken<'a> {
+        match self {
+            QueryKind::Select => SqlToken::Keyword(Cow::from("SELECT")),
+            QueryKind::Update => SqlToken::Keyword(Cow::from("UPDATE")),
+            QueryKind::Delete => SqlToken::Keyword(Cow::from("DELETE")),
+        }
+    }
+}
+impl AsRef<str> for QueryKind {
+    fn as_ref(&self) -> &str {
+        match self {
+            QueryKind::Select => { "SELECT" }
+            QueryKind::Update => { "UPDATE " }
+            QueryKind::Delete => { "DELETE " }
+        }
+    }
+}

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

@@ -0,0 +1,79 @@
+use std::fmt::{Display, Formatter};
+use crate::query::querybuilder::syntax::tokens::{SqlToken, ToSqlTokens};
+
+#[derive(Clone, Default, Debug)]
+pub struct TableMetadata {
+    pub schema: Option<String>,
+    pub name: String,
+} // TODO: we can have those fields as Cow<'_> for max performance
+
+impl<'a> ToSqlTokens<'a> for TableMetadata {
+    fn to_tokens(&self) -> SqlToken<'a> {
+        match &self.schema {
+            Some(s) => {
+                out.push(SqlToken::Ident(s));
+                out.push(SqlToken::Symbol('.'));
+                out.push(SqlToken::Ident(&self.name));
+            }
+            None => {
+                out.push(SqlToken::Ident(&self.name));
+            }
+        }
+    }
+}
+impl From<&str> for TableMetadata {
+    /// Creates a new [`TableMetadata`] from a string slice.
+    ///
+    /// If the slice contains a dot, we assume that is a schema.table_name format, otherwise,
+    /// we assume that the client is just creating a [`Self`] from the passed in string
+    fn from(value: &str) -> Self {
+        if let Some((schema, table)) = value.split_once('.') {
+            TableMetadata {
+                schema: Some(schema.to_string()),
+                name: table.to_string(),
+            }
+        } else {
+            TableMetadata {
+                schema: None,
+                name: value.to_string(),
+            }
+        }
+    }
+}
+
+
+impl<'a> TableMetadata {
+    pub fn new(schema: &'a str, name: &'a str) -> Self {
+        Self { schema: Some(schema.to_string()), name: name.to_string() }
+    }
+    pub fn schema(&mut self, schema: String) { self.schema = Some(schema); }
+    pub fn table_name(&mut self, table_name: String) { self.name = table_name }
+
+    /// Returns an already formatted version of the schema and table of a target database table
+    /// ready to be used in a SQL statement.
+    ///
+    /// This method allocates a new string, so it returns an owned one to the callee.
+    /// Just take it in consideration if someday someone uses it outside the macro generation
+    /// and there's some heavy callee procedure
+    pub fn sql(&self) -> String {
+        match &self.schema {
+            Some(schema_name) => {format!("{}.{}", schema_name, self.name)}
+            None => self.name.to_string()
+        }
+    }
+}
+
+impl Display for TableMetadata {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match &self.schema {
+            Some(schema_name) => {write!(f, "{}.{}", schema_name, self.name)}
+            None => {write!(f, "{}", self.name)}
+        }
+    }
+}
+
+impl AsRef<str> for TableMetadata {
+    fn as_ref(&self) -> &str {
+        self.schema.as_ref().unwrap()
+    }
+}

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

@@ -0,0 +1,49 @@
+use std::borrow::Cow;
+use std::fmt::Write;
+use crate::connection::database_type::DatabaseType;
+
+pub trait ToSqlTokens<'a> {
+    fn to_tokens(&self) -> SqlToken<'a>;
+}
+
+pub enum SqlToken<'a> {
+    Keyword(Cow<'a, str>),        // SELECT, WHERE, AND, OR, FROM, UPDATE, DELETE
+    WhiteSpace,
+    Ident(Cow<'a, str>),          // table, column
+    Symbol(char),            // = , ( ) , .
+    Placeholder(usize),      // $1, ? , @P1
+}
+
+pub struct TokenWriter<'a> {
+    pub tokens: Vec<SqlToken<'a>>,
+}
+
+impl<'a> TokenWriter<'a> {
+    pub fn new() -> Self {
+        Self { tokens: Vec::new() }
+    }
+
+    pub fn push(&mut self, token: SqlToken<'a>) {
+        self.tokens.push(token);
+    }
+
+    pub fn render(self, db: DatabaseType) -> String {
+        let mut out = String::new();
+
+        for t in self.tokens {
+            match t {
+                SqlToken::Keyword(k) => write!(out, " {}", k).unwrap(),
+                SqlToken::Ident(i) => write!(out, " {}", i).unwrap(),
+                SqlToken::Symbol(c) => write!(out, " {}", c).unwrap(),
+                SqlToken::Placeholder(p) => match db { // TODO: invent something like placeholder kind, so we can avoid to match it on every pplaceholder?
+                    DatabaseType::PostgreSql => write!(out, " ${}", p).unwrap(),
+                    DatabaseType::SqlServer  => write!(out, " @P{}", p).unwrap(),
+                    DatabaseType::MySQL      => write!(out, " ?").unwrap(),
+                    DatabaseType::Deferred   => write!(out, " ?").unwrap(),
+                },
+            }
+        }
+
+        out.trim_start().to_string()
+    }
+}

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

@@ -1,10 +1,11 @@
 use crate::connection::database_type::DatabaseType;
 use crate::query::bounds::{FieldIdentifier, FieldValueIdentifier};
-use crate::query::operators::{Comp, Operator};
+use crate::query::operators::Comp;
 use crate::query::parameters::QueryParameter;
 use crate::query::query::Query;
 use crate::query::querybuilder::types::TableMetadata;
-use crate::query::querybuilder::{DeleteQueryBuilderOps, QueryBuilder, QueryBuilderOps, QueryKind};
+use crate::query::querybuilder::{DeleteQueryBuilderOps, QueryBuilder, QueryBuilderOps};
+use crate::query::querybuilder::syntax::query_kind::QueryKind;
 use std::error::Error;
 
 /// Contains the specific database operations associated with the