Mysql integration in Canyon (#45)

* mysql-support start with docker configuration to up container and load data

* mysql-support - first implementation workspace canyon_connection

* mysql - change module bounds pending DateTime<OffSet> look problem and implement solution

* mysql-support canyon macros, pending trait implement FromValue in &str and chrono:Date<OffSet>

* mysql-support count table implemented

* mysql-support - pending implement select test

* mysql-support craete reorder array params to use with mysql params

* mysql-support resolve quotes in queries and innecesary loop in reorder map

* mysql-support select, update , and query_builder

* mysql-support correction test insert and delete mysql implementation and investigate get last insert in mysql_async

* develop remove imports not use

* mysql-support added integration to returning primary key

* mysql-support correction cfg features

* mysql-support remove comment to mysql implementation in canyon_database_connector.rs

* mysql-support canyon_macro.rs added in feature migrations

* mysql-support replace error with feature in canyon_macro and separate pattern in crud.rs

* changes: remove CanyonRowsMysql and implement mysql_async, repair initialization mssql

* changes: corrections other test

* changes: insert and multiinsert match_rows

* changes: lib cargo_macros RowMapper

* changes: select macro remove else if to generate tokenstream with action count

* changes: resolve clippy error format! in expect to create Regex

* changes: resolve clippy error format! in expect to create Regex

* changes: implement Operator by datasource type

* changes: added default datasources

* changes: correction error feature specify in datasources.rs enum Auth

* changes: correction cargo fmt

---------

Co-authored-by: OnSystem <thihiddenonsystem@gmail.com>

Author: 0nSystem

.gitignore

@@ -5,4 +5,5 @@ Cargo.lock
 canyon_tester/
 macro_utils.rs
 .vscode/
-postgres-data/
+postgres-data/
+mysql-data/

Cargo.toml

@@ -16,7 +16,6 @@ members = [
     "canyon_entities",
     "canyon_migrations",
     "canyon_macros",
-
     "tests"
 ]
 
@@ -31,6 +30,9 @@ canyon_macros = { workspace = true, path = "canyon_macros" }
 # To be marked as opt deps
 tokio-postgres = { workspace = true, optional = true }
 tiberius = { workspace = true, optional = true }
+mysql_async = { workspace = true, optional = true }
+mysql_common = { workspace = true, optional = true }
+
 
 [workspace.dependencies]
 canyon_crud = { version = "0.4.2", path = "canyon_crud" }
@@ -43,6 +45,8 @@ tokio = { version = "1.27.0", features = ["full"]  }
 tokio-util = { version = "0.7.4", features = ["compat"]  }
 tokio-postgres = { version = "0.7.2", features = ["with-chrono-0_4"] }
 tiberius = { version = "0.12.1", features = ["tds73", "chrono", "integrated-auth-gssapi"] }
+mysql_async = { version = "0.32.2" }
+mysql_common = { version = "0.30.6", features = [ "chrono" ]}
 
 chrono = { version = "0.4", features = ["serde"] }  # Just from TP better?
 serde = { version = "1.0.138", features = ["derive"] }
@@ -54,12 +58,14 @@ lazy_static = "1.4.0"
 toml = "0.7.3"
 async-trait = "0.1.68"
 walkdir = "2.3.3"
-regex = "1.5"
+regex = "1.9.3"
 partialdebug = "0.2.0"
 
 quote = "1.0.9"
 proc-macro2 = "1.0.27"
 
+
+
 [workspace.package]
 version = "0.4.2"
 edition = "2021"
@@ -73,4 +79,5 @@ description = "A Rust ORM and QueryBuilder"
 [features]
 postgres = ["tokio-postgres", "canyon_connection/postgres", "canyon_crud/postgres", "canyon_migrations/postgres", "canyon_macros/postgres"]
 mssql = ["tiberius", "canyon_connection/mssql", "canyon_crud/mssql", "canyon_migrations/mssql", "canyon_macros/mssql"]
+mysql = ["mysql_async", "mysql_common", "canyon_connection/mysql", "canyon_crud/mysql", "canyon_migrations/mysql", "canyon_macros/mysql"]
 migrations = ["canyon_migrations", "canyon_macros/migrations"]

bash_aliases.sh

@@ -15,6 +15,9 @@ tokio-util = { workspace = true }
 
 tokio-postgres = { workspace = true, optional = true }
 tiberius = { workspace = true, optional = true }
+mysql_async = { workspace = true, optional = true }
+mysql_common = { workspace = true, optional = true }
+
 
 futures = { workspace = true }
 indexmap = { workspace = true }
@@ -28,3 +31,6 @@ walkdir = { workspace = true }
 [features]
 postgres = ["tokio-postgres"]
 mssql = ["tiberius", "async-std"]
+mysql = ["mysql_async","mysql_common"]
+
+

canyon_connection/Cargo.toml

@@ -2,12 +2,14 @@ use serde::Deserialize;
 
 #[cfg(feature = "mssql")]
 use async_std::net::TcpStream;
+#[cfg(feature = "mysql")]
+use mysql_async::Pool;
 #[cfg(feature = "mssql")]
 use tiberius::{AuthMethod, Config};
 #[cfg(feature = "postgres")]
 use tokio_postgres::{Client, NoTls};
 
-use crate::datasources::DatasourceConfig;
+use crate::datasources::{Auth, DatasourceConfig};
 
 /// Represents the current supported databases by Canyon
 #[derive(Deserialize, Debug, Eq, PartialEq, Clone, Copy)]
@@ -18,6 +20,19 @@ pub enum DatabaseType {
     #[serde(alias = "sqlserver", alias = "mssql")]
     #[cfg(feature = "mssql")]
     SqlServer,
+    #[serde(alias = "mysql")]
+    #[cfg(feature = "mysql")]
+    MySQL,
+}
+
+impl From<&Auth> for DatabaseType {
+    fn from(value: &Auth) -> Self {
+        match value {
+            crate::datasources::Auth::Postgres(_) => DatabaseType::PostgreSql,
+            crate::datasources::Auth::SqlServer(_) => DatabaseType::SqlServer,
+            crate::datasources::Auth::MySQL(_) => DatabaseType::MySQL,
+        }
+    }
 }
 
 /// A connection with a `PostgreSQL` database
@@ -33,6 +48,12 @@ pub struct SqlServerConnection {
     pub client: &'static mut tiberius::Client<TcpStream>,
 }
 
+/// A connection with a `Mysql` database
+#[cfg(feature = "mysql")]
+pub struct MysqlConnection {
+    pub client: Pool,
+}
+
 /// The Canyon database connection handler. When the client's program
 /// starts, Canyon gets the information about the desired datasources,
 /// process them and generates a pool of 1 to 1 database connection for
@@ -42,6 +63,8 @@ pub enum DatabaseConnection {
     Postgres(PostgreSqlConnection),
     #[cfg(feature = "mssql")]
     SqlServer(SqlServerConnection),
+    #[cfg(feature = "mysql")]
+    MySQL(MysqlConnection),
 }
 
 unsafe impl Send for DatabaseConnection {}
@@ -64,6 +87,10 @@ impl DatabaseConnection {
                     crate::datasources::Auth::SqlServer(_) => {
                         panic!("Found SqlServer auth configuration for a PostgreSQL datasource")
                     }
+                    #[cfg(feature = "mysql")]
+                    crate::datasources::Auth::MySQL(_) => {
+                        panic!("Found MySql auth configuration for a PostgreSQL datasource")
+                    }
                 };
                 let (new_client, new_connection) = tokio_postgres::connect(
                     &format!(
@@ -109,6 +136,10 @@ impl DatabaseConnection {
                         }
                         crate::datasources::SqlServerAuth::Integrated => AuthMethod::Integrated,
                     },
+                    #[cfg(feature = "mysql")]
+                    crate::datasources::Auth::MySQL(_) => {
+                        panic!("Found PostgreSQL auth configuration for a SqlServer database")
+                    }
                 });
 
                 // on production, it is not a good idea to do this. We should upgrade
