refactor(WIP)!: convertions from types that makes sense on the join clause params

TheRustifyer · TheRustifyer · commit ef2ac178746b · 2025-12-04T12:17:40.000+01:00
diff --git a/canyon_core/src/query/bounds.rs b/canyon_core/src/query/bounds.rs
@@ -38,7 +38,7 @@ pub trait Inspectionable<'a> {
 }
 
 pub trait TableMetadata<'a>: std::fmt::Display {
-    fn as_str(&self) -> &'static str;
+    fn as_str(&self) -> &'a str;
 }
 
 /// Created for retrieve the field's name of a field of a struct, giving
diff --git a/canyon_core/src/query/querybuilder/syntax/column.rs b/canyon_core/src/query/querybuilder/syntax/column.rs
@@ -1,3 +1,4 @@
+use crate::query::bounds::FieldIdentifier;
 use crate::query::querybuilder::syntax::symbol::Symbol::Dot;
 use crate::query::querybuilder::syntax::tokens::{SqlToken, ToSqlTokens};
 
@@ -8,9 +9,18 @@ pub struct ColumnRef<'a> {
     pub alias: Option<&'a str>,
 }
 
+impl<'a, T> From<T> for ColumnRef<'a>
+where
+    T: FieldIdentifier,
+{
+    fn from(value: T) -> Self {
+        Self::from(value.as_str())
+    }
+}
+
 impl<'a> From<&'a str> for ColumnRef<'a> {
     fn from(value: &'a str) -> Self {
-        Self::new(value)
+        __impl::column_ref_from_str_ref(value)
     }
 }
 
@@ -32,7 +42,11 @@ impl<'a> ToSqlTokens<'a> for ColumnRef<'a> {
 
 impl<'a> ColumnRef<'a> {
     pub fn new(column_name: &'a str) -> Self {
-        Self { column: column_name, table: None, alias: None }
+        Self {
+            column: column_name,
+            table: None,
+            alias: None,
+        }
     }
 
     /// mutator that allows to modify a [`ColumnRef`] to have a <table>.<column> format
@@ -52,3 +66,224 @@ impl<'a> ColumnRef<'a> {
         self
     }
 }
