1use crate::model::enum_type::EnumType;
2use crate::model::schema::Schema;
3use crate::model::table::Table;
4use crate::model::types::{BooleanMode, ForeignKeyMode};
5
6fn 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
16fn 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 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 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 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 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 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 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 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 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 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 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}