chore: cargo fmt

Author: TheRustifyer

canyon_core/src/connection/database_type.rs

@@ -70,7 +70,8 @@ pub enum DatabaseType {
     /// .where_("id", Comp::Eq, &42)
     /// .build()?; // resolved dynamically to the active database type
     /// ```
-    #[default] Deferred,
+    #[default]
+    Deferred,
 }
 
 impl Display for DatabaseType {

canyon_core/src/query/operators.rs

@@ -22,10 +22,9 @@ pub enum Comp {
     /// Operator "=<" less or equals than value
     LtEq,
     /// A "LIKE" comp operator
-    Like(LikeKind)
+    Like(LikeKind),
 }
 
-
 impl Display for Comp {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let op = match *self {
@@ -35,7 +34,7 @@ impl Display for Comp {
             Self::GtEq => ">=",
             Self::Lt => "<",
             Self::LtEq => "<=",
-            Self::Like(ref __kind) => "LIKE"
+            Self::Like(ref __kind) => "LIKE",
         };
         write!(f, "{}", op)
     }

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

@@ -1,31 +1,38 @@
 //! Contains the elements that makes part of the formal declaration
 //! of the behaviour of the Canyon-SQL QueryBuilder
 
-use std::error::Error;
 use crate::query::bounds::{FieldIdentifier, FieldValueIdentifier};
 use crate::query::operators::Comp;
 use crate::query::parameters::QueryParameter;
 use crate::query::querybuilder::syntax::column::ColumnRef;
 use crate::query::querybuilder::syntax::table_metadata::TableMetadata;
+use std::error::Error;
 
 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.
-    /// 
+    ///
     /// 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;
+    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
     /// internal values collection of the [`crate::query::querybuilder::QueryBuilder`]
-    fn set_values<Z, Q>(self, columns: &'a [(Z, Q)]) -> Result<Self, Box<dyn Error + Send + Sync + 'a>>
+    fn set_values<Z, Q>(
+        self,
+        columns: &'a [(Z, Q)],
+    ) -> Result<Self, Box<dyn Error + Send + Sync + 'a>>
     where
         Z: FieldIdentifier,
         Q: QueryParameter,
@@ -36,7 +43,7 @@ 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<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:
     ///
@@ -181,7 +188,11 @@ pub trait QueryBuilderOps<'a> {
     ///   the field name that maps the targeted column name
     /// * `values` - An array of [`QueryParameter`] with the values to filter
     ///   inside the `IN` operator
-    fn and_values_in<'b, Z, Q>(self, column: Z, values: &'a [Q]) -> Result<Self, Box<dyn Error + Send + Sync + 'b>>
+    fn and_values_in<'b, Z, Q>(
+        self,
+        column: Z,
+        values: &'a [Q],
+    ) -> Result<Self, Box<dyn Error + Send + Sync + 'b>>
     where
         Z: FieldIdentifier,
         Q: QueryParameter,
@@ -195,7 +206,11 @@ pub trait QueryBuilderOps<'a> {
     ///   the field name that maps the targeted column name
     /// * `values` - An array of [`QueryParameter`] with the values to filter
     ///   inside the `IN` operator
-    fn or_values_in<'b, Z, Q>(self, r#or: Z, values: &'a [Q]) -> Result<Self, Box<dyn Error + Send + Sync + 'b>>
+    fn or_values_in<'b, Z, Q>(
+        self,
+        r#or: Z,
+        values: &'a [Q],
+    ) -> Result<Self, Box<dyn Error + Send + Sync + 'b>>
     where
         Z: FieldIdentifier,
         Q: QueryParameter,

canyon_core/src/query/querybuilder/mod.rs

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

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

@@ -1,4 +1,6 @@
-use crate::query::querybuilder::syntax::emitter::{AsEmitBody, AsEmitFrom, AsEmitKind, AstProcessor, EmitBody, EmitFrom, EmitKind, ToSql};
+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};
 
@@ -26,15 +28,23 @@ impl Default for DeleteAst {
 }
 
 impl DeleteAst {
-    pub fn new() -> Self { Self{} }
+    pub fn new() -> Self {
+        Self {}
+    }
 }
 
 impl<'a> AsEmitKind<'a> for DeleteAst {
-    fn as_emit_kind(&self) -> Option<&dyn EmitKind<'a>> { Some(self as &dyn EmitKind<'a>) }
+    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>) }
+    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 }
-}
+    fn as_emit_body(&self) -> Option<&dyn EmitBody<'a>> {
+        None
+    }
+}

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

@@ -1,9 +1,9 @@
-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::{LParen, RParen};
+use crate::query::querybuilder::syntax::tokens::{SqlToken, Symbol, ToSqlTokens};
+use std::borrow::Cow;
 
 pub struct InsertAst<'a> {
     pub columns: Vec<&'a str>,
