1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
use strum::IntoEnumIterator;
use super::{category::DataTypeCategory, types_for_database::TypesForDatabase};
use crate::database::{MySqlTypes, PostgresTypes};
use std::fmt::{self, Display, Formatter};
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DatabaseType {
Postgres,
Mysql,
Sqlite,
Mongo,
}
impl Display for DatabaseType {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
let database_type = match *self {
DatabaseType::Postgres => "postgres",
DatabaseType::Mysql => "mysql",
DatabaseType::Sqlite => "sqlite",
DatabaseType::Mongo => "mongo",
};
write!(f, "{}", database_type)
}
}
pub trait DatabaseTypeTrait {
type DatabaseType;
type DataType: Clone;
type DataTypeCategory: Clone;
fn get_database_types(
&self,
data_types_for_category: &Self::DataType,
data_type_category: &Self::DataTypeCategory,
) -> Vec<Self::DataType>;
}
pub struct PostgresDatabaseType;
pub struct MySqlDatabaseType;
pub struct SqliteDatabaseType;
impl DatabaseTypeTrait for PostgresDatabaseType {
type DatabaseType = PostgresTypes;
type DataType = TypesForDatabase;
type DataTypeCategory = DataTypeCategory;
/// # Name: get_database_types
/// ## Description
/// This function returns a vector of all the database types for the given data type category.
/// ## Parameters
/// * `data_types_for_category` - A reference to a vector of data types for the given data type category.
/// * `data_type_category` - A reference to the data type category.
/// ## Returns
/// A vector of all the database types for the given data type category.
/// ## Example
/// ```
/// use rustyroad::database::{DatabaseTypeTrait, PostgresDatabaseType, types_for_database::TypesForDatabase, category::DataTypeCategory, databasetype::DatabaseType};
/// let postgres_database_type = PostgresDatabaseType;
/// let data_types_for_category = TypesForDatabase::new();
/// let data_type_category = DataTypeCategory::new("Text");
///
/// match data_type_category {
/// Some(data_type_category) => {
/// let database_types = postgres_database_type.get_database_types(&data_types_for_category, &data_type_category);
/// assert_eq!(database_types.len(), 1);
/// assert_eq!(database_types[0].get_postgres_types(&data_type_category).len(), 5);
/// },
/// None => {
/// println!("No data type category found");
/// }
/// }
/// ```
fn get_database_types(
&self,
data_types_for_category: &Self::DataType,
data_type_category: &Self::DataTypeCategory,
) -> Vec<TypesForDatabase> {
let data_types = PostgresTypes::iter();
let mut types_for_database = TypesForDatabase::new();
for data_type in data_types {
let _data_type = data_type.to_string();
let _data_type =
data_type_category.get_data_types_from_data_type_category(DatabaseType::Postgres);
let data_type = data_types_for_category.get_postgres_types(data_type_category);
types_for_database.add_postgres_type(data_type_category.to_string(), data_type);
}
let types_for_database = vec![types_for_database];
types_for_database
}
}
impl DatabaseTypeTrait for MySqlDatabaseType {
type DatabaseType = MySqlTypes;
type DataType = TypesForDatabase;
type DataTypeCategory = DataTypeCategory;
/// # Name: get_database_types
/// ## Description
/// This function returns a vector of all the database types for the given data type category.
/// ## Parameters
/// * `data_types_for_category` - A reference to a vector of data types for the given data type category.
/// * `data_type_category` - A reference to the data type category.
/// ## Returns
/// A vector of all the database types for the given data type category.
/// ## Example
/// ```
/// use rustyroad::database::{DatabaseTypeTrait, MySqlDatabaseType, types_for_database::TypesForDatabase, category::DataTypeCategory, databasetype::DatabaseType};
/// let mysql_database_type = MySqlDatabaseType;
/// let data_types_for_category = TypesForDatabase::new();
/// let data_type_category = DataTypeCategory::new("Text");
///
/// match data_type_category {
/// Some(data_type_category) => {
/// let database_types = mysql_database_type.get_database_types(&data_types_for_category, &data_type_category);
/// assert_eq!(database_types.len(), 1);
/// assert_eq!(database_types[0].get_mysql_types(&data_type_category).len(), 5);
/// }
/// None => {
/// println!("No data type category found");
/// }
/// }
/// ```
fn get_database_types(
&self,
data_types_for_category: &Self::DataType,
data_type_category: &Self::DataTypeCategory,
) -> Vec<TypesForDatabase> {
let database_types = MySqlTypes::iter();
let mut types_for_database = TypesForDatabase::new();
for data_type in database_types {
let _data_type = data_type.to_string();
let _data_type =
data_type_category.get_data_types_from_data_type_category(DatabaseType::Mysql);
let data_type = data_types_for_category.get_mysql_types(data_type_category);
types_for_database
.add_mysql_type(data_type_category.to_string(), data_type)
.expect("Failed to add mysql type");
}
let types_for_database = vec![types_for_database];
types_for_database
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_postgres_database_type() {
let postgres_db_type = PostgresDatabaseType;
let data_types_for_category = TypesForDatabase::new();
let data_type_category = DataTypeCategory::Text;
let result =
postgres_db_type.get_database_types(&data_types_for_category, &data_type_category);
// Assert that the result is not empty
assert!(!result.is_empty());
println!("{:?}", result);
let types_for_database = &result[0].postgres.types;
// Assert that the result contains only one element
if let Some(text_types) = types_for_database.get("Text") {
// text_types is a reference to the Vec of types for "Text"
for text_type in text_types {
println!("{:?}", text_type);
}
assert_eq!(text_types.len(), 5);
} else {
println!("No types found for \"Text\"");
}
assert!(types_for_database.contains_key("Text"));
assert_eq!(types_for_database.len(), 1);
}
}