refactor(WIP)!: given the emitters real entity like behaviour

Author: TheRustifyer

canyon_core/src/query/operators.rs

@@ -1,6 +1,7 @@
 use std::fmt::Display;
 use crate::connection::database_type::DatabaseType;
-use crate::query::querybuilder::syntax::tokens::{SqlToken, Symbol, ToSqlTokens};
+use crate::query::querybuilder::syntax::keyword::Keyword;
+use crate::query::querybuilder::syntax::tokens::{SqlToken, SqlTokens, Symbol, ToSqlTokens};
 
 /// Enumerated type for represent the comparison operations
 /// in SQL sentences
@@ -38,24 +39,24 @@ impl Display for Comp {
 }
 
 impl<'a> ToSqlTokens<'a> for Comp {
-    fn to_tokens(&self, out: &mut Vec<SqlToken<'a>>) {
+    fn to_tokens(&self, out: &mut SqlTokens<'a>) {
         match *self {
-            Comp::Eq => out.push(SqlToken::Symbol(Symbol::Equals)),
+            Comp::Eq => out.symbol(Symbol::Equals),
             Comp::Neq => {
-                out.push(SqlToken::Symbol(Symbol::Not));
-                out.push(SqlToken::Symbol(Symbol::Equals))
+                out.symbol(Symbol::Not);
+                out.symbol(Symbol::Equals)
             }
-            Comp::Gt => out.push(SqlToken::Symbol(Symbol::RAngle)),
+            Comp::Gt => out.symbol(Symbol::RAngle),
             Comp::GtEq => {
-                out.push(SqlToken::Symbol(Symbol::RAngle));
-                out.push(SqlToken::Symbol(Symbol::Equals))
+                out.symbol(Symbol::RAngle);
+                out.symbol(Symbol::Equals)
             }
-            Comp::Lt => out.push(SqlToken::Symbol(Symbol::LAngle)),
+            Comp::Lt => out.symbol(Symbol::LAngle),
             Comp::LtEq => {
-                out.push(SqlToken::Symbol(Symbol::LAngle));
-                out.push(SqlToken::Symbol(Symbol::Equals))
+                out.symbol(Symbol::LAngle);
+                out.symbol(Symbol::Equals)
             }
-            Comp::Like(__kind) => out.push(SqlToken::new_keyword("LIKE"))
+            Comp::Like(__kind) => out.keyword(Keyword::Like)
         }
     }
 }

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

@@ -1,23 +1,11 @@
-use crate::query::querybuilder::syntax::emitter::{
-    AsEmitBody, AsEmitFrom, AsEmitKind, AstProcessor, EmitBody, EmitFrom, EmitKind, ToSql,
-};
-use crate::query::querybuilder::syntax::table_metadata::TableMetadata;
-use crate::query::querybuilder::syntax::tokens::{SqlToken, ToSqlTokens};
+use crate::query::querybuilder::syntax::emitter::AstProcessor;
+use crate::query::querybuilder::syntax::query_kind::QueryKind;
 
 pub struct DeleteAst {}
 
-impl AstProcessor for DeleteAst {}
-impl<'a> ToSql<'a> 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 AstProcessor for DeleteAst {
+    fn query_kind(&self) -> QueryKind {
+        QueryKind::Delete
     }
 }
 
@@ -33,18 +21,3 @@ impl DeleteAst {
     }
 }
 
-impl<'a> AsEmitKind<'a> for DeleteAst {
-    fn as_emit_kind(&self) -> Option<&dyn EmitKind<'a>> {
-        Some(self as &dyn EmitKind<'a>)
-    }
-}
-impl<'a> AsEmitFrom<'a> for DeleteAst {
-    fn as_emit_from(&self) -> Option<&dyn EmitFrom<'a>> {
-        Some(self as &dyn EmitFrom<'a>)
-    }
-}
-impl<'a> AsEmitBody<'a> for DeleteAst {
-    fn as_emit_body(&self) -> Option<&dyn EmitBody<'a>> {
-        None
-    }
-}

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

@@ -1,48 +1,16 @@
 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::Symbol::{LParen, RParen};
-use crate::query::querybuilder::syntax::tokens::{SqlToken, Symbol, ToSqlTokens};
-use std::borrow::Cow;
+use crate::query::querybuilder::syntax::column::ColumnRef;
+use crate::query::querybuilder::syntax::emitter::AstProcessor;
+use crate::query::querybuilder::syntax::query_kind::QueryKind;
 
+#[derive(Default)]
 pub struct InsertAst<'a> {
-    pub columns: Vec<&'a str>,
+    pub columns: Vec<ColumnRef<'a>>,
     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> AstProcessor for InsertAst<'a> {
