Skip to main content

schema_model/model/
schema.rs

1use crate::model::enum_type::EnumType;
2use crate::model::function::Function;
3use crate::model::other_sql::OtherSql;
4use crate::model::procedure::Procedure;
5use crate::model::table::Table;
6use crate::model::types::{DatabaseType, RelationType};
7use crate::model::view::View;
8use std::collections::HashMap;
9
10#[derive(Debug)]
11pub struct Schema {
12    schema_name: Option<String>,
13    case_sensitive_text: bool,
14    tables: Vec<Table>,
15    views: Vec<View>,
16    functions: Vec<Function>,
17    procedures: Vec<Procedure>,
18    other_sql: Vec<OtherSql>,
19    // Case-insensitive map: store lowercase name -> index in tables vec
20    table_map: HashMap<String, usize>,
21    enum_types: HashMap<String, EnumType>,
22}
23
24impl Default for Schema {
25    fn default() -> Self {
26        Self {
27            schema_name: None,
28            case_sensitive_text: true,
29            tables: Vec::new(),
30            views: Vec::new(),
31            functions: Vec::new(),
32            procedures: Vec::new(),
33            other_sql: Vec::new(),
34            table_map: HashMap::new(),
35            enum_types: HashMap::new(),
36        }
37    }
38}
39
40impl Schema {
41    pub fn new<S: Into<String>>(schema_name: Option<S>) -> Self {
42        Self {
43            schema_name: schema_name.map(|s| s.into()),
44            ..Default::default()
45        }
46    }
47
48    pub fn schema_name(&self) -> Option<&str> {
49        self.schema_name.as_deref()
50    }
51
52    pub fn case_sensitive_text(&self) -> bool {
53        self.case_sensitive_text
54    }
55
56    pub fn set_case_sensitive_text(&mut self, value: bool) {
57        self.case_sensitive_text = value;
58    }
59
60    pub fn tables(&self) -> &[Table] {
61        &self.tables
62    }
63
64    pub fn get_table(&self, name: &str) -> &Table {
65        let idx = self.table_index(name);
66        &self.tables[idx]
67    }
68
69    pub(crate) fn get_table_mut(&mut self, name: &str) -> &mut Table {
70        let idx = self.table_index(name);
71        &mut self.tables[idx]
72    }
73
74    /// Same as `get_table_mut`, but returns `None` instead of panicking when no table
75    /// with this name exists - useful for callers (e.g. the XML parser) resolving
76    /// possibly-malformed input, where a missing table should surface as an error
77    /// rather than crash.
78    pub fn get_table_mut_checked(&mut self, name: &str) -> Option<&mut Table> {
79        let name_lower = name.to_lowercase();
80        let idx = *self.table_map.get(&name_lower)?;
81        Some(&mut self.tables[idx])
82    }
83
84    fn table_index(&self, name: &str) -> usize {
85        let name_lower = name.to_lowercase();
86        *self.table_map.get(&name_lower)
87            .unwrap_or_else(|| panic!("Unable to locate a table with the name '{}'", name))
88    }
89
90    pub fn get_optional_table(&self, name: &str) -> Option<&Table> {
91        let name_lower = name.to_lowercase();
92        self.table_map.get(&name_lower).map(|&idx| &self.tables[idx])
93    }
94
95    pub fn all_views(&self) -> &[View] {
96        &self.views
97    }
98
99    pub fn views(&self, database_type: DatabaseType) -> Vec<View> {
100        self.views
101            .iter()
102            .filter(|view| view.database_type().is_none() || view.database_type().unwrap() == database_type)
103            .cloned()
104            .collect()
105    }
106
107    pub fn enum_types(&self) -> impl Iterator<Item = &EnumType> {
108        let mut enum_types: Vec<&EnumType> = self.enum_types.values().collect();
109        enum_types.sort_by(|a, b| a.name().cmp(b.name()));
110        enum_types.into_iter()
111    }
112
113    pub fn get_enum_type(&self, type_name: &str) -> &EnumType {
114        self.enum_types
115            .get(&type_name.to_lowercase())
116            .unwrap_or_else(|| panic!("Unable to locate an enum type with the name '{}'", type_name))
117    }
118
119    pub fn functions(&self) -> &[Function] {
120        &self.functions
121    }
122
123    pub fn procedures(&self) -> &[Procedure] {
124        &self.procedures
125    }
126
127    pub fn other_sql(&self) -> &[OtherSql] {
128        &self.other_sql
129    }
130
131    pub fn validate(&self) -> Vec<String> {
132        let mut errors: Vec<String> = Vec::new();
133        for table in &self.tables {
134            if table.columns().is_empty() {
135                errors.push(format!(
136                    "ERROR: table {} has no columns; generated `create table` SQL would be invalid",
137                    table.name()
138                ));
139            }
140
141            for relation in table.relations() {
142                if relation.relation_type() == RelationType::SetNull {
143                    let from_column_name = relation.from_column_name();
144                    match table.has_column(from_column_name) {
145                        true if table.column(from_column_name).is_required() => {
146                            errors.push(format!(
147                                "ERROR: {}.{} is required. The {}.{} relation specifies setnull, which is not allowed",
148                                table.name(),
149                                from_column_name,
150                                relation.to_table_name(),
151                                relation.to_column_name()
152                            ));
153                        }
154                        true => {}
155                        false => {
156                            errors.push(format!(
157                                "ERROR: {}.{} does not exist. The {}.{} relation refers to it as the source column",
158                                table.name(),
159                                from_column_name,
160                                relation.to_table_name(),
161                                relation.to_column_name()
162                            ));
163                        }
164                    }
165                }
166            }
167
168            for column in table.columns() {
169                if let Some(enum_type_name) = column.enum_type()
170                    && !self.enum_types.contains_key(&enum_type_name.to_lowercase())
171                {
172                    errors.push(format!(
173                        "ERROR: {}.{} references enum type '{}' which is not defined in this schema",
174                        table.name(),
175                        column.name(),
176                        enum_type_name
177                    ));
178                }
179
180                if column.column_type() == crate::model::column_type::ColumnType::Array
181                    && column.element_type().is_none()
182                {
183                    errors.push(format!(
184                        "ERROR: {}.{} is an array column but has no elementType",
185                        table.name(),
186                        column.name()
187                    ));
188                }
189            }
190        }
191        errors
192    }
193
194    pub(crate) fn add_table(&mut self, table: Table) {
195        let idx = self.tables.len();
196        self.table_map.insert(table.name().to_lowercase(), idx);
197        self.tables.push(table);
198    }
199
200    /// Sorts the schema's tables alphabetically by name, in place. Must be called after all
201    /// tables have been added, since it rebuilds the name -> index lookup used by `get_table`.
202    pub fn sort_tables_by_name(&mut self) {
203        self.tables.sort_by(|a, b| a.name().cmp(b.name()));
204
205        self.table_map.clear();
206        for (idx, table) in self.tables.iter().enumerate() {
207            self.table_map.insert(table.name().to_lowercase(), idx);
208        }
209    }
210
211    pub(crate) fn add_view(&mut self, view: View) {
212        self.views.push(view);
213    }
214
215    pub(crate) fn add_enum_type(&mut self, enum_type: EnumType) {
216        self.enum_types
217            .insert(enum_type.name().to_lowercase(), enum_type);
218    }
219
220    pub(crate) fn add_functions(&mut self, functions: Vec<Function>) {
221        self.functions.extend(functions);
222    }
223
224    pub(crate) fn add_procedures(&mut self, procedures: Vec<Procedure>) {
225        self.procedures.extend(procedures);
226    }
227
228    pub(crate) fn add_other_sql(&mut self, other_sql: OtherSql) {
229        self.other_sql.push(other_sql);
230    }
231}
232
233#[cfg(test)]
234mod tests {
235    use super::*;
236    use crate::model::column::Column;
237    use crate::model::column_type::ColumnType;
238    use crate::model::relation::Relation;
239
240    fn make_schema() -> Schema {
241        Schema::new(Some("schema"))
242    }
243
244    #[test]
245    fn add_and_get_table_and_sort() {
246        let mut schema = make_schema();
247        let table1 = Table::new(
248            Some("schema"),
249            "Table1",
250            Option::<&str>::None,
251            crate::model::types::LockEscalation::Auto,
252            false,
253            vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
254            Vec::new(),
255            Vec::new(),
256            Vec::new(),
257            Vec::new(),
258            Vec::new(),
259            Vec::new(),
260            Vec::new(),
261            Vec::new(),
262        );
263        let table2 = Table::new(
264            Some("schema"),
265            "Table2",
266            Option::<&str>::None,
267            crate::model::types::LockEscalation::Auto,
268            false,
269            Vec::new(),
270            Vec::new(),
271            Vec::new(),
272            Vec::new(),
273            Vec::new(),
274            Vec::new(),
275            Vec::new(),
276            Vec::new(),
277            Vec::new(),
278        );
279        schema.add_table(table1);
280        schema.add_table(table2);
281        assert_eq!(schema.get_table("Table2").name(), "Table2"); // case-insensitive
282        let names: Vec<_> = schema.tables().iter().map(|t| t.name()).collect();
283        assert_eq!(names, vec!["Table1", "Table2"]);
284        // table_map rebuilt so get_table still works
285        assert_eq!(schema.get_table("Table1").name(), "Table1");
286    }
287
288    #[test]
289    fn get_enum_type_is_case_insensitive() {
290        // Matches the case-insensitive lookup used everywhere else in the model
291        // (Table::column/has_column, Schema::get_table); a column declaring
292        // `enumType="gendertype"` must still resolve an enum declared as `GenderType`.
293        let mut schema = make_schema();
294        schema.add_enum_type(EnumType::new("GenderType", Vec::new()));
295
296        assert_eq!(schema.get_enum_type("GenderType").name(), "GenderType");
297        assert_eq!(schema.get_enum_type("gendertype").name(), "GenderType");
298        assert_eq!(schema.get_enum_type("GENDERTYPE").name(), "GenderType");
299    }
300
301    #[test]
302    fn views_filtered_by_database_type() {
303        let mut s = make_schema();
304        s.add_view(View::new(Some("s"), "v1", "sql1", Some(DatabaseType::Postgresql)));
305        s.add_view(View::new(Some("s"), "v2", "sql2", Some(DatabaseType::SqlServer)));
306        let pg = s.views(DatabaseType::Postgresql);
307        assert_eq!(pg.len(), 1);
308        assert_eq!(pg[0].name(), "v1");
309    }
310
311    #[test]
312    fn validate_setnull_error_when_required() {
313        let mut s = make_schema();
314        let parent = Table::new(
315            Some("s"),
316            "parent",
317            Option::<&str>::None,
318            crate::model::types::LockEscalation::Auto,
319            false,
320            vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
321            Vec::new(),
322            Vec::new(),
323            Vec::new(),
324            Vec::new(),
325            Vec::new(),
326            Vec::new(),
327            Vec::new(),
328            Vec::new(),
329        );
330        s.add_table(parent);
331
332        let child = Table::new(
333            Some("s"),
334            "child",
335            Option::<&str>::None,
336            crate::model::types::LockEscalation::Auto,
337            false,
338            vec![Column::new(Some("s"), "pid", ColumnType::Int, 0, 0, true)],
339            Vec::new(),
340            Vec::new(),
341            vec![Relation::new(
342                "parent",
343                "id",
344                "child",
345                "pid",
346                RelationType::SetNull,
347                false,
348            )],
349            Vec::new(),
350            Vec::new(),
351            Vec::new(),
352            Vec::new(),
353            Vec::new(),
354        );
355        s.add_table(child);
356
357        let errors = s.validate();
358        assert_eq!(errors.len(), 1);
359        assert!(errors[0].contains("setnull"));
360    }
361
362    #[test]
363    fn validate_reports_error_instead_of_panicking_when_from_column_is_missing() {
364        // A relation whose `src` attribute doesn't match any real column on the table
365        // (e.g. a typo in the XML) must surface as a validation error, not panic.
366        let mut s = make_schema();
367        let parent = Table::new(
368            Some("s"),
369            "parent",
370            Option::<&str>::None,
371            crate::model::types::LockEscalation::Auto,
372            false,
373            vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
374            Vec::new(),
375            Vec::new(),
376            Vec::new(),
377            Vec::new(),
378            Vec::new(),
379            Vec::new(),
380            Vec::new(),
381            Vec::new(),
382        );
383        s.add_table(parent);
384
385        let child = Table::new(
386            Some("s"),
387            "child",
388            Option::<&str>::None,
389            crate::model::types::LockEscalation::Auto,
390            false,
391            vec![Column::new(Some("s"), "pid", ColumnType::Int, 0, 0, true)],
392            Vec::new(),
393            Vec::new(),
394            vec![Relation::new(
395                "parent",
396                "id",
397                "child",
398                "does_not_exist",
399                RelationType::SetNull,
400                false,
401            )],
402            Vec::new(),
403            Vec::new(),
404            Vec::new(),
405            Vec::new(),
406            Vec::new(),
407        );
408        s.add_table(child);
409
410        let errors = s.validate();
411        assert_eq!(errors.len(), 1);
412        assert!(errors[0].contains("does_not_exist"));
413    }
414
415    #[test]
416    fn validate_reports_error_for_column_referencing_an_undeclared_enum_type() {
417        // A column's `enumType` attribute referencing a name with no matching `<enum>`
418        // declaration must surface as a validation error - previously nothing caught
419        // this, and it panicked deep in SQL generation instead (`get_enum_type`).
420        use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
421        use crate::model::column_type::ColumnType as CT;
422
423        let table = TableBuilder::new(Some("s"), "widget")
424            .add_column(
425                ColumnBuilder::new(Some("s"), "status", CT::Enum)
426                    .enum_type(Some("StatusType".to_string()))
427                    .build(),
428            )
429            .build();
430        let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
431
432        let errors = schema.validate();
433        assert_eq!(errors.len(), 1);
434        assert!(errors[0].contains("StatusType"));
435    }
436
437    #[test]
438    fn validate_reports_error_for_table_with_no_columns() {
439        // A table with zero columns generates invalid `create table t (\n)` DDL; this
440        // must be caught up front rather than crash/emit invalid SQL during generation.
441        use crate::builder::{SchemaBuilder, TableBuilder};
442
443        let table = TableBuilder::new(Some("s"), "widget").build();
444        let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
445
446        let errors = schema.validate();
447        assert_eq!(errors.len(), 1);
448        assert!(errors[0].contains("widget"));
449        assert!(errors[0].contains("no columns"));
450    }
451
452    #[test]
453    fn validate_reports_error_for_array_column_missing_element_type() {
454        use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
455        use crate::model::column_type::ColumnType as CT;
456
457        let table = TableBuilder::new(Some("s"), "widget")
458            .add_column(ColumnBuilder::new(Some("s"), "tags", CT::Array).build())
459            .build();
460        let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
461
462        let errors = schema.validate();
463        assert_eq!(errors.len(), 1);
464        assert!(errors[0].contains("tags"));
465        assert!(errors[0].contains("elementType"));
466    }
467
468    #[test]
469    fn validate_accepts_array_column_with_element_type_set() {
470        use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
471        use crate::model::column_type::ColumnType as CT;
472
473        let table = TableBuilder::new(Some("s"), "widget")
474            .add_column(
475                ColumnBuilder::new(Some("s"), "tags", CT::Array)
476                    .element_type(Some("varchar".to_string()))
477                    .build(),
478            )
479            .build();
480        let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
481
482        assert!(schema.validate().is_empty());
483    }
484
485    #[test]
486    fn validate_accepts_column_referencing_a_declared_enum_type_case_insensitively() {
487        use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
488        use crate::model::column_type::ColumnType as CT;
489        use crate::model::enum_type::EnumType;
490
491        let table = TableBuilder::new(Some("s"), "widget")
492            .add_column(
493                ColumnBuilder::new(Some("s"), "status", CT::Enum)
494                    .enum_type(Some("statustype".to_string()))
495                    .build(),
496            )
497            .build();
498        let schema = SchemaBuilder::new(Some("s"))
499            .add_table(table)
500            .add_enum_type(EnumType::new("StatusType", Vec::new()))
501            .build();
502
503        assert!(schema.validate().is_empty());
504    }
505
506    // #[test]
507    // fn build_reverse_relations_creates_back_refs() {
508    //     let mut s = make_schema();
509    //     let mut parent = Table::new(
510    //         Some("s"),
511    //         "p",
512    //         Option::<&str>::None,
513    //         crate::model::types::LockEscalation::Auto,
514    //         false,
515    //         vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
516    //         Vec::new(),
517    //         Vec::new(),
518    //         Vec::new(),
519    //         Vec::new(),
520    //         Vec::new(),
521    //         Vec::new(),
522    //         Vec::new(),
523    //         Vec::new(),
524    //     );
525    //     let mut child = Table::new(
526    //         Some("s"),
527    //         "c",
528    //         Option::<&str>::None,
529    //         crate::model::types::LockEscalation::Auto,
530    //         false,
531    //         vec![Column::new(Some("s"), "pid", ColumnType::Int, 0, 0, false)],
532    //         Vec::new(),
533    //         Vec::new(),
534    //         vec![Relation::new(
535    //             "p",
536    //             "id",
537    //             "c",
538    //             "pid",
539    //             RelationType::Cascade,
540    //             false,
541    //         )],
542    //         Vec::new(),
543    //         Vec::new(),
544    //         Vec::new(),
545    //         Vec::new(),
546    //         Vec::new(),
547    //     );
548    //     s.add_table(parent);
549    //     s.add_table(child);
550    //
551    //     s.build_reverse_relations();
552    //     let p_ref = s.get_table("p");
553    //     assert_eq!(p_ref.reverse_relations().len(), 1);
554    //     let rr = &p_ref.reverse_relations()[0];
555    //     assert_eq!(rr.from_table_name(), "c");
556    //     assert_eq!(rr.to_table_name(), "p");
557    // }
558}