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") => {
36 Some("dbo")
37 }
38 Some(s) => Some(s),
39 None => self.default_schema(),
40 };
41 match resolved {
42 Some(schema) if *self == DatabaseType::Sqlite => format!("{}_{}", schema, name),
47 Some(schema) => format!("{}.{}", schema, name),
48 None => name.to_string(),
49 }
50 }
51}
52
53#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
54pub enum RelationType {
55 Cascade,
56 Enforce,
57 SetNull,
58 DoNothing,
59}
60
61#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
62pub enum BooleanMode {
63 #[default]
64 Native,
65 YesNo,
66 YN,
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, Default)]
83pub enum ForeignKeyMode {
84 None,
85 #[default]
86 Relations,
87 Triggers,
88}
89
90impl FromStr for ForeignKeyMode {
91 type Err = String;
92
93 fn from_str(s: &str) -> Result<Self, Self::Err> {
94 match s.to_lowercase().as_str() {
95 "none" => Ok(ForeignKeyMode::None),
96 "relations" => Ok(ForeignKeyMode::Relations),
97 "triggers" => Ok(ForeignKeyMode::Triggers),
98 _ => Err(format!("Unknown foreign key mode: {}", s)),
99 }
100 }
101}
102
103#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
104pub enum OtherSqlOrder {
105 Bottom,
106 Top,
107}
108
109#[derive(Debug, Clone, PartialEq, Eq, Hash)]
110pub enum TableOption {
111 Data,
112 NoExport,
113 Compress,
114}
115
116#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
117pub enum TriggerType {
118 Update,
119 Delete,
120}
121
122#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
123pub enum KeyType {
124 Primary,
125 Unique,
126 Index,
127}
128
129#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
130pub enum LockEscalation {
131 #[default]
132 Auto,
133 Disable,
134 Table,
135}
136
137impl FromStr for LockEscalation {
138 type Err = String;
139
140 fn from_str(s: &str) -> Result<Self, Self::Err> {
141 match s.to_lowercase().as_str() {
142 "auto" => Ok(LockEscalation::Auto),
143 "disable" => Ok(LockEscalation::Disable),
144 "table" => Ok(LockEscalation::Table),
145 _ => Err(format!("Unknown lock escalation: {}", s)),
146 }
147 }
148}
149
150use std::str::FromStr;
151
152#[cfg(test)]
153mod tests {
154 use super::*;
155
156 #[test]
157 fn boolean_mode_default_is_native() {
158 let bm = BooleanMode::default();
159 assert_eq!(bm, BooleanMode::Native);
160 }
161
162 #[test]
163 fn enums_equality_and_copy() {
164 let db: DatabaseType = DatabaseType::Postgresql;
165 let db2 = db;
166 assert_eq!(db, db2);
167
168 let t1 = TriggerType::Update;
169 let t2 = TriggerType::Update;
170 assert_eq!(t1, t2);
171
172 let rel = RelationType::Cascade;
173 assert_eq!(rel, RelationType::Cascade);
174
175 let k = KeyType::Primary;
176 assert_eq!(k, KeyType::Primary);
177
178 let fk = ForeignKeyMode::Relations;
179 assert_eq!(fk, ForeignKeyMode::Relations);
180
181 let ord = OtherSqlOrder::Top;
182 assert_eq!(ord, OtherSqlOrder::Top);
183
184 let le = LockEscalation::Auto;
185 assert_eq!(le, LockEscalation::Auto);
186 }
187
188 #[test]
189 fn table_option_equality() {
190 assert_eq!(TableOption::Compress, TableOption::Compress);
191 assert_ne!(TableOption::Data, TableOption::NoExport);
192 }
193
194 #[test]
195 fn default_schema_per_database_type() {
196 assert_eq!(DatabaseType::Postgresql.default_schema(), Some("public"));
197 assert_eq!(DatabaseType::SqlServer.default_schema(), Some("dbo"));
198 assert_eq!(DatabaseType::Sqlite.default_schema(), None);
199 }
200
201 #[test]
202 fn qualified_name_uses_default_schema_when_none() {
203 assert_eq!(
204 DatabaseType::Postgresql.qualified_name(None, "users"),
205 "public.users"
206 );
207 assert_eq!(
208 DatabaseType::SqlServer.qualified_name(None, "users"),
209 "dbo.users"
210 );
211 assert_eq!(DatabaseType::Sqlite.qualified_name(None, "users"), "users");
212 }
213
214 #[test]
215 fn qualified_name_preserves_explicit_non_default_schema() {
216 assert_eq!(
217 DatabaseType::Postgresql.qualified_name(Some("app"), "users"),
218 "app.users"
219 );
220 assert_eq!(
221 DatabaseType::SqlServer.qualified_name(Some("app"), "users"),
222 "app.users"
223 );
224 }
225
226 #[test]
227 fn qualified_name_flattens_schema_for_sqlite() {
228 assert_eq!(
232 DatabaseType::Sqlite.qualified_name(Some("app"), "users"),
233 "app_users"
234 );
235 assert_eq!(DatabaseType::Sqlite.qualified_name(None, "users"), "users");
236 }
237
238 #[test]
239 fn qualified_name_maps_public_to_dbo_on_sql_server() {
240 assert_eq!(
241 DatabaseType::SqlServer.qualified_name(Some("public"), "users"),
242 "dbo.users"
243 );
244 assert_eq!(
245 DatabaseType::SqlServer.qualified_name(Some("PUBLIC"), "users"),
246 "dbo.users"
247 );
248 assert_eq!(
249 DatabaseType::Postgresql.qualified_name(Some("public"), "users"),
250 "public.users"
251 );
252 }
253}