#update Refactored and upgraded the Canyon Memory process. Also, queries are now full parameterized.

Author: TheRustifyer

CHANGELOG.md

@@ -9,10 +9,20 @@ Year format is defined as: `YYYY-m-d`
 
 ## [Unreleased]
 
-## [0.1.1] - 2023 - 03 - 20
+## [0.1.2] - 2023 - 03 - 23
+
+### Update
+
+- Removed from `postgresql` migrations the auto conversion to lowercase of the table and column names
 
 ### Fix
 
+- Solved a bug in the canyon_entity proc macro that was wiring the incorrect user table name in the migrations
+
+## [0.1.1] - 2023 - 03 - 20
+
+### Update
+
 - Adding more types to the supported ones for Tiberius in the row mapper
 
 ## [0.1.0] - 2022 - 12 - 25

canyon_macros/src/lib.rs

@@ -196,11 +196,14 @@ pub fn canyon_entity(
                             .expect("Something went wrong parsing the `table_name` argument")
                             .to_string();
 
-                        if attr_arg_ident == "table_name" || attr_arg_ident == "schema" {
-                            table_name = Some(Box::leak(attr_arg_ident.into_boxed_str()));
+                        if &attr_arg_ident == "table_name" || &attr_arg_ident == "schema" {
                             match nv.lit {
                                 syn::Lit::Str(ref l) => {
-                                    schema_name = Some(Box::leak(l.value().into_boxed_str()))
+                                    if &attr_arg_ident == "table_name" {
+                                        table_name = Some(Box::leak(l.value().into_boxed_str()))
+                                    } else {
+                                        schema_name = Some(Box::leak(l.value().into_boxed_str()))
+                                    }
                                 }
                                 _ => {
                                     parsing_attribute_error = Some(syn::Error::new(
@@ -257,7 +260,9 @@ pub fn canyon_entity(
     let mut new_entity = CanyonRegisterEntity::default();
     let e = Box::leak(entity.struct_name.to_string().into_boxed_str());
     new_entity.entity_name = e;
-    new_entity.user_table_name = table_name;
+    new_entity.entity_db_table_name = table_name.unwrap_or(
+        Box::leak(helpers::default_database_table_name_from_entity_name(e).into_boxed_str())
+    );
     new_entity.user_schema_name = schema_name;
 
     // The entity fields

canyon_macros/src/utils/helpers.rs

@@ -81,7 +81,6 @@ pub fn table_schema_parser(macro_data: &MacroTokens<'_>) -> Result<String, Token
 }
 
 /// Parses a syn::Identifier to get a snake case database name from the type identifier
-/// TODO: #[macro(table_name = 'user_defined_db_table_name)]'
 pub fn _database_table_name_from_struct(ty: &Ident) -> String {
     let struct_name: String = ty.to_string();
     let mut table_name: String = String::new();
@@ -105,9 +104,8 @@ pub fn _database_table_name_from_struct(ty: &Ident) -> String {
     table_name
 }
 
-/// Parses a syn::Identifier to get a snake case database name from the type identifier
-/// TODO: #[macro(table_name = 'user_defined_db_table_name)]'
-pub fn _database_table_name_from_entity_name(ty: &str) -> String {
+/// Parses a syn::Identifier to create a defaulted snake case database table name
+pub fn default_database_table_name_from_entity_name(ty: &str) -> String {
     let struct_name: String = ty.to_string();
     let mut table_name: String = String::new();
 

canyon_observer/src/constants.rs

@@ -1,10 +1,22 @@
-pub mod queries {}
+pub const NUMERIC_PK_DATATYPE: [&str; 6] = ["i16", "u16", "i32", "u32", "i64", "u64"];
+
+pub mod queries {
+    pub const INSERT_INTO_CANYON_MEMORY: &str = 
+        "INSERT INTO canyon_memory (filepath, struct_name, declared_table_name) \
+        VALUES ($1, $2, $3)";
+    pub const UPDATE_CANYON_MEMORY: &str = 
+        "UPDATE canyon_memory SET filepath = $1, struct_name = $2, \
+        declared_table_name = $3 WHERE id = $4";
+    pub const DELETE_FROM_CANYON_MEMORY: &str = 
+        "DELETE FROM canyon_memory WHERE struct_name = $1";
+}
 
 pub mod postgresql_queries {
     pub static CANYON_MEMORY_TABLE: &str = "CREATE TABLE IF NOT EXISTS canyon_memory (
             id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
             filepath VARCHAR NOT NULL,
-            struct_name VARCHAR NOT NULL
+            struct_name VARCHAR NOT NULL,
+            declared_table_name VARCHAR NOT NULL
         )";
 
     pub static FETCH_PUBLIC_SCHEMA: &str =
@@ -38,9 +50,10 @@ pub mod mssql_queries {
     pub static CANYON_MEMORY_TABLE: &str = "IF OBJECT_ID(N'[dbo].[canyon_memory]', N'U') IS NULL
         BEGIN
             CREATE TABLE dbo.canyon_memory (
-                id					INT PRIMARY KEY IDENTITY,
-                filepath			NVARCHAR(250) NOT NULL,
-                struct_name			NVARCHAR(100) NOT NULL
+                id					    INT PRIMARY KEY IDENTITY,
+                filepath			    NVARCHAR(250) NOT NULL,
+                struct_name			    NVARCHAR(100) NOT NULL,
+                declared_table_name	    NVARCHAR(100) NOT NULL
             );
         END";
 
@@ -166,17 +179,8 @@ pub mod sqlserver_type {
     pub const DATETIME: &str = "DATETIME2";
 }
 
-/// Contains fragments queries to be invoked as const items and to be concatenated
-/// with dynamic data
-///
-/// Ex: ` format!("{} PRIMARY KEY GENERATED ALWAYS AS IDENTITY", postgres_datatype_syntax)`
-pub mod query_chunk {
-    // TODO @gbm25
-}
-
 pub mod mocked_data {
     use canyon_connection::lazy_static::lazy_static;
-
     use crate::migrations::information_schema::{ColumnMetadata, TableMetadata};
 
     lazy_static! {

canyon_observer/src/lib.rs

@@ -13,7 +13,6 @@ pub mod migrations;
 
 extern crate canyon_crud;
 
-// The migrator tool
 mod constants;
 pub mod manager;
 
@@ -26,4 +25,27 @@ pub static CANYON_REGISTER_ENTITIES: Mutex<Vec<CanyonRegisterEntity<'static>>> =
 lazy_static! {
     pub static ref QUERIES_TO_EXECUTE: Mutex<HashMap<&'static str, Vec<String>>> =
         Mutex::new(HashMap::new());
+    pub static ref CM_QUERIES_TO_EXECUTE: Mutex<HashMap<&'static str, Vec<(&'static str, Vec<String>)>>> = // TODO Provisional until we parameterize as well the migration queries
+        Mutex::new(HashMap::new());
 }
+
+// TODO replace the unwraps for the operator ? when the appropiated crate will be added
+pub fn add_cm_query_to_execute(stmt: &'static str, datasource_name: &'static str, params: Vec<String>) {
+    if CM_QUERIES_TO_EXECUTE
+        .lock()
+        .unwrap()
+        .contains_key(datasource_name)
+    {
+        CM_QUERIES_TO_EXECUTE
+            .lock()
+            .unwrap()
+            .get_mut(datasource_name)
+            .unwrap()
+            .push((stmt, params));
+    } else {
+        CM_QUERIES_TO_EXECUTE
+            .lock()
+            .unwrap()
+            .insert(datasource_name, vec![(stmt, params)]);
+    }
+}

canyon_observer/src/migrations/handler.rs

@@ -47,34 +47,41 @@ impl Migrations {
 
             let mut migrations_processor = MigrationsProcessor::default();
 
-            let canyon_memory = CanyonMemory::remember(datasource).await;
-            let canyon_tables = CANYON_REGISTER_ENTITIES.lock().unwrap().to_vec();
+            let canyon_entities = CANYON_REGISTER_ENTITIES.lock().unwrap().to_vec();
+            let canyon_memory = CanyonMemory::remember(datasource, &canyon_entities).await;
+            // println!("Canyon memory: {:?}", &canyon_memory);
+            // println!("Canyon tables: {:?}", &canyon_entities);
 
             // Tracked entities that must be migrated whenever Canyon starts
             let schema_status =
                 Self::fetch_database(datasource.name, datasource.properties.db_type).await;
             let database_tables_schema_info = Self::map_rows(schema_status);
+            // println!("DB tables: {:?}", &database_tables_schema_info);
+
 
             // We filter the tables from the schema that aren't Canyon entities
             let mut user_database_tables = vec![];
             for parsed_table in database_tables_schema_info.iter() {
                 if canyon_memory
                     .memory
-                    .values()
-                    .any(|f| f.to_lowercase() == parsed_table.table_name)
-                    || canyon_memory
-                        .renamed_entities
-                        .values()
-                        .any(|f| *f == parsed_table.table_name.to_lowercase())
+                    .iter()
+                    .any(|f|
+                        f.declared_table_name.eq(&parsed_table.table_name)
+                    ) || canyon_memory
+                            .renamed_entities
+                            .values()
+                            .any(|f| *f == parsed_table.table_name)
                 {
                     user_database_tables.append(&mut vec![parsed_table]);
                 }
             }
 
+            println!("Tables to process: {:?}", user_database_tables.iter().map(|t| &t.table_name).collect::<Vec<_>>());
+
             migrations_processor
                 .process(
                     canyon_memory,
-                    canyon_tables,
+                    canyon_entities,
                     user_database_tables,
                     datasource,
                 )