Skip to main content

schema_model/model/
types.rs

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
158// Re-export Version so external crates can access it via model::types
159pub 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}