refactor(WIP)!: querybuilder whitespaces();

Author: TheRustifyer

canyon_core/src/connection/datasources.rs

@@ -123,6 +123,7 @@ impl DatasourceConfig {
 
     pub fn has_migrations_enabled(&self) -> bool {
         if let Some(migrations) = self.properties.migrations {
+            // Option<Migrations>
             migrations.has_migrations_enabled()
         } else {
             false

canyon_core/src/connection/mod.rs

@@ -60,7 +60,6 @@ use crate::query::parameters::QueryParameter;
 use crate::rows::{CanyonRows, FromSqlOwnedValue};
 
 // Apply the macro to implement DbConnection for &str and str
-use crate::impl_db_connection_for_str;
 impl_db_connection_for_str!(str);
 impl_db_connection_for_str!(&str);
 

canyon_core/src/query/bounds.rs

@@ -1,4 +1,5 @@
 use crate::query::parameters::QueryParameter;
+use crate::query::querybuilder::syntax::column::ColumnRef;
 use crate::rows::FromSqlOwnedValue;
 
 /// Contract that provides a way to Canyon to inspect certain property or values at runtime.
@@ -66,11 +67,7 @@ pub trait TableMetadata<'a>: std::fmt::Display {
 pub trait FieldIdentifier: std::fmt::Display {
     fn as_str(&self) -> &'static str;
 
-    /// Returns a formatted string as `{<table_name>.<column_name>}`.
-    ///
-    /// This is useful during queries generations for example, in join statements, when you
-    /// alias other defined names, etc.
-    fn table_and_column_name(&self) -> String;
+    fn as_column_ref(&self) -> ColumnRef<'static>;
 }
 
 /// Represents some kind of introspection to make the implementors

canyon_core/src/query/mod.rs

@@ -5,3 +5,6 @@ pub mod bounds;
 pub mod operators;
 pub mod parameters;
 pub mod querybuilder;
+
+// Re-exports
+pub use crate::query::querybuilder::syntax::column::ColumnRef;

canyon_core/src/query/operators.rs

@@ -7,7 +7,7 @@ use std::fmt::Display;
 
 /// Enumerated type for represent the comparison operations
 /// in SQL sentences
-#[derive(Debug, PartialEq, Copy, Clone)]
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub enum Comp {
     /// Operator "=" equals
     Eq,
@@ -40,7 +40,7 @@ impl Display for Comp {
     }
 }
 
-impl<'a> ToSqlTokens<'a> for Comp {
+impl<'a, D: SqlDialect> ToSqlTokens<'a, D> for Comp {
     fn to_tokens(&self) -> impl IntoIterator<Item = SqlToken<'a>> + 'a {
         let mut out = SqlTokens::with_capacity(2);
 
@@ -67,7 +67,7 @@ impl<'a> ToSqlTokens<'a> for Comp {
     }
 }
 
-#[derive(Debug, PartialEq, Copy, Clone)]
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub enum LikeKind {
     /// Operator "LIKE"  as '%pattern%'
     Full,

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

@@ -141,19 +141,6 @@ pub trait SelectQueryBuilderOps<'a>: QueryBuilderOps<'a> {
 /// without mixing types or polluting everything into
 /// just one type.
 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);
-
     /// Generates a `WHERE` SQL clause for constraint the query.
     ///
     /// * `column` - An [`&str`] that will provide the target column name

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

@@ -1,7 +1,6 @@
-use crate::query::parameters::QueryParameter;
-use crate::query::querybuilder::syntax::column::ColumnRef;
-use crate::query::querybuilder::syntax::emitter::AstProcessor;
-use crate::query::querybuilder::syntax::query_kind::QueryKind;
+pub(crate) use crate::query::querybuilder::syntax::{
+    column::ColumnRef, emitter::AstProcessor, query_kind::QueryKind,
+};
 use transient::Transient;
 
 #[derive(Default, Transient)]
@@ -17,7 +16,7 @@ impl<'a> AstProcessor<'a> for InsertAst<'a> {
 }
 
 impl<'a> InsertAst<'a> {
-    pub const fn new() -> Self {
+    pub const fn _new() -> Self {
         Self {
             columns: Vec::new(),
             returning_columns: Vec::new(),

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

@@ -1,5 +1,6 @@
 use crate::query::operators::Comp;
 use crate::query::querybuilder::syntax::column::ColumnRef;
+use crate::query::querybuilder::syntax::dialect::SqlDialect;
 use crate::query::querybuilder::syntax::keyword::Keyword;
 use crate::query::querybuilder::syntax::tokens::{
     PlaceholderKind, SqlToken, SqlTokens, ToSqlTokens,
@@ -31,19 +32,25 @@ impl From<ConditionClauseKind> for Keyword {
     }
 }
 
-impl<'a> ToSqlTokens<'a> for ConditionClause<'a> {
+impl<'a, D: SqlDialect> ToSqlTokens<'a, D> for ConditionClause<'a> {
     fn to_tokens(&self) -> impl IntoIterator<Item = SqlToken<'a>> + 'a {
         let mut out = SqlTokens::with_capacity(4);
 
         // Clause keyword
         out.keyword(self.kind.into());
 
         // Column
-        out.extend(self.column_name.to_tokens());
+        out.extend(<ColumnRef<'_> as ToSqlTokens<'_, D>>::to_tokens(
+            &self.column_name,
+        ));
+
+        out.whitespace();
 
         // Operator
         out.operator(self.operator);
 
+        out.whitespace();
+
         // Value placeholder
         out.placeholder(match self.operator {
             Comp::Like(kind) => PlaceholderKind::Like(kind, self.value_index),

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

@@ -1,4 +1,5 @@
 use crate::query::bounds::FieldIdentifier;
+use crate::query::querybuilder::syntax::dialect::SqlDialect;
 use crate::query::querybuilder::syntax::tokens::{SqlToken, SqlTokens, ToSqlTokens};
 
 #[derive(Debug, Clone, Default)]
@@ -10,10 +11,10 @@ pub struct ColumnRef<'a> {
 
 impl<'a, T> From<T> for ColumnRef<'a>
 where
-    T: FieldIdentifier,
+    T: FieldIdentifier + 'a,
 {
     fn from(value: T) -> Self {
-        Self::from(value.as_str())
+        value.as_column_ref()
     }
 }
 
@@ -23,10 +24,10 @@ impl<'a> From<&'a str> for ColumnRef<'a> {
     }
 }
 
-impl<'a> ToSqlTokens<'a> for ColumnRef<'a> {
+impl<'a, D: SqlDialect> ToSqlTokens<'a, D> for ColumnRef<'a> {
     fn to_tokens(&self) -> impl IntoIterator<Item = SqlToken<'a>> + 'a {
         let mut out = SqlTokens::with_capacity(__detail::calculate_column_ref_capacity(self));
-        __impl::generate_column_ref_tokens(self, &mut out);
+        __impl::generate_column_ref_tokens::<D>(self, &mut out);
         out
     }
 }
@@ -60,6 +61,8 @@ impl<'a> ColumnRef<'a> {
 
 mod __impl {
     use crate::query::querybuilder::syntax::column::{__detail, ColumnRef};
+    use crate::query::querybuilder::syntax::dialect::SqlDialect;
+    use crate::query::querybuilder::syntax::emitter::types::helpers;
     use crate::query::querybuilder::syntax::keyword::Keyword;
     use crate::query::querybuilder::syntax::symbol::Symbol::Dot;
     use crate::query::querybuilder::syntax::tokens::SqlTokens;
@@ -88,17 +91,20 @@ mod __impl {
         }
     }
 
-    pub(crate) fn generate_column_ref_tokens<'a>(__self: &ColumnRef<'a>, out: &mut SqlTokens<'a>) {
+    pub(crate) fn generate_column_ref_tokens<'a, D: SqlDialect>(
+        __self: &ColumnRef<'a>,
+        out: &mut SqlTokens<'a>,
+    ) {
         if let Some(table_ref) = __self.table {
-            out.ident(table_ref);
+            helpers::push_quoted_ident::<D>(table_ref, out);
             out.symbol(Dot)
         }
 
-        out.ident(__self.column);
+        helpers::push_quoted_ident::<D>(__self.column, out);
 
         if let Some(alias) = __self.alias {
             out.keyword(Keyword::As);
-            out.ident(alias);
+            helpers::push_quoted_ident::<D>(alias, out);
         }
     }
 }

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

@@ -12,13 +12,14 @@ pub trait SqlDialect {
     const DB: DatabaseType;
     const SUPPORTS_RETURNING: bool = true;
     const _SUPPORTS_LIMIT_OFFSET: bool = true;
-    const IDENT_QUOTING: IdentQuoting = IdentQuoting::DoubleQuote;
+    const IDENT_QUOTING: IdentQuotingStyle = IdentQuotingStyle::DoubleQuote;
     const PLACEHOLDER_SYMBOL: PlaceholderSymbol = PlaceholderSymbol::DollarNumbered;
-    const PLACEHOLDER_DATA_TYPE: PlaceholderDatatype = PlaceholderDatatype::VARCHAR;
+    const PLACEHOLDER_DATA_TYPE: PlaceholderDatatype = PlaceholderDatatype::Varchar;
 }
 
 /// Safe assuming that Canyon's default is PostgreSQL,
 /// which is the most widely used and standards-compliant database among the supported ones.
+#[allow(dead_code)]
 pub struct StandardDialect;
 impl SqlDialect for StandardDialect {
     const DB: DatabaseType = PostgreSql;
@@ -29,7 +30,7 @@ pub struct PgDialect;
 #[cfg(feature = "postgres")]
 impl SqlDialect for PgDialect {
     const DB: DatabaseType = PostgreSql;
-    const IDENT_QUOTING: IdentQuoting = IdentQuoting::DoubleQuote;
+    const IDENT_QUOTING: IdentQuotingStyle = IdentQuotingStyle::DoubleQuote;
     const PLACEHOLDER_SYMBOL: PlaceholderSymbol = PlaceholderSymbol::DollarNumbered;
 }
 
@@ -39,7 +40,7 @@ pub struct MsSql;
 impl SqlDialect for MsSql {
     const DB: DatabaseType = SqlServer;
     const SUPPORTS_RETURNING: bool = false;
-    const IDENT_QUOTING: IdentQuoting = IdentQuoting::Bracket;
+    const IDENT_QUOTING: IdentQuotingStyle = IdentQuotingStyle::Bracket;
     const PLACEHOLDER_SYMBOL: PlaceholderSymbol = PlaceholderSymbol::AtPNumbered;
 }
 
@@ -48,9 +49,9 @@ pub struct MySql;
 #[cfg(feature = "mysql")]
 impl SqlDialect for MySql {
     const DB: DatabaseType = MySQL;
-    const IDENT_QUOTING: IdentQuoting = IdentQuoting::Backtick;
+    const IDENT_QUOTING: IdentQuotingStyle = IdentQuotingStyle::Backtick;
     const PLACEHOLDER_SYMBOL: PlaceholderSymbol = PlaceholderSymbol::QuestionMark;
-    const PLACEHOLDER_DATA_TYPE: PlaceholderDatatype = PlaceholderDatatype::CHAR;
+    const PLACEHOLDER_DATA_TYPE: PlaceholderDatatype = PlaceholderDatatype::Char;
 }
 
 /// Identifier quoting strategy for a SQL dialect.
@@ -65,7 +66,7 @@ impl SqlDialect for MySql {
 /// - MySQL: `` `ident` ``
 /// - SQL Server: `[ident]`
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum IdentQuoting {
+pub enum IdentQuotingStyle {
     /// ANSI SQL style, used by PostgreSQL and as the generic default.
     DoubleQuote,
     /// MySQL style.
@@ -74,23 +75,43 @@ pub enum IdentQuoting {
     Bracket,
 }
 
-impl IdentQuoting {
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum IdentQuoting {
+    DoubleQuote,
+    Backtick,
+    OpeningBracket,
+    ClosingBracket,
+}
+
+impl IdentQuotingStyle {
     #[inline]
-    pub const fn opening(self) -> &'static str {
+    pub const fn opening(self) -> IdentQuoting {
         match self {
-            Self::DoubleQuote => "\"",
-            Self::Backtick => "`",
-            Self::Bracket => "[",
+            Self::DoubleQuote => IdentQuoting::DoubleQuote,
+            Self::Backtick => IdentQuoting::Backtick,
+            Self::Bracket => IdentQuoting::OpeningBracket,
         }
     }
 
     #[inline]
-    pub const fn closing(self) -> &'static str {
+    pub const fn closing(self) -> IdentQuoting {
         match self {
+            Self::DoubleQuote => IdentQuoting::DoubleQuote,
+            Self::Backtick => IdentQuoting::Backtick,
+            Self::Bracket => IdentQuoting::ClosingBracket,
+        }
+    }
+}
+
+impl Display for IdentQuoting {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let t = match self {
             Self::DoubleQuote => "\"",
             Self::Backtick => "`",
-            Self::Bracket => "]",
-        }
+            Self::OpeningBracket => "[",
+            Self::ClosingBracket => "]",
+        };
+        write!(f, "{}", t)
     }
 }
 
@@ -104,7 +125,7 @@ pub enum PlaceholderSymbol {
     /// @p1, @p2, @p3
     AtPNumbered,
     /// :1, :2, :3
-    ColonNumbered,
+    _ColonNumbered,
 }
 
 impl Display for PlaceholderSymbol {
@@ -113,7 +134,7 @@ impl Display for PlaceholderSymbol {
             Self::QuestionMark => "?",
             Self::DollarNumbered => "$",
             Self::AtPNumbered => "@P",
-            Self::ColonNumbered => ":",
+            Self::_ColonNumbered => ":",
         };
         write!(f, "{}", symbol)
     }
@@ -122,15 +143,15 @@ impl Display for PlaceholderSymbol {
 /// Represents the syntax style for parameter placeholders in prepared statements.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum PlaceholderDatatype {
-    VARCHAR,
-    CHAR,
+    Varchar,
+    Char,
 }
 
 impl Display for PlaceholderDatatype {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let datatype = match self {
-            Self::VARCHAR => "VARCHAR",
-            Self::CHAR => "CHAR",
+            Self::Varchar => "VARCHAR",
+            Self::Char => "CHAR",
         };
         write!(f, "{}", datatype)
     }