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