+
+mod __impl {
+    use crate::query::querybuilder::syntax::column::{__detail, 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) {
+            Some(idx) => {
+                let (left, right) = trimmed.split_at(idx);
+                let right = right[2..].trim_start();
+                (left.trim(), Some(right.trim()))
+            }
+            None => (trimmed, None),
+        };
+
+        let (table, column) = match before_alias.split_once('.') {
+            Some((tbl, col)) => (Some(tbl.trim()), col.trim()),
+            None => (None, before_alias.trim()),
+        };
+
+        ColumnRef {
+            table,
+            column,
+            alias,
+        }
+    }
+}
+
+mod __detail {
+    pub(crate) fn find_case_insensitive_as(s: &str) -> Option<usize> {
+        let bytes = s.as_bytes();
+        for i in 0..bytes.len().saturating_sub(2) {
+            let a = bytes[i];
+            let b = bytes[i + 1];
+
+            // Match case-insensitive ASCII
+            let is_a = a == b'a' || a == b'A';
+            let is_s = b == b's' || b == b'S';
+
+            if is_a && is_s {
+                let before_ok = i > 0 && bytes[i - 1].is_ascii_whitespace();
+                let after_ok = i + 2 < bytes.len() && bytes[i + 2].is_ascii_whitespace();
+
+                if before_ok && after_ok {
+                    return Some(i);
+                }
+            }
+        }
+        None
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ColumnRef;
+    use crate::query::querybuilder::syntax::column::__detail::find_case_insensitive_as;
+
+    // ------------------------------------------------------------
+    // Tests for find_case_insensitive_as
+    // ------------------------------------------------------------
+    #[test]
+    fn test_find_as_basic_uppercase() {
+        let idx = find_case_insensitive_as("col AS x").unwrap();
+        assert_eq!(&"col AS x"[idx..idx + 2], "AS");
+    }
+
+    #[test]
+    fn test_find_as_lowercase() {
+        let idx = find_case_insensitive_as("col as x").unwrap();
+        assert_eq!(&"col as x"[idx..idx + 2], "as");
+    }
+
+    #[test]
+    fn test_find_as_mixed_case() {
+        let idx = find_case_insensitive_as("col As x").unwrap();
+        assert_eq!(&"col As x"[idx..idx + 2], "As");
+    }
+
+    #[test]
+    fn test_find_as_with_multiple_spaces() {
+        let idx = find_case_insensitive_as("col   AS    x").unwrap();
+        assert_eq!(&"col   AS    x"[idx..idx + 2], "AS");
+    }
+
+    #[test]
+    fn test_find_as_requires_space_before_and_after() {
+        assert!(find_case_insensitive_as("colASx").is_none());
+        assert!(find_case_insensitive_as("col ASx").is_none());
+        assert!(find_case_insensitive_as("colAS x").is_none());
+        assert!(find_case_insensitive_as("ASx").is_none());
+        assert!(find_case_insensitive_as("xAS").is_none());
+    }
+
+    #[test]
+    fn test_find_as_at_start_or_end() {
+        assert!(find_case_insensitive_as(" AS x").is_some());
+        assert!(find_case_insensitive_as("x AS ").is_some());
+    }
+
+    #[test]
+    fn test_find_as_no_match() {
+        assert!(find_case_insensitive_as("column something").is_none());
+        assert!(find_case_insensitive_as("").is_none());
+        assert!(find_case_insensitive_as("a s").is_none());
+        assert!(find_case_insensitive_as("col AX x").is_none());
+    }
+
+    #[test]
+    fn test_find_as_with_table_column() {
+        let idx = find_case_insensitive_as("table.col as alias").unwrap();
+        assert_eq!(&"table.col as alias"[idx..idx + 2], "as");
+    }
+
+    // ------------------------------------------------------------
+    // Tests for From<&str> for ColumnRef
+    // ------------------------------------------------------------
+    #[test]
+    fn test_column_ref_simple_column() {
+        let c = ColumnRef::from("name");
+        assert_eq!(c.table, None);
+        assert_eq!(c.column, "name");
+        assert_eq!(c.alias, None);
+    }
+
+    #[test]
+    fn test_column_ref_table_column() {
+        let c = ColumnRef::from("users.name");
+        assert_eq!(c.table, Some("users"));
+        assert_eq!(c.column, "name");
+        assert_eq!(c.alias, None);
+    }
+
+    #[test]
+    fn test_column_ref_with_alias_uppercase_as() {
+        let c = ColumnRef::from("users.name AS n");
+        assert_eq!(c.table, Some("users"));
+        assert_eq!(c.column, "name");
+        assert_eq!(c.alias, Some("n"));
+    }
+
+    #[test]
+    fn test_column_ref_with_alias_lowercase_as() {
+        let c = ColumnRef::from("users.name as n");
+        assert_eq!(c.table, Some("users"));
+        assert_eq!(c.column, "name");
+        assert_eq!(c.alias, Some("n"));
+    }
+
+    #[test]
+    fn test_column_ref_with_alias_mixed_case_as() {
+        let c = ColumnRef::from("users.name As n");
+        assert_eq!(c.table, Some("users"));
+        assert_eq!(c.column, "name");
+        assert_eq!(c.alias, Some("n"));
+    }
+
+    #[test]
+    fn test_column_ref_multiple_spaces_around_as() {
+        let c = ColumnRef::from("users.name   AS    n");
+        assert_eq!(c.table, Some("users"));
+        assert_eq!(c.column, "name");
+        assert_eq!(c.alias, Some("n"));
+    }
+
+    #[test]
+    fn test_column_ref_alias_without_table() {
+        let c = ColumnRef::from("name AS n");
+        assert_eq!(c.table, None);
+        assert_eq!(c.column, "name");
+        assert_eq!(c.alias, Some("n"));
+    }
+
+    #[test]
+    fn test_column_ref_no_alias_when_as_not_valid() {
+        let c = ColumnRef::from("nameASn");
+        assert_eq!(c.table, None);
+        assert_eq!(c.column, "nameASn");
+        assert_eq!(c.alias, None);
+    }
+
+    #[test]
+    fn test_column_ref_trim_whitespace() {
+        let c = ColumnRef::from("   users.name AS n   ");
+        assert_eq!(c.table, Some("users"));
+        assert_eq!(c.column, "name");
+        assert_eq!(c.alias, Some("n"));
+    }
+
+    #[test]
+    fn test_column_ref_alias_complex() {
+        let c = ColumnRef::from("users.full_name AS fullNameAlias");
+        assert_eq!(c.table, Some("users"));
+        assert_eq!(c.column, "full_name");
+        assert_eq!(c.alias, Some("fullNameAlias"));
+    }
+
+    #[test]
+    fn test_column_ref_no_table_but_alias() {
+        let c = ColumnRef::from("email AS e");
+        assert_eq!(c.table, None);
+        assert_eq!(c.column, "email");
+        assert_eq!(c.alias, Some("e"));
+    }
+
+    #[test]
+    fn test_column_ref_only_column_and_spaces() {
+        let c = ColumnRef::from("   column_name   ");
+        assert_eq!(c.table, None);
+        assert_eq!(c.column, "column_name");
+        assert_eq!(c.alias, None);
+    }
+
+    #[test]
+    fn test_column_ref_only_table_column_with_spaces() {
+        let c = ColumnRef::from("   users . name   ");
+        assert_eq!(c.table, Some("users"));
+        assert_eq!(c.column, "name");
+        assert_eq!(c.alias, None);
+    }
+}
diff --git a/canyon_core/src/query/querybuilder/syntax/table_metadata.rs b/canyon_core/src/query/querybuilder/syntax/table_metadata.rs
@@ -1,13 +1,23 @@
-use std::borrow::Cow;
-use std::fmt::{Display, Formatter};
+use crate::query::bounds;
 use crate::query::querybuilder::syntax::symbol::Symbol;
 use crate::query::querybuilder::syntax::tokens::{SqlToken, ToSqlTokens};
+use std::borrow::Cow;
+use std::fmt::{Display, Formatter};
 
 #[derive(Clone, Default, Debug)]
 pub struct TableMetadata<'a> {
     pub schema: Option<Cow<'a, str>>,
     pub name: Cow<'a, str>,
-} // TODO: we can have those fields as Cow<'_> for max performance
+}
+
+impl<'a, T> From<T> for TableMetadata<'a>
+where
+    T: bounds::TableMetadata<'a>,
+{
+    fn from(value: T) -> Self {
+        Self::from(value.as_str()) // this covers the need of producing <table>.<column>
+    }
+}
 
 impl<'a> ToSqlTokens<'a> for TableMetadata<'a> {
     fn to_tokens(&self, out: &mut Vec<SqlToken<'a>>) {
@@ -38,13 +48,19 @@ impl<'a> From<&'a str> for TableMetadata<'a> {
     }
 }
 
