refactor(WIP)!: emit_columns shared logic. New helpers mod for the shared emission impl details

Author: TheRustifyer

canyon_core/src/connection/database_type.rs

@@ -71,7 +71,7 @@ pub enum DatabaseType {
     /// .build()?; // resolved dynamically to the active database type
     /// ```
     #[default]
-    Deferred,
+    Deferred, // TODO: review if this is yet viable
 }
 
 impl Display for DatabaseType {

canyon_core/src/query/querybuilder/syntax/emitter/backends/mysql.rs

@@ -9,8 +9,4 @@ pub struct MySqlEmitter<'a> {
 
 impl<'a> SqlEmitter<'a> for MySqlEmitter<'a> {
     type Dialect = MySql;
-
-    fn tokens(&mut self) -> &mut SqlTokens<'a> {
-        &mut self.tokens
-    }
 }

canyon_core/src/query/querybuilder/syntax/emitter/backends/pg.rs

@@ -1,8 +1,5 @@
-use crate::query::querybuilder::syntax::ast::BaseAst;
 use crate::query::querybuilder::syntax::dialect::PgDialect;
-use crate::query::querybuilder::syntax::emitter::types::select::EmitSelect;
 use crate::query::querybuilder::syntax::emitter::{AstProcessor, SqlEmitter};
-use crate::query::querybuilder::syntax::query_kind::QueryKind;
 use crate::query::querybuilder::syntax::tokens::SqlTokens;
 
 #[derive(Default)]
@@ -14,8 +11,4 @@ pub struct PgEmitter<'a> {
 // implementation is based on the postgres one, that's why postgres doesn't override it
 impl<'a> SqlEmitter<'a> for PgEmitter<'a> {
     type Dialect = PgDialect;
-
-    fn tokens(&mut self) -> &mut SqlTokens<'a> {
-        &mut self.tokens
-    }
 }

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

@@ -83,15 +83,6 @@ where
     /// system.
     type Dialect: SqlDialect;
 
-    /// Mutable access to the internal SQL token buffer.
-    ///
-    /// SQL emission produces a sequence of tokens such as keywords,
-    /// symbols, identifiers, and parameter placeholders. Emitters write
-    /// these tokens into the buffer during `emit`. After emission is
-    /// complete, the buffer can be passed to a renderer to produce
-    /// a final SQL string.
-    fn tokens(&mut self) -> &mut SqlTokens<'a>;
-
     /// Emit SQL tokens for the given AST node and table metadata.
     ///
     /// This method is the central entry point for query emission.
@@ -116,28 +107,28 @@ where
     /// emission writes: `SELECT ... FROM ... WHERE ...`. A backend
     /// emitter may choose to include or omit certain clauses (e.g.,
     /// `RETURNING`) depending on dialect support.