@@ -136,14 +167,49 @@ impl DatabaseConnection {
                     )),
                 }))
             }
+            #[cfg(feature = "mysql")]
+            DatabaseType::MySQL => {
+                let (user, password) = match &datasource.auth {
+                    #[cfg(feature = "mssql")]
+                    crate::datasources::Auth::SqlServer(_) => {
+                        panic!("Found SqlServer auth configuration for a PostgreSQL datasource")
+                    }
+                    #[cfg(feature = "postgres")]
+                    crate::datasources::Auth::Postgres(_) => {
+                        panic!("Found MySql auth configuration for a PostgreSQL datasource")
+                    }
+                    #[cfg(feature = "mysql")]
+                    crate::datasources::Auth::MySQL(mysql_auth) => match mysql_auth {
+                        crate::datasources::MySQLAuth::Basic { username, password } => {
+                            (username, password)
+                        }
+                    },
+                };
+
+                //TODO add options to optionals params in url
+
+                let url = format!(
+                    "mysql://{}:{}@{}:{}/{}",
+                    user,
+                    password,
+                    datasource.properties.host,
+                    datasource.properties.port.unwrap_or_default(),
+                    datasource.properties.db_name
+                );
+                let mysql_connection = Pool::from_url(url)?;
+
+                Ok(DatabaseConnection::MySQL(MysqlConnection {
+                    client: { mysql_connection },
+                }))
+            }
         }
     }
 
     #[cfg(feature = "postgres")]
     pub fn postgres_connection(&self) -> &PostgreSqlConnection {
         match self {
             DatabaseConnection::Postgres(conn) => conn,
-            #[cfg(all(feature = "postgres", feature = "mssql"))]
+            #[cfg(all(feature = "postgres", feature = "mssql", feature = "mysql"))]
             _ => panic!(),
         }
     }
