1#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
2pub enum DatabaseType {
3 Postgresql,
4 Sqlite,
5 SqlServer,
6}
7
8impl DatabaseType {
9 pub fn statement_separator(&self) -> &'static str {
10 match self {
11 DatabaseType::Postgresql => ";",
12 DatabaseType::Sqlite => ";",
13 DatabaseType::SqlServer => "\ngo",
14 }
15 }
16
17 pub fn max_key_name_length(&self) -> usize {
18 match self {
19 DatabaseType::Postgresql => 63,
20 DatabaseType::Sqlite => 128,
21 DatabaseType::SqlServer => 32,
22 }
23 }
24
25 pub fn default_schema(&self) -> Option<&'static str> {
26 match self {
27 DatabaseType::Postgresql => Some("public"),
28 DatabaseType::SqlServer => Some("dbo"),
29 DatabaseType::Sqlite => None,
30 }
31 }
32
33 pub fn qualified_name(&self, schema_name: Option<&str>, name: &str) -> String {
34 let resolved = match schema_name {
35 Some(s) if *self == DatabaseType::SqlServer && s.eq_ignore_ascii_case("public") => Some("dbo"),
36 Some(s) => Some(s),
37 None => self.default_schema(),
38 };
39 match resolved {
40 Some(schema) if *self == DatabaseType::Sqlite => format!("{}_{}", schema, name),
45 Some(schema) => format!("{}.{}", schema, name),
46 None => name.to_string(),
47 }
48 }
49}
50
51#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
52pub enum RelationType {
53 Cascade,
54 Enforce,
55 SetNull,
56 DoNothing,
57}
58
59#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
60#[derive(Default)]
61pub enum BooleanMode {
62 #[default]
63 Native,
64 YesNo,
65 YN,
66}
67
68
69impl FromStr for BooleanMode {
70 type Err = String;
71
72 fn from_str(s: &str) -> Result<Self, Self::Err> {
73 match s.to_lowercase().as_str() {
74 "native" => Ok(BooleanMode::Native),
75 "yesno" => Ok(BooleanMode::YesNo),
76 "yn" => Ok(BooleanMode::YN),
77 _ => Err(format!("Unknown boolean mode: {}", s)),
78 }
79 }
80}
81
82#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
83#[derive(Default)]
84pub enum ForeignKeyMode {
85 None,
86 #[default]
87 Relations,
88 Triggers,
89}
90
91
92impl FromStr for ForeignKeyMode {
93 type Err = String;
94
95 fn from_str(s: &str) -> Result<Self, Self::Err> {
96 match s.to_lowercase().as_str() {
97 "none" => Ok(ForeignKeyMode::None),
98 "relations" => Ok(ForeignKeyMode::Relations),
99 "triggers" => Ok(ForeignKeyMode::Triggers),
100 _ => Err(format!("Unknown foreign key mode: {}", s)),
101 }
102 }
103}
104
105#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
106pub enum OtherSqlOrder {
107 Bottom,
108 Top,
109}
110
111#[derive(Debug, Clone, PartialEq, Eq, Hash)]
112pub enum TableOption {
113 Data,
114 NoExport,
115 Compress,
116}
117
118#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
119pub enum TriggerType {
120 Update,
121 Delete,
122}
123
124#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
125pub enum KeyType {
126 Primary,
127 Unique,
128 Index,
129}
130
131#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
132#[derive(Default)]
133pub enum LockEscalation {
134 #[default]
135 Auto,
136 Disable,
137 Table,
138}
139
140
141impl FromStr for LockEscalation {
142 type Err = String;
143
144 fn from_str(s: &str) -> Result<Self, Self::Err> {
145 match s.to_lowercase().as_str() {
146 "auto" => Ok(LockEscalation::Auto),
147 "disable" => Ok(LockEscalation::Disable),
148 "table" => Ok(LockEscalation::Table),
149 _ => Err(format!("Unknown lock escalation: {}", s)),
150 }
151 }
152}
153
154use std::str::FromStr;
155
156#[cfg(test)]
157mod tests {
158 use super::*;
159
160 #[test]
161 fn boolean_mode_default_is_native() {
162 let bm = BooleanMode::default();
163 assert_eq!(bm, BooleanMode::Native);
164 }
165
166 #[test]
167 fn enums_equality_and_copy() {
168 let db: DatabaseType = DatabaseType::Postgresql;
169 let db2 = db;
170 assert_eq!(db, db2);
171
172 let t1 = TriggerType::Update;
173 let t2 = TriggerType::Update;
174 assert_eq!(t1, t2);
175
176 let rel = RelationType::Cascade;
177 assert_eq!(rel, RelationType::Cascade);
178
179 let k = KeyType::Primary;
180 assert_eq!(k, KeyType::Primary);
181
182 let fk = ForeignKeyMode::Relations;
183 assert_eq!(fk, ForeignKeyMode::Relations);
184
185 let ord = OtherSqlOrder::Top;
186 assert_eq!(ord, OtherSqlOrder::Top);
187
188 let le = LockEscalation::Auto;
189 assert_eq!(le, LockEscalation::Auto);
190 }
191
192 #[test]
193 fn table_option_equality() {
194 assert_eq!(TableOption::Compress, TableOption::Compress);
195 assert_ne!(TableOption::Data, TableOption::NoExport);
196 }
197
198 #[test]
199 fn default_schema_per_database_type() {
200 assert_eq!(DatabaseType::Postgresql.default_schema(), Some("public"));
201 assert_eq!(DatabaseType::SqlServer.default_schema(), Some("dbo"));
202 assert_eq!(DatabaseType::Sqlite.default_schema(), None);
203 }
204
205 #[test]
206 fn qualified_name_uses_default_schema_when_none() {
207 assert_eq!(DatabaseType::Postgresql.qualified_name(None, "users"), "public.users");
208 assert_eq!(DatabaseType::SqlServer.qualified_name(None, "users"), "dbo.users");
209 assert_eq!(DatabaseType::Sqlite.qualified_name(None, "users"), "users");
210 }
211
212 #[test]
213 fn qualified_name_preserves_explicit_non_default_schema() {
214 assert_eq!(DatabaseType::Postgresql.qualified_name(Some("app"), "users"), "app.users");
215 assert_eq!(DatabaseType::SqlServer.qualified_name(Some("app"), "users"), "app.users");
216 }
217
218 #[test]
219 fn qualified_name_flattens_schema_for_sqlite() {
220 assert_eq!(DatabaseType::Sqlite.qualified_name(Some("app"), "users"), "app_users");
224 assert_eq!(DatabaseType::Sqlite.qualified_name(None, "users"), "users");
225 }
226
227 #[test]
228 fn qualified_name_maps_public_to_dbo_on_sql_server() {
229 assert_eq!(DatabaseType::SqlServer.qualified_name(Some("public"), "users"), "dbo.users");
230 assert_eq!(DatabaseType::SqlServer.qualified_name(Some("PUBLIC"), "users"), "dbo.users");
231 assert_eq!(DatabaseType::Postgresql.qualified_name(Some("public"), "users"), "public.users");
232 }
233}