+    fn query_kind(&self) -> QueryKind { QueryKind::Insert }
 }
 
 impl<'a> InsertAst<'a> {

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

@@ -1,14 +1,9 @@
 use crate::query::querybuilder::syntax::column::ColumnRef;
-use crate::query::querybuilder::syntax::emitter::{
-    AsEmitBody, AsEmitFrom, AsEmitKind, AstProcessor, EmitBody, EmitFrom, EmitKind, ToSql,
-};
+use crate::query::querybuilder::syntax::emitter::AstProcessor;
 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, ToSqlTokens};
-use std::borrow::Cow;
+use crate::query::querybuilder::syntax::query_kind::QueryKind;
 
 #[derive(Default)]
 pub struct SelectAst<'a> {
@@ -35,61 +30,8 @@ impl<'a> SelectAst<'a> {
     }
 }
 
-impl<'a> ToSql<'a> for SelectAst<'a> {}
-
-impl<'a> AstProcessor for SelectAst<'a> {}
-
-impl<'a> EmitKind<'a> for SelectAst<'a> {
-    fn emit_kind(&self, out: &mut Vec<SqlToken<'a>>) {
-        out.push(SqlToken::Keyword(Cow::Borrowed("SELECT")));
-    }
-}
-
-impl<'a> EmitFrom<'a> for SelectAst<'a> {
-    fn emit_from(&self, meta: &TableMetadata<'a>, out: &mut Vec<SqlToken<'a>>) {
-        // columns
-        if self.columns.is_empty() {
-            out.push(SqlToken::Symbol(Symbol::Asterisk));
-        } else {
-            for (i, col) in self.columns.iter().enumerate() {
-                if i > 0 {
-                    out.push(SqlToken::Symbol(Symbol::Comma));
-                }
-                col.to_tokens(out);
-            }
-        }
-        // FROM
-        out.push(SqlToken::new_keyword("FROM"));
-        meta.to_tokens(out);
-    }
-}
-impl<'a> EmitBody<'a> for SelectAst<'a> {
-    fn emit_body(&self, out: &mut Vec<SqlToken<'a>>) {
-        for j in &self.joins {
-            j.to_tokens(out)
-        }
-        for c in &self._inner.conditions {
-            c.accept(self);
-        }
-    }
-}
-
-// tell the system that SelectAst supports these phases:
-impl<'a> AsEmitKind<'a> for SelectAst<'a> {
-    fn as_emit_kind(&self) -> Option<&dyn EmitKind<'a>> {
-        Some(self as &dyn EmitKind<'a>)
-    }
-}
-impl<'a> AsEmitFrom<'a> for SelectAst<'a> {
-    fn as_emit_from(&self) -> Option<&dyn EmitFrom<'a>> {
-        Some(self as &dyn EmitFrom<'a>)
-    }
-}
-impl<'a> AsEmitBody<'a> for SelectAst<'a> {
-    fn as_emit_body(&self) -> Option<&dyn EmitBody<'a>> {
-        Some(self as &dyn EmitBody<'a>)
+impl<'a> AstProcessor for SelectAst<'a> {
+    fn query_kind(&self) -> QueryKind {
+        QueryKind::Select
     }
 }
-// impl<'a> AsEmitConditions<'a> for SelectAst<'a> {
-//     fn as_emit_conditions(&self) -> Option<&dyn EmitConditions<'a>> { Some(self as &dyn EmitConditions<'a>) }
-// }

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

@@ -1,34 +1,15 @@
 use crate::query::querybuilder::syntax::column::ColumnRef;
-use crate::query::querybuilder::syntax::emitter::{
-    AsEmitBody, AsEmitFrom, AsEmitKind, AstProcessor, EmitBody, EmitFrom, EmitKind, ToSql,
-};
-use crate::query::querybuilder::syntax::tokens::SqlToken;
+use crate::query::querybuilder::syntax::emitter::AstProcessor;
+use crate::query::querybuilder::syntax::query_kind::QueryKind;
 
 pub struct UpdateAst<'a> {
     pub columns: Vec<ColumnRef<'a>>,
 }
 
-impl<'a> AstProcessor for UpdateAst<'a> {}
-impl<'a> ToSql<'a> 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> AstProcessor for UpdateAst<'a> {
+    fn query_kind(&self) -> QueryKind { QueryKind::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 {
@@ -43,19 +24,3 @@ impl<'a> UpdateAst<'a> {
         }
     }
 }
-
-impl<'a> AsEmitKind<'a> for UpdateAst<'a> {
-    fn as_emit_kind(&self) -> Option<&dyn EmitKind<'a>> {
-        Some(self as &dyn EmitKind<'a>)
-    }
-}
-impl<'a> AsEmitFrom<'a> for UpdateAst<'a> {
-    fn as_emit_from(&self) -> Option<&dyn EmitFrom<'a>> {
-        None
-    }
-}
-impl<'a> AsEmitBody<'a> for UpdateAst<'a> {
-    fn as_emit_body(&self) -> Option<&dyn EmitBody<'a>> {
-        Some(self as &dyn EmitBody<'a>)
-    }
-}

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