@@ -152,7 +218,16 @@ impl DatabaseConnection {
     pub fn sqlserver_connection(&mut self) -> &mut SqlServerConnection {
         match self {
             DatabaseConnection::SqlServer(conn) => conn,
-            #[cfg(all(feature = "postgres", feature = "mssql"))]
+            #[cfg(all(feature = "postgres", feature = "mssql", feature = "mysql"))]
+            _ => panic!(),
+        }
+    }
+
+    #[cfg(feature = "mysql")]
+    pub fn mysql_connection(&self) -> &MysqlConnection {
+        match self {
+            DatabaseConnection::MySQL(conn) => conn,
+            #[cfg(all(feature = "postgres", feature = "mssql", feature = "mysql"))]
             _ => panic!(),
         }
     }
@@ -166,13 +241,14 @@ mod database_connection_handler {
     /// Tests the behaviour of the `DatabaseType::from_datasource(...)`
     #[test]
     fn check_from_datasource() {
-        #[cfg(all(feature = "postgres", feature = "mssql"))]
+        #[cfg(all(feature = "postgres", feature = "mssql", feature = "mysql"))]
         {
             const CONFIG_FILE_MOCK_ALT_ALL: &str = r#"
                 [canyon_sql]
                 datasources = [
                     {name = 'PostgresDS', auth = { postgresql = { basic = { username = "postgres", password = "postgres" } } }, properties.host = 'localhost', properties.db_name = 'triforce', properties.migrations='enabled' },
-                    {name = 'SqlServerDS', auth = { sqlserver = { basic = { username = "sa", password = "SqlServer-10" } } }, properties.host = '192.168.0.250.1', properties.port = 3340, properties.db_name = 'triforce2', properties.migrations='disabled' }
+                    {name = 'SqlServerDS', auth = { sqlserver = { basic = { username = "sa", password = "SqlServer-10" } } }, properties.host = '192.168.0.250.1', properties.port = 3340, properties.db_name = 'triforce2', properties.migrations='disabled' },
+                    {name = 'MysqlDS', auth = { mysql = { basic = { username = "root", password = "root" } } }, properties.host = '192.168.0.250.1', properties.port = 3340, properties.db_name = 'triforce2', properties.migrations='disabled' }
                 ]
             "#;
             let config: CanyonSqlConfig = toml::from_str(CONFIG_FILE_MOCK_ALT_ALL)
@@ -185,6 +261,10 @@ mod database_connection_handler {
                 config.canyon_sql.datasources[1].get_db_type(),
                 DatabaseType::SqlServer
             );
+            assert_eq!(
+                config.canyon_sql.datasources[2].get_db_type(),
+                DatabaseType::MySQL
+            );
         }
 
         #[cfg(feature = "postgres")]
@@ -218,5 +298,22 @@ mod database_connection_handler {
                 DatabaseType::SqlServer
             );
         }
+
+        #[cfg(feature = "mysql")]
+        {
+            const CONFIG_FILE_MOCK_ALT_MYSQL: &str = r#"
+                [canyon_sql]
+                datasources = [
+                    {name = 'MysqlDS', auth = { mysql = { basic = { username = "root", password = "root" } } }, properties.host = '192.168.0.250.1', properties.port = 3340, properties.db_name = 'triforce2', properties.migrations='disabled' }
+                ]
+            "#;
+
+            let config: CanyonSqlConfig = toml::from_str(CONFIG_FILE_MOCK_ALT_MYSQL)
+                .expect("A failure happened retrieving the [canyon_sql] section");
+            assert_eq!(
+                config.canyon_sql.datasources[0].get_db_type(),
+                DatabaseType::MySQL
+            );
+        }
     }
 }

canyon_connection/src/canyon_database_connector.rs

