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