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