@@ -11,7 +11,7 @@ fn load_ds_config_from_array() {
         [canyon_sql]
         datasources = [
             {name = 'PostgresDS', auth = { postgresql = { basic = { username = "postgres", password = "postgres" } } }, properties.host = 'localhost', properties.db_name = 'triforce', properties.migrations='enabled' },
-       ]
+        ]
         "#;
         let config: CanyonSqlConfig = toml::from_str(CONFIG_FILE_MOCK_ALT_PG)
             .expect("A failure happened retrieving the [canyon_sql] section");
@@ -64,6 +64,33 @@ fn load_ds_config_from_array() {
 
         assert_eq!(ds_2.auth, Auth::SqlServer(SqlServerAuth::Integrated));
     }
+    #[cfg(feature = "mysql")]
+    {
+        const CONFIG_FILE_MOCK_ALT_MYSQL: &str = r#"
+        [canyon_sql]
+        datasources = [
+            {name = 'MysqlDS', auth = { mysql = { basic = { username = "root", password = "root" } } }, properties.host = '192.168.0.250.1', properties.port = 3340, properties.db_name = 'triforce2', properties.migrations='disabled' }
+        ]
+        "#;
+        let config: CanyonSqlConfig = toml::from_str(CONFIG_FILE_MOCK_ALT_MYSQL)
+            .expect("A failure happened retrieving the [canyon_sql] section");
+
+        let ds_1 = &config.canyon_sql.datasources[0];
+
+        assert_eq!(ds_1.name, "MysqlDS");
+        assert_eq!(ds_1.get_db_type(), DatabaseType::MySQL);
+        assert_eq!(
+            ds_1.auth,
+            Auth::MySQL(MySQLAuth::Basic {
+                username: "root".to_string(),
+                password: "root".to_string()
+            })
+        );
+        assert_eq!(ds_1.properties.host, "192.168.0.250.1");
+        assert_eq!(ds_1.properties.port, Some(3340));
+        assert_eq!(ds_1.properties.db_name, "triforce2");
+        assert_eq!(ds_1.properties.migrations, Some(Migrations::Disabled));
+    }
 }
 ///
 #[derive(Deserialize, Debug, Clone)]
@@ -90,18 +117,23 @@ impl DatasourceConfig {
             Auth::Postgres(_) => DatabaseType::PostgreSql,
             #[cfg(feature = "mssql")]
             Auth::SqlServer(_) => DatabaseType::SqlServer,
+            #[cfg(feature = "mysql")]
+            Auth::MySQL(_) => DatabaseType::MySQL,
         }
     }
 }
 
 #[derive(Deserialize, Debug, Clone, PartialEq)]
 pub enum Auth {
-    #[serde(alias = "PostgreSQL", alias = "postgresql", alias = "postgres")]
+    #[serde(alias = "PostgresSQL", alias = "postgresql", alias = "postgres")]
     #[cfg(feature = "postgres")]
     Postgres(PostgresAuth),
     #[serde(alias = "SqlServer", alias = "sqlserver", alias = "mssql")]
     #[cfg(feature = "mssql")]
     SqlServer(SqlServerAuth),
+    #[serde(alias = "MYSQL", alias = "mysql", alias = "MySQL")]
+    #[cfg(feature = "mysql")]
+    MySQL(MySQLAuth),
 }
 
 #[derive(Deserialize, Debug, Clone, PartialEq)]
@@ -120,6 +152,13 @@ pub enum SqlServerAuth {
     Integrated,
 }
 
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+#[cfg(feature = "mysql")]
+pub enum MySQLAuth {
+    #[serde(alias = "Basic", alias = "basic")]
+    Basic { username: String, password: String },
+}
+
 #[derive(Deserialize, Debug, Clone)]
 pub struct DatasourceProperties {
     pub host: String,

canyon_connection/src/datasources.rs

@@ -2,6 +2,8 @@
 pub extern crate async_std;
 pub extern crate futures;
 pub extern crate lazy_static;
+#[cfg(feature = "mysql")]
+pub extern crate mysql_async;
 #[cfg(feature = "mssql")]
 pub extern crate tiberius;
 pub extern crate tokio;
@@ -104,3 +106,19 @@ pub fn get_database_connection<'a>(
             )
     }
 }
+
+pub fn get_database_config<'a>(
+    datasource_name: &str,
+    datasources_config: &'a [DatasourceConfig],
+) -> &'a DatasourceConfig {
+    if datasource_name.is_empty() {
+        datasources_config
+            .get(0)
+            .unwrap_or_else(|| panic!("Not exist datasource"))
+    } else {
+        datasources_config
+            .iter()
+            .find(|dc| dc.name == datasource_name)
+            .unwrap_or_else(|| panic!("Not found datasource expected {datasource_name}"))
+    }
+}