-    fn emit(&mut self, ast: &impl AstProcessor<'a>, base_ast: &BaseAst<'a>)
+    fn emit(&mut self, ast: &impl AstProcessor<'a>, base_ast: &BaseAst<'a>) -> SqlTokens<'a>
     where
         Self: Sized,
     {
         // Default implementation delegates:
         match ast.query_kind() {
             QueryKind::Select => self.emit_select(ast, base_ast),
-            QueryKind::Insert => {}
-            QueryKind::Update => {}
-            QueryKind::Delete => {}
+            QueryKind::Insert => self.emit_select(ast, base_ast),
+            QueryKind::Update => self.emit_select(ast, base_ast),
+            QueryKind::Delete => self.emit_select(ast, base_ast),
         }
     } // TODO: should emit as the outer wrapper really return the emitter internal buffer?
 }
 
 pub trait EmitInsert<'a>: SqlEmitter<'a> {
-    fn emit_insert(&mut self, ast: &'a InsertAst<'a>, meta: &TableMetadata<'a>);
+    fn emit_insert(&mut self, ast: &'a InsertAst<'a>, meta: &TableMetadata<'a>) -> SqlTokens<'a>;
 }
 
 pub trait EmitUpdate<'a>: SqlEmitter<'a> {
-    fn emit_update(&mut self, ast: &'a UpdateAst<'a>, meta: &TableMetadata<'a>);
+    fn emit_update(&mut self, ast: &'a UpdateAst<'a>, meta: &TableMetadata<'a>) -> SqlTokens<'a>;
 }
 
 pub trait EmitDelete<'a>: SqlEmitter<'a> {
-    fn emit_delete(&mut self, ast: &'a DeleteAst, meta: &TableMetadata<'a>);
+    fn emit_delete(&mut self, ast: &'a DeleteAst, meta: &TableMetadata<'a>) -> SqlTokens<'a>;
 }

canyon_core/src/query/querybuilder/syntax/emitter/types/helpers.rs

@@ -0,0 +1,14 @@
+//! Standalone functions that shares the same behaviour for different AST kinds
+
+use crate::query::querybuilder::syntax::column::ColumnRef;
+use crate::query::querybuilder::syntax::symbol::Symbol::Comma;
+use crate::query::querybuilder::syntax::tokens::{SqlTokens, ToSqlTokens};
+
+pub(crate) fn emit_columns<'a>(columns: &Vec<ColumnRef<'a>>, tokens: &mut SqlTokens<'a>) {
+    for (i, column) in columns.iter().enumerate() {
+        if i > 0 {
+            tokens.symbol(Comma);
+        }
+        column.to_tokens(tokens); // TODO: change opt-out-in
+    }
+}

canyon_core/src/query/querybuilder/syntax/emitter/types/insert.rs

@@ -1,23 +1,19 @@
 use crate::query::querybuilder::syntax::ast::insert::InsertAst;
 use crate::query::querybuilder::syntax::dialect::SqlDialect;
 use crate::query::querybuilder::syntax::emitter::SqlEmitter;
+use crate::query::querybuilder::syntax::emitter::types::helpers;
 use crate::query::querybuilder::syntax::keyword::Keyword;
-use crate::query::querybuilder::syntax::symbol::Symbol::Comma;
-use crate::query::querybuilder::syntax::tokens::ToSqlTokens;
+use crate::query::querybuilder::syntax::tokens::SqlTokens;
 
-pub(crate) fn emit_returning<'a, E: SqlEmitter<'a>>(emitter: &mut E, ast: &InsertAst<'a>) {
+pub(crate) fn emit_returning<'a, E: SqlEmitter<'a>>(
+    ast: &InsertAst<'a>,
+    tokens: &mut SqlTokens<'a>,
+) {
     if !E::Dialect::SUPPORTS_RETURNING {
         return; // early guarding
     }
     // TODO: actual impl, not the one below, is should have a RETURNING COLS on the INSERT implementation
-    let tokens_holder = emitter.tokens();
-    tokens_holder.keyword(Keyword::Returning);
-
-    for (i, column) in ast.columns.iter().enumerate() {
-        // TODO:: this is duplicated
-        if i > 0 {
-            tokens_holder.symbol(Comma);
-        }
-        column.to_tokens(tokens_holder); // TODO: strange
-    }
+    tokens.keyword(Keyword::Returning);
+    // add the columns
+    helpers::emit_columns(&ast.columns, tokens)
 }

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

@@ -1,4 +1,5 @@
 pub(crate) mod delete;
+mod helpers;
 pub(crate) mod insert;
 pub(crate) mod select;
 pub(crate) mod update;

canyon_core/src/query/querybuilder/syntax/emitter/types/select.rs

@@ -1,41 +1,46 @@
-use crate::query::querybuilder::syntax::ast::BaseAst;
 use crate::query::querybuilder::syntax::ast::select::SelectAst;
+use crate::query::querybuilder::syntax::ast::BaseAst;
+use crate::query::querybuilder::syntax::emitter::types::helpers;
 use crate::query::querybuilder::syntax::emitter::{AstProcessor, SqlEmitter};
 use crate::query::querybuilder::syntax::keyword::Keyword;
-use crate::query::querybuilder::syntax::symbol::Symbol::Comma;
-use crate::query::querybuilder::syntax::tokens::{SqlTokens, ToSqlTokens};
+use crate::query::querybuilder::syntax::tokens::SqlTokens;
 
 /// Blanket implementation for all the SqlEmitter implementors that are able to generate
 /// SELECT like SQL clauses
 impl<'a, T> EmitSelect<'a> for T
 where
     T: SqlEmitter<'a>,
 {
-    fn emit_select(&mut self, ast: &impl AstProcessor<'a>, base_ast: &BaseAst<'a>) {
-        let select_ast = transient::Downcast::downcast_ref::<SelectAst>(ast.as_any()).expect("Handle this");
-        self.tokens().keyword(Keyword::Select);
+    fn emit_select(
+        &mut self,
+        ast: &impl AstProcessor<'a>,
+        base_ast: &BaseAst<'a>,
+    ) -> SqlTokens<'a> {
+        let mut tokens = SqlTokens::default();
+
+        let select_ast =
+            transient::Downcast::downcast_ref::<SelectAst>(ast.as_any()).expect("Handle this");
 
-        emit_columns(self, select_ast);
-        emit_from(self, base_ast);
+        tokens.keyword(Keyword::Select);
+
+        emit_columns(select_ast, &mut tokens);
+        emit_from(base_ast, &mut tokens);
+
+        tokens
     }
 }
 
 /// DOC me this
 pub trait EmitSelect<'a>: SqlEmitter<'a> {
-    fn emit_select(&mut self, ast: &impl AstProcessor<'a>, base_ast: &BaseAst<'a>);
+    fn emit_select(&mut self, ast: &impl AstProcessor<'a>, base_ast: &BaseAst<'a>)
+    -> SqlTokens<'a>;
 }
 
-pub(crate) fn emit_columns<'a>(emitter: &mut impl SqlEmitter<'a>, ast: &SelectAst<'a>) {
-    let tokens = emitter.tokens();
-    for (i, column) in ast.columns.iter().enumerate() {
-        if i > 0 {
-            tokens.symbol(Comma);
-        }
-        column.to_tokens(tokens);
-    }
+pub(crate) fn emit_columns<'a>(ast: &SelectAst<'a>, tokens: &mut SqlTokens<'a>) {
+    helpers::emit_columns(&ast.columns, tokens)
 }
 
-pub(crate) fn emit_from<'a>(emitter: &mut impl SqlEmitter<'a>, base_ast: &BaseAst<'a>) {
+pub(crate) fn emit_from<'a>(base_ast: &BaseAst<'a>, tokens: &mut SqlTokens<'a>) {
     //meta.to_tokens(emitter.tokens())
     todo!()
 }

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

@@ -48,7 +48,7 @@ impl<'a, P: AstProcessor<'a> + 'a> QueryBuilder<'a, P> {
     }
 
     fn sql<'b>(&self) -> Result<String, Box<dyn Error + Send + Sync + 'b>> {
-        // __impl::check_invariants_over_condition_clauses(self)?;
+        __impl::check_invariants_over_condition_clauses(self)?;
 
         let mut tokens = SqlTokens::default();
 
@@ -167,7 +167,7 @@ mod __impl {
     /// Quick standalone that acts as a façade for an orchestrator that just organizes a procedural way of testing
     /// that the constructed underlying query is syntactically correct
     pub(crate) fn check_invariants_over_condition_clauses<'a, 'b, P: AstProcessor<'a>>(
-        _self: &'a QueryBuilder<'a, P>,
+        _self: &QueryBuilder<'a, P>,
     ) -> Result<(), Box<dyn Error + Send + Sync + 'b>> {
         __validators::check_where_clause_position(_self)
     }
@@ -231,7 +231,6 @@ mod __detail {
     ) where
         P: AstProcessor<'a>,
     {
-        let qk = ast.query_kind();
         match database_type {
             DatabaseType::PostgreSql => {
                 let mut emitter = PgEmitter::default();