-
 impl<'a> TableMetadata<'a> {
     pub fn new(table_name: &'a str) -> Self {
-        Self { schema: None, name: Cow::from(table_name) }
+        Self {
+            schema: None,
+            name: Cow::from(table_name),
+        }
+    }
+    pub fn schema(&mut self, schema: String) {
+        self.schema = Some(Cow::from(schema));
+    }
+    pub fn table_name(&mut self, table_name: String) {
+        self.name = Cow::from(table_name)
     }
-    pub fn schema(&mut self, schema: String) { self.schema = Some(Cow::from(schema)); }
-    pub fn table_name(&mut self, table_name: String) { self.name = Cow::from(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.
@@ -54,17 +70,23 @@ impl<'a> TableMetadata<'a> {
     /// 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()
+            Some(schema_name) => {
+                format!("{}.{}", schema_name, self.name)
+            }
+            None => self.name.to_string(),
         }
     }
 }
 
 impl<'a> Display for TableMetadata<'a> {
     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)}
+            Some(schema_name) => {
+                write!(f, "{}.{}", schema_name, self.name)
+            }
+            None => {
+                write!(f, "{}", self.name)
+            }
         }
     }
 }
diff --git a/canyon_entities/src/manager_builder.rs b/canyon_entities/src/manager_builder.rs
@@ -73,8 +73,8 @@ pub fn generated_enum_type_for_struct_data(canyon_entity: &CanyonEntity) -> Toke
             }
         }
 
-        impl #generics canyon_sql::query::bounds::TableMetadata<'_> for #generics #enum_name #generics {
-            fn as_str(&self) -> &'static str {
+        impl<'a> canyon_sql::query::bounds::TableMetadata<'a> for #generics #enum_name #generics {
+            fn as_str(&self) -> &'a str {
                 match *self {
                     #enum_name::Name => #struct_name,
                     #enum_name::DbName => #db_target_table_name,
diff --git a/canyon_macros/src/lib.rs b/canyon_macros/src/lib.rs
@@ -81,6 +81,7 @@ pub fn main(_meta: CompilerTokenStream, input: CompilerTokenStream) -> CompilerT
 /// the tokio's current reactor
 #[proc_macro_attribute]
 pub fn canyon_tokio_test(
+    // TODO: with Result for using ? on tests?
     _meta: CompilerTokenStream,
     input: CompilerTokenStream,
 ) -> CompilerTokenStream {
@@ -119,6 +120,7 @@ pub fn canyon_tokio_test(
 #[proc_macro_attribute]
 pub fn canyon_entity(meta: CompilerTokenStream, input: CompilerTokenStream) -> CompilerTokenStream {
     let attrs = syn::parse_macro_input!(meta as syn::AttributeArgs);
+    // TODO: a table with table and schema fields maybe would have been more corret
     generate_canyon_entity_tokens(attrs, input).into()
 }
 
diff --git a/tests/crud/querybuilder_operations.rs b/tests/crud/querybuilder_operations.rs

Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ pub trait Inspectionable<'a> {`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`pub trait TableMetadata<'a>: std::fmt::Display {`
`41`		`- fn as_str(&self) -> &'static str;`
	`41`	`+ fn as_str(&self) -> &'a str;`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`/// Created for retrieve the field's name of a field of a struct, giving`
Original file line number	Diff line number	Diff line change
`@@ -73,8 +73,8 @@ pub fn generated_enum_type_for_struct_data(canyon_entity: &CanyonEntity) -> Toke`
`73`	`73`	`}`
`74`	`74`	`}`
`75`	`75`
`76`		`- impl #generics canyon_sql::query::bounds::TableMetadata<'_> for #generics #enum_name #generics {`
`77`		`- fn as_str(&self) -> &'static str {`
	`76`	`+ impl<'a> canyon_sql::query::bounds::TableMetadata<'a> for #generics #enum_name #generics {`
	`77`	`+ fn as_str(&self) -> &'a str {`
`78`	`78`	`match *self {`
`79`	`79`	`#enum_name::Name => #struct_name,`
`80`	`80`	`#enum_name::DbName => #db_target_table_name,`