rs_aio_db 0.8.5

All in one (aka Aio) database with async support. Based on sqlite, bevy_reflect and tokio, includes a dead simple API to be used (no SQL needed just pure Rust). Comes with automigration.
Documentation 
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

use crate::db::models::Schema;

pub(crate) fn get_sql_type(rust_type: &str) -> Option<String> {

     // "bool" => return Some("NUMERIC".into()),
     // "u8" => return Some("INTEGER".into()),
     // "u16" => return Some("INTEGER".into()),
     // "u32" => return Some("INTEGER".into()),
     // "u64" => return Some("INTEGER".into()),
     // "i8" => return Some("INTEGER".into()),
     // "i16" => return Some("INTEGER".into()),
     // "i32" => return Some("INTEGER".into()),
     // "i64" => return Some("INTEGER".into()),
     // "f32" => return Some("REAL".into()),
     // "f64" => return Some("REAL".into()),
     // "char" => return Some("TEXT".into()),
     // "String" => return Some("TEXT".into()),
     // "Vec" => return Some("BLOB".into()),
     // _ => return None

     // "bool" => return Some("NUMERIC".into()),
     // "u8" => return Some("INTEGER".into()),
     // "u16" => return Some("INTEGER".into()),
     // "u32" => return Some("BIGINT".into()),
     // "u64" => return Some("UNSIGNED BIG INT".into()),
     // "i8" => return Some("TINYINT".into()),
     // "i16" => return Some("SMALLINT".into()),
     // "i32" => return Some("INTEGER".into()),
     // "i64" => return Some("BIGINT".into()),
     // "f32" => return Some("REAL".into()),
     // "f64" => return Some("REAL".into()),
     // "char" => return Some("TEXT".into()),
     // "String" => return Some("TEXT".into()),
     // "Vec" => return Some("BLOB".into()),

     match rust_type {
          "bool" => return Some("NUMERIC".into()),
          "u8" => return Some("INTEGER".into()),
          "u16" => return Some("INTEGER".into()),
          "u32" => return Some("BIGINT".into()),
          "u64" => return Some("UNSIGNED BIG INT".into()),
          "i8" => return Some("TINYINT".into()),
          "i16" => return Some("SMALLINT".into()),
          "i32" => return Some("INTEGER".into()),
          "i64" => return Some("BIGINT".into()),
          "f32" => return Some("REAL".into()),
          "f64" => return Some("REAL".into()),
          "char" => return Some("TEXT".into()),
          "String" => return Some("TEXT".into()),
          "Vec" => return Some("BLOB".into()),
          _ => return None
     }
}

pub(crate) fn get_current_schema(query_result: String) -> Vec<Schema> {
     let content = extract_parentheses_contents(&query_result).unwrap();
     let list = split_by_comma(&content);
     let schema = split_by_empty_space(list);
     return schema;
}

pub(crate) fn extract_parentheses_contents(input: &str) -> Option<String> {
     let mut result = String::new();
     let mut in_parentheses = false;
 
     for c in input.chars() {
         match c {
             '(' => {
                 in_parentheses = true;
             }
             ')' => {
                 break; // Stop when encountering the closing parenthesis
             }
             _ => {
                 if in_parentheses {
                     result.push(c);
                 }
             }
         }
     }
 
     if !result.is_empty() && in_parentheses {
         Some(result)
     } else {
         None
     }
}

pub(crate) fn split_by_comma(input: &str) -> Vec<&str> {
     return input.split(',').map(|s| s.trim()).collect();
}

pub(crate) fn split_by_empty_space(input: Vec<&str>) -> Vec<Schema> {
     let mut list: Vec<Schema> = Vec::new();

     for field in input {
          let splitted: Vec<&str> = field.split(' ').map(|f| f.trim()).collect();
          list.push(Schema {
               field_name: splitted.first().unwrap().to_string(),
               field_type: splitted.last().unwrap().to_string()
          });
     }

     return list;
}

pub(crate) fn generate_db_schema_query(schema_vec: &Vec<Schema>, name: &str) -> String {
     let mut create_table = format!("CREATE TABLE IF NOT EXISTS {} (", name);
               
     for new_field in schema_vec.iter().take(schema_vec.len() - 1) {
          let sql_type = get_sql_type(new_field.field_type.as_str()).unwrap();
          create_table = format!("{} {},", create_table, format!("{} {}", new_field.field_name, sql_type));
     }

     let last_field_type = schema_vec.iter().last().unwrap();
     let sql_type = get_sql_type(last_field_type.field_type.as_str()).unwrap();
     create_table = format!("{} {})", create_table, format!("{} {}", last_field_type.field_name, sql_type));

     return create_table;
}