@@ -17,13 +17,16 @@ impl<'a> EmitKind<'a> for InsertAst<'a> {
 }
 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
+        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)); }
+                if i > 0 {
+                    out.push(SqlToken::Symbol(Symbol::Comma));
+                }
                 //out.push(SqlToken::new_ident(c));
             }
             out.push(SqlToken::Symbol(Symbol::RParen));
@@ -44,6 +47,9 @@ impl<'a> EmitBody<'a> for InsertAst<'a> {
 
 impl<'a> InsertAst<'a> {
     pub fn new() -> Self {
-        Self { columns: Vec::new(), values: Vec::new() }
+        Self {
+            columns: Vec::new(),
+            values: Vec::new(),
+        }
     }
-}
+}

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

@@ -1,13 +1,14 @@
-pub(crate) mod select;
+pub(crate) mod delete;
 pub(crate) mod insert;
+pub(crate) mod select;
 pub(crate) mod update;
-pub(crate) mod delete;
 
 use crate::query::querybuilder::syntax::clause::ConditionClause;
 use crate::query::querybuilder::syntax::table_metadata::TableMetadata;
 
 /// Base AST for common parts
-#[derive(Default)] pub struct BaseAst<'a> {
+#[derive(Default)]
+pub struct BaseAst<'a> {
     pub table: TableMetadata<'a>,
     pub conditions: Vec<ConditionClause<'a>>,
 }
@@ -16,7 +17,7 @@ impl<'a> BaseAst<'a> {
     pub fn new(table: impl Into<TableMetadata<'a>>) -> Self {
         Self {
             table: table.into(),
-            conditions: Vec::new()
+            conditions: Vec::new(),
         }
     }
 }

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

@@ -1,12 +1,14 @@
-use std::borrow::Cow;
 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::{
+    AsEmitBody, AsEmitFrom, AsEmitKind, AstProcessor, EmitBody, EmitFrom, EmitKind, ToSql,
+};
 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;
 
 #[derive(Default)]
 pub struct SelectAst<'a> {
@@ -15,7 +17,7 @@ pub struct SelectAst<'a> {
     pub order_by: Option<OrderByClause<'a>>,
     pub having: Option<HavingClause<'a>>,
     pub group_by: Vec<ColumnRef<'a>>, // TODO: ColumnRef
-    pub limit: Option<u64>, // TODO: strong typing
+    pub limit: Option<u64>,           // TODO: strong typing
     pub offset: Option<u64>,
 }
 
@@ -44,7 +46,7 @@ impl<'a> EmitKind<'a> for SelectAst<'a> {
 }
 
 impl<'a> EmitFrom<'a> for SelectAst<'a> {
-    fn emit_from(&self, meta: &TableMetadata<'a>, out: &mut Vec<SqlToken<'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));
@@ -60,7 +62,6 @@ impl<'a> EmitFrom<'a> for SelectAst<'a> {
         // FROM
         out.push(SqlToken::new_keyword("FROM"));
         meta.to_tokens(out);
-
     }
 }
 impl<'a> EmitBody<'a> for SelectAst<'a> {
@@ -76,16 +77,21 @@ impl<'a> EmitBody<'a> for SelectAst<'a> {
     }
 }
 
-
 // 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>) }
+    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>) }
+    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>) }
+    fn as_emit_body(&self) -> Option<&dyn EmitBody<'a>> {
+        Some(self as &dyn EmitBody<'a>)
+    }
 }
 // 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,5 +1,7 @@
 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::{
+    AsEmitBody, AsEmitFrom, AsEmitKind, AstProcessor, EmitBody, EmitFrom, EmitKind, ToSql,
+};
 use crate::query::querybuilder::syntax::tokens::SqlToken;
 
 pub struct UpdateAst<'a> {
@@ -36,16 +38,24 @@ impl<'a> Default for UpdateAst<'a> {
 
 impl<'a> UpdateAst<'a> {
     pub fn new() -> Self {
-        Self { columns: Vec::new() }
+        Self {
+            columns: Vec::new(),
+        }
     }
 }
 
 impl<'a> AsEmitKind<'a> for UpdateAst<'a> {
-    fn as_emit_kind(&self) -> Option<&dyn EmitKind<'a>> { Some(self as &dyn EmitKind<'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 }
+    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>) }
-}
+    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,8 @@
 use crate::query::operators::Comp;
 use crate::query::querybuilder::syntax::column::ColumnRef;
 
-#[derive(Clone)] pub struct ConditionClause<'a> {
+#[derive(Clone)]
+pub struct ConditionClause<'a> {
     pub(crate) kind: ConditionClauseKind,
     pub(crate) column_name: ColumnRef<'a>,
     pub(crate) operator: Comp,
@@ -12,7 +13,7 @@ pub enum ConditionClauseKind {
     Where,
     And,
     Or,
-    In
+    In,
 }
 
 impl AsRef<str> for ConditionClauseKind {