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