@@ -1,7 +1,6 @@
 use crate::query::operators::Comp;
 use crate::query::querybuilder::syntax::column::ColumnRef;
-use crate::query::querybuilder::syntax::tokens::SqlToken::{Operator, Placeholder};
-use crate::query::querybuilder::syntax::tokens::{PlaceholderKind, SqlToken, ToSqlTokens};
+use crate::query::querybuilder::syntax::tokens::{PlaceholderKind, SqlTokens, ToSqlTokens};
 
 #[derive(Clone)]
 pub struct ConditionClause<'a> {
@@ -30,21 +29,21 @@ impl ConditionClauseKind {
 }
 
 impl<'a> ToSqlTokens<'a> for ConditionClause<'a> {
-    fn to_tokens(&self, out: &mut Vec<SqlToken<'a>>) {
+    fn to_tokens(&self, out: &mut SqlTokens<'a>) {
 
         // Clause keyword
-        out.push(SqlToken::new_keyword(self.kind.as_str()));
+        out.ident(self.kind.as_str()); // NOTE: dubious
 
         // Column
         self.column_name.to_tokens(out);
 
         // Operator
-        out.push(Operator(self.operator));
+        out.operator(self.operator);
 
         // Value placeholder
-        out.push(Placeholder(match self.operator {
+        out.placeholder(match self.operator {
             Comp::Like(kind) => PlaceholderKind::Like(kind, self.value_index),
             _ => PlaceholderKind::Value(self.value_index)
-        }));
+        });
     }
 }

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

@@ -1,6 +1,8 @@
+use std::borrow::Cow;
 use crate::query::bounds::FieldIdentifier;
+use crate::query::querybuilder::syntax::keyword::Keyword;
 use crate::query::querybuilder::syntax::symbol::Symbol::Dot;
-use crate::query::querybuilder::syntax::tokens::{SqlToken, ToSqlTokens};
+use crate::query::querybuilder::syntax::tokens::{SqlToken, SqlTokens, ToSqlTokens};
 
 #[derive(Debug, Clone, Default)]
 pub struct ColumnRef<'a> {
@@ -25,17 +27,17 @@ impl<'a> From<&'a str> for ColumnRef<'a> {
 }
 
 impl<'a> ToSqlTokens<'a> for ColumnRef<'a> {
-    fn to_tokens(&self, out: &mut Vec<SqlToken<'a>>) {
+    fn to_tokens(&self, out: &mut SqlTokens<'a>) {
         if let Some(table_ref) = self.table {
-            out.push(SqlToken::new_ident(table_ref));
-            out.push(SqlToken::Symbol(Dot))
+            out.ident(table_ref);
+            out.symbol(Dot)
         }
 
-        out.push(SqlToken::new_ident(self.column));
+        out.ident(self.column);
 
         if let Some(alias) = self.alias {
-            out.push(SqlToken::new_keyword("AS"));
-            out.push(SqlToken::new_ident(alias));
+            out.keyword(Keyword::As);
+            out.ident(alias);
         }
     }
 }
@@ -70,7 +72,7 @@ impl<'a> ColumnRef<'a> {
 mod __impl {
     use crate::query::querybuilder::syntax::column::{__detail, ColumnRef};
 
-    pub(crate) fn column_ref_from_str_ref(value: &'_ str) -> ColumnRef<'_> {
+    pub(crate) fn column_ref_from_str_ref(value: &str) -> ColumnRef {
         let trimmed = value.trim();
 
         let (before_alias, alias) = match __detail::find_case_insensitive_as(trimmed) {

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

@@ -0,0 +1,22 @@
+
+/// Governs syntax rules such as placeholder format,
+/// quoting style, and supported clauses.
+/// For example, PostgreSQL may allow `RETURNING`, while MySQL does not.
+pub trait SqlDialect {
+    const SUPPORTS_RETURNING: bool = true;
+    const SUPPORTS_LIMIT_OFFSET: bool = true;
+    // const IDENT_QUOTING: IdentQuoting;
+}
+
+#[cfg(feature = "postgres")]
+pub struct PgDialect;
+#[cfg(feature = "postgres")] impl SqlDialect for PgDialect {}
+
+#[cfg(feature = "mssql")]
+pub struct MsSql;
+#[cfg(feature = "mssql")] impl SqlDialect for MsSql {
+    const SUPPORTS_RETURNING: bool = false;
+}
+#[cfg(feature = "mysql")]
+pub struct MySql;
+#[cfg(feature = "mysql")] impl SqlDialect for MySql {}