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