Skip to main content

schema_model/model/
database_model.rs

1use crate::model::enum_type::EnumType;
2use crate::model::schema::Schema;
3use crate::model::table::Table;
4use crate::model::types::{BooleanMode, ForeignKeyMode};
5
6/// Schema names compare case-insensitively, like table and column names; `None` is the
7/// default schema and only matches `None`.
8fn schema_names_match(a: Option<&str>, b: Option<&str>) -> bool {
9    match (a, b) {
10        (None, None) => true,
11        (Some(a), Some(b)) => a.to_lowercase() == b.to_lowercase(),
12        _ => false,
13    }
14}
15
16/// Splits `table` or `schema.table` into `(schema, table)`. Anything with more than one
17/// dot is rejected rather than guessed at (it used to silently resolve as a table
18/// literally named `a.b.c`).
19fn split_qualified_name(qualified_name: &str) -> Result<(Option<&str>, &str), String> {
20    let parts: Vec<&str> = qualified_name.split('.').collect();
21    match parts.as_slice() {
22        [table] => Ok((None, table)),
23        [schema, table] => Ok((Some(schema), table)),
24        _ => Err(format!(
25            "'{}' is not a valid table reference; expected 'table' or 'schema.table'",
26            qualified_name
27        )),
28    }
29}
30
31#[derive(Debug, Default, Clone)]
32pub struct DatabaseModel {
33    foreign_key_mode: ForeignKeyMode,
34    boolean_mode: BooleanMode,
35    schemas: Vec<Schema>,
36}
37
38impl DatabaseModel {
39    pub fn new(
40        boolean_mode: BooleanMode,
41        foreign_key_mode: ForeignKeyMode,
42        schemas: Vec<Schema>,
43    ) -> Self {
44        Self {
45            boolean_mode,
46            foreign_key_mode,
47            schemas,
48        }
49    }
50
51    pub fn foreign_key_mode(&self) -> ForeignKeyMode {
52        self.foreign_key_mode
53    }
54
55    pub fn boolean_mode(&self) -> BooleanMode {
56        self.boolean_mode
57    }
58
59    pub fn schemas(&self) -> &Vec<Schema> {
60        &self.schemas
61    }
62
63    pub fn default_schema(&self) -> &Schema {
64        self.schemas
65            .iter()
66            .find(|s| s.schema_name().is_none())
67            .expect("Default schema not found")
68    }
69
70    pub fn default_schema_mut(&mut self) -> &mut Schema {
71        self.schemas
72            .iter_mut()
73            .find(|s| s.schema_name().is_none())
74            .expect("Default schema not found")
75    }
76
77    pub fn find_schema(&self, schema_name: Option<&str>) -> &Schema {
78        if schema_name.is_none() {
79            return self.default_schema();
80        }
81
82        self.schemas
83            .iter()
84            .find(|s| schema_names_match(s.schema_name(), schema_name))
85            .unwrap_or_else(|| panic!("Schema '{}' not found", schema_name.unwrap()))
86    }
87
88    pub(crate) fn find_schema_mut(&mut self, schema_name: Option<&str>) -> &mut Schema {
89        if schema_name.is_none() {
90            return self.default_schema_mut();
91        }
92
93        self.schemas
94            .iter_mut()
95            .find(|s| schema_names_match(s.schema_name(), schema_name))
96            .unwrap_or_else(|| panic!("Schema '{}' not found", schema_name.unwrap()))
97    }
98
99    /// Resolves the enum a column in `schema_name` refers to: the column's own schema
100    /// first, then the database-level (default-schema) `<enum>` declarations, so a
101    /// column inside `<schema name="app">` can use a shared top-level enum (M5). An enum
102    /// declared in the column's own schema shadows a same-named database-level one.
103    ///
104    /// Returns the schema that owns the enum (`None` = the default schema) alongside it,
105    /// since a generator that emits a schema-qualified type name needs the owner, not
106    /// the referring column's schema (M4).
107    pub fn resolve_enum_type(
108        &self,
109        schema_name: Option<&str>,
110        enum_type: &str,
111    ) -> Option<(Option<&str>, &EnumType)> {
112        let in_schema = |name: Option<&str>| {
113            self.schemas
114                .iter()
115                .find(|s| schema_names_match(s.schema_name(), name))
116                .and_then(|s| {
117                    s.get_optional_enum_type(enum_type)
118                        .map(|found| (s.schema_name(), found))
119                })
120        };
121        if schema_name.is_some()
122            && let Some(found) = in_schema(schema_name)
123        {
124            return Some(found);
125        }
126        in_schema(None)
127    }
128
129    pub fn find_enum_type(&self, schema_name: Option<&str>, enum_type: &str) -> &EnumType {
130        self.resolve_enum_type(schema_name, enum_type)
131            .map(|(_, found)| found)
132            .unwrap_or_else(|| {
133                panic!(
134                    "Unable to locate an enum type with the name '{}'",
135                    enum_type
136                )
137            })
138    }
139
140    pub fn all_tables(&self) -> Vec<&Table> {
141        self.schemas.iter().flat_map(|s| s.tables()).collect()
142    }
143
144    pub fn find_table(&self, schema_name: Option<&str>, table_name: &str) -> &Table {
145        let schema = self.find_schema(schema_name);
146        schema.get_table(table_name)
147    }
148
149    pub fn find_table_by_qualified_name(&self, qualified_name: &str) -> &Table {
150        let (schema_name, table_name) =
151            split_qualified_name(qualified_name).unwrap_or_else(|e| panic!("{}", e));
152
153        self.find_table(schema_name, table_name)
154    }
155
156    /// Same as `find_table_by_qualified_name`, but returns `None` instead of panicking
157    /// when the schema or table doesn't exist - used by `validate()` to check relation
158    /// targets without crashing on a dangling one.
159    pub fn find_table_by_qualified_name_checked(&self, qualified_name: &str) -> Option<&Table> {
160        let (schema_name, table_name) = split_qualified_name(qualified_name).ok()?;
161
162        self.schemas
163            .iter()
164            .find(|s| schema_names_match(s.schema_name(), schema_name))
165            .and_then(|s| s.get_optional_table(table_name))
166    }
167
168    /// Checks model-wide invariants that individual `Schema::validate()` calls can't see
169    /// (a relation's target table may live in a different schema than the one declaring
170    /// it). Combined with each schema's own `validate()`, this is meant to be run once
171    /// after parsing/building a model and before handing it to SQL generation or
172    /// migration - several generator code paths (`find_enum_type`, `find_table_by_qualified_name`,
173    /// ...) panic on a reference that doesn't resolve, on the assumption the model was
174    /// already validated.
175    pub fn validate(&self) -> Vec<String> {
176        let mut errors: Vec<String> = Vec::new();
177
178        for schema in &self.schemas {
179            errors.extend(schema.validate());
180        }
181
182        for schema in &self.schemas {
183            for table in schema.tables() {
184                for column in table.columns() {
185                    if let Some(enum_type_name) = column.enum_type()
186                        && self
187                            .resolve_enum_type(schema.schema_name(), enum_type_name)
188                            .is_none()
189                    {
190                        errors.push(format!(
191                            "ERROR: {}.{} references enum type '{}' which is not defined in {}",
192                            table.name(),
193                            column.name(),
194                            enum_type_name,
195                            match schema.schema_name() {
196                                Some(name) => format!("schema '{}' or at the database level", name),
197                                None => "this database".to_string(),
198                            }
199                        ));
200                    }
201                }
202            }
203        }
204
205        for table in self.all_tables() {
206            for relation in table.relations() {
207                match split_qualified_name(relation.to_table_name()) {
208                    Err(e) => errors.push(format!(
209                        "ERROR: {}.{} has a relation with an invalid target: {}",
210                        table.name(),
211                        relation.from_column_name(),
212                        e
213                    )),
214                    Ok(_) => {
215                        match self.find_table_by_qualified_name_checked(relation.to_table_name()) {
216                            None => errors.push(format!(
217                                "ERROR: {}.{} has a relation to '{}' which does not exist",
218                                table.name(),
219                                relation.from_column_name(),
220                                relation.to_table_name()
221                            )),
222                            Some(target) => {
223                                for (from_column, to_column) in relation.column_pairs() {
224                                    if !target.has_column(to_column) {
225                                        errors.push(format!(
226                                        "ERROR: {}.{} has a relation to {}.{}, but {} has no column '{}'",
227                                        table.name(),
228                                        from_column,
229                                        relation.to_table_name(),
230                                        to_column,
231                                        target.name(),
232                                        to_column
233                                    ));
234                                    }
235                                }
236                            }
237                        }
238                    }
239                }
240            }
241        }
242
243        errors
244    }
245
246    pub fn find_table_mut(&mut self, schema_name: Option<&str>, table_name: &str) -> &mut Table {
247        let schema = self.find_schema_mut(schema_name);
248        schema.get_table_mut(table_name)
249    }
250
251    /// Same as `find_table_mut`, but returns `None` instead of panicking when the schema
252    /// or table doesn't exist - useful for callers (e.g. the XML parser) resolving
253    /// possibly-malformed input, where a dangling reference should surface as an error
254    /// rather than crash.
255    pub fn find_table_mut_checked(
256        &mut self,
257        schema_name: Option<&str>,
258        table_name: &str,
259    ) -> Option<&mut Table> {
260        let schema = self
261            .schemas
262            .iter_mut()
263            .find(|s| schema_names_match(s.schema_name(), schema_name))?;
264        schema.get_table_mut_checked(table_name)
265    }
266
267    pub fn sort_tables_by_name(&mut self) {
268        for schema in self.schemas.iter_mut() {
269            schema.sort_tables_by_name();
270        }
271    }
272}
273
274#[cfg(test)]
275mod tests {
276    use super::*;
277    use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
278    use crate::model::column_type::ColumnType;
279    use crate::model::relation::Relation;
280    use crate::model::table::Table;
281    use crate::model::types::RelationType;
282
283    #[test]
284    fn validate_reports_error_for_a_relation_whose_target_table_does_not_exist() {
285        // A relation whose target table doesn't exist anywhere in the model (typo'd
286        // name, or a schema that was never declared) must surface as a validation
287        // error - several generator code paths panic on this instead if it's not
288        // caught up front.
289        let child = TableBuilder::new(None::<&str>, "child")
290            .add_column(ColumnBuilder::new(None::<&str>, "parent_id", ColumnType::Int).build())
291            .add_relation(Relation::new(
292                "Regoin",
293                "id",
294                "child",
295                "parent_id",
296                RelationType::Cascade,
297                false,
298            ))
299            .build();
300        let schema = SchemaBuilder::new(None::<&str>).add_table(child).build();
301        let model =
302            DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
303
304        let errors = model.validate();
305        assert_eq!(errors.len(), 1);
306        assert!(errors[0].contains("Regoin"));
307    }
308
309    #[test]
310    fn validate_accepts_a_relation_whose_target_table_exists_in_a_different_schema() {
311        let parent = TableBuilder::new(Some("app"), "parent")
312            .add_column(
313                ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence)
314                    .required(true)
315                    .build(),
316            )
317            .build();
318        let parent_schema = SchemaBuilder::new(Some("app")).add_table(parent).build();
319
320        let child = TableBuilder::new(None::<&str>, "child")
321            .add_column(ColumnBuilder::new(None::<&str>, "parent_id", ColumnType::Int).build())
322            .add_relation(Relation::new(
323                "app.parent",
324                "id",
325                "child",
326                "parent_id",
327                RelationType::Cascade,
328                false,
329            ))
330            .build();
331        let default_schema = SchemaBuilder::new(None::<&str>).add_table(child).build();
332
333        let model = DatabaseModel::new(
334            BooleanMode::Native,
335            ForeignKeyMode::Relations,
336            vec![default_schema, parent_schema],
337        );
338
339        assert!(model.validate().is_empty());
340    }
341
342    fn enum_column_table(schema: Option<&str>, enum_name: &str) -> Table {
343        TableBuilder::new(schema, "widget")
344            .add_column(
345                ColumnBuilder::new(schema, "status", ColumnType::Enum)
346                    .enum_type(Some(enum_name.to_string()))
347                    .build(),
348            )
349            .build()
350    }
351
352    fn enum_named(name: &str) -> crate::model::enum_type::EnumType {
353        crate::model::enum_type::EnumType::new(name, Vec::new())
354    }
355
356    #[test]
357    fn validate_reports_error_for_column_referencing_an_undeclared_enum_type() {
358        // Previously nothing caught this and it panicked deep in SQL generation.
359        let schema = SchemaBuilder::new(Some("s"))
360            .add_table(enum_column_table(Some("s"), "StatusType"))
361            .build();
362        let model =
363            DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
364
365        let errors = model.validate();
366        assert_eq!(errors.len(), 1);
367        assert!(errors[0].contains("StatusType"));
368    }
369
370    #[test]
371    fn validate_accepts_a_database_level_enum_used_from_a_named_schema() {
372        // M5: a top-level `<enum>` lives in the default schema; a column inside
373        // `<schema name="app">` must be able to reference it.
374        let default_schema = SchemaBuilder::new(None::<&str>)
375            .add_enum_type(enum_named("StatusType"))
376            .build();
377        let app = SchemaBuilder::new(Some("app"))
378            .add_table(enum_column_table(Some("app"), "statustype"))
379            .build();
380        let model = DatabaseModel::new(
381            BooleanMode::Native,
382            ForeignKeyMode::Relations,
383            vec![default_schema, app],
384        );
385
386        assert!(model.validate().is_empty());
387    }
388
389    #[test]
390    fn resolve_enum_type_prefers_own_schema_and_reports_the_owner() {
391        let default_schema = SchemaBuilder::new(None::<&str>)
392            .add_enum_type(enum_named("StatusType"))
393            .add_enum_type(enum_named("SharedType"))
394            .build();
395        let app = SchemaBuilder::new(Some("app"))
396            .add_enum_type(enum_named("StatusType"))
397            .build();
398        let model = DatabaseModel::new(
399            BooleanMode::Native,
400            ForeignKeyMode::Relations,
401            vec![default_schema, app],
402        );
403
404        assert_eq!(
405            model
406                .resolve_enum_type(Some("app"), "StatusType")
407                .unwrap()
408                .0,
409            Some("app")
410        );
411        assert_eq!(
412            model
413                .resolve_enum_type(Some("app"), "SharedType")
414                .unwrap()
415                .0,
416            None
417        );
418        assert_eq!(model.resolve_enum_type(None, "StatusType").unwrap().0, None);
419        assert!(model.resolve_enum_type(None, "Missing").is_none());
420    }
421
422    fn id_table(schema: Option<&str>, name: &str) -> Table {
423        TableBuilder::new(schema, name)
424            .add_column(
425                ColumnBuilder::new(schema, "id", ColumnType::Sequence)
426                    .required(true)
427                    .build(),
428            )
429            .build()
430    }
431
432    #[test]
433    fn validate_reports_error_for_a_relation_whose_target_column_does_not_exist() {
434        // M11: only the target *table* used to be checked.
435        let parent = id_table(None, "parent");
436        let child = TableBuilder::new(None::<&str>, "child")
437            .add_column(ColumnBuilder::new(None::<&str>, "parent_id", ColumnType::Int).build())
438            .add_relation(Relation::new(
439                "parent",
440                "idd",
441                "child",
442                "parent_id",
443                RelationType::Cascade,
444                false,
445            ))
446            .build();
447        let schema = SchemaBuilder::new(None::<&str>)
448            .add_table(parent)
449            .add_table(child)
450            .build();
451        let model =
452            DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
453
454        let errors = model.validate();
455        assert_eq!(errors.len(), 1);
456        assert!(errors[0].contains("idd"));
457    }
458
459    #[test]
460    fn find_schema_is_case_insensitive() {
461        // M12: table and column lookups are case-insensitive; schema lookup must match.
462        let app = SchemaBuilder::new(Some("App"))
463            .add_table(id_table(Some("App"), "parent"))
464            .build();
465        let default_schema = SchemaBuilder::new(None::<&str>).build();
466        let model = DatabaseModel::new(
467            BooleanMode::Native,
468            ForeignKeyMode::Relations,
469            vec![default_schema, app],
470        );
471
472        assert_eq!(model.find_schema(Some("app")).schema_name(), Some("App"));
473        assert_eq!(
474            model.find_table_by_qualified_name("APP.Parent").name(),
475            "parent"
476        );
477        assert!(
478            model
479                .find_table_by_qualified_name_checked("app.parent")
480                .is_some()
481        );
482    }
483
484    #[test]
485    fn three_part_qualified_name_is_rejected_not_treated_as_unqualified() {
486        // M12: `db.schema.table` used to resolve a table literally named `db.schema.table`.
487        let model = DatabaseModel::new(
488            BooleanMode::Native,
489            ForeignKeyMode::Relations,
490            vec![
491                SchemaBuilder::new(None::<&str>)
492                    .add_table(id_table(None, "a.b.c"))
493                    .build(),
494            ],
495        );
496
497        assert!(
498            model
499                .find_table_by_qualified_name_checked("a.b.c")
500                .is_none()
501        );
502    }
503}