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, Clone)]
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 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 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
134 let mut seen_table_names: HashMap<String, &str> = HashMap::new();
135 for table in &self.tables {
136 let name_lower = table.name().to_lowercase();
137 if seen_table_names.contains_key(&name_lower) {
138 errors.push(format!(
139 "ERROR: duplicate table name '{}'; table names must be unique within a schema \
140 (comparison is case-insensitive)",
141 table.name()
142 ));
143 } else {
144 seen_table_names.insert(name_lower, table.name());
145 }
146 }
147
148 for table in &self.tables {
149 if table.columns().is_empty() {
150 errors.push(format!(
151 "ERROR: table {} has no columns; generated `create table` SQL would be invalid",
152 table.name()
153 ));
154 }
155
156 let identity_columns: Vec<&str> = table
157 .columns()
158 .iter()
159 .filter(|c| {
160 matches!(
161 c.column_type(),
162 crate::model::column_type::ColumnType::Sequence
163 | crate::model::column_type::ColumnType::LongSequence
164 )
165 })
166 .map(|c| c.name())
167 .collect();
168 if identity_columns.len() > 1 {
169 errors.push(format!(
170 "ERROR: table {} has more than one identity column ({}); \
171 a table may have at most one sequence/longsequence column",
172 table.name(),
173 identity_columns.join(", ")
174 ));
175 }
176
177 for relation in table.relations() {
178 if relation.relation_type() == RelationType::SetNull {
179 let from_column_name = relation.from_column_name();
180 match table.has_column(from_column_name) {
181 true if table.column(from_column_name).is_required() => {
182 errors.push(format!(
183 "ERROR: {}.{} is required. The {}.{} relation specifies setnull, which is not allowed",
184 table.name(),
185 from_column_name,
186 relation.to_table_name(),
187 relation.to_column_name()
188 ));
189 }
190 true => {}
191 false => {
192 errors.push(format!(
193 "ERROR: {}.{} does not exist. The {}.{} relation refers to it as the source column",
194 table.name(),
195 from_column_name,
196 relation.to_table_name(),
197 relation.to_column_name()
198 ));
199 }
200 }
201 }
202 }
203
204 for column in table.columns() {
205 if let Some(enum_type_name) = column.enum_type()
206 && !self.enum_types.contains_key(&enum_type_name.to_lowercase())
207 {
208 errors.push(format!(
209 "ERROR: {}.{} references enum type '{}' which is not defined in this schema",
210 table.name(),
211 column.name(),
212 enum_type_name
213 ));
214 }
215
216 if column.column_type() == crate::model::column_type::ColumnType::Enum && column.enum_type().is_none() {
217 errors.push(format!(
218 "ERROR: {}.{} is an enum column but has no enumType",
219 table.name(),
220 column.name()
221 ));
222 }
223
224 if column.column_type() == crate::model::column_type::ColumnType::Array {
225 match column.element_type() {
226 None => {
227 errors.push(format!(
228 "ERROR: {}.{} is an array column but has no elementType",
229 table.name(),
230 column.name()
231 ));
232 }
233 Some(element_type_name) => {
234 if let Err(e) = crate::model::column_type::ColumnType::from_type_name(element_type_name) {
235 errors.push(format!(
236 "ERROR: {}.{} is an array column with an invalid elementType '{}': {}",
237 table.name(),
238 column.name(),
239 element_type_name,
240 e
241 ));
242 }
243 }
244 }
245 }
246
247 if column.column_type() == crate::model::column_type::ColumnType::Boolean
248 && let Some(default_constraint) = column.default_constraint()
249 && crate::model::column::parse_boolean_default(default_constraint).is_err()
250 {
251 errors.push(format!(
252 "ERROR: {}.{} has default '{}', which is not a recognized boolean value \
253 (expected true/false, 1/0, yes/no, on/off, or 'null' for no default)",
254 table.name(),
255 column.name(),
256 default_constraint
257 ));
258 }
259
260 if matches!(
261 column.column_type(),
262 crate::model::column_type::ColumnType::Char | crate::model::column_type::ColumnType::Varchar
263 ) && column.length() <= 0
264 {
265 errors.push(format!(
266 "ERROR: {}.{} is a {:?} column with no length (or length <= 0); \
267 a length attribute greater than zero is required",
268 table.name(),
269 column.name(),
270 column.column_type()
271 ));
272 }
273 }
274 }
275 errors
276 }
277
278 pub(crate) fn add_table(&mut self, table: Table) {
279 let idx = self.tables.len();
280 self.table_map.insert(table.name().to_lowercase(), idx);
281 self.tables.push(table);
282 }
283
284 pub fn sort_tables_by_name(&mut self) {
287 self.tables.sort_by(|a, b| a.name().cmp(b.name()));
288
289 self.table_map.clear();
290 for (idx, table) in self.tables.iter().enumerate() {
291 self.table_map.insert(table.name().to_lowercase(), idx);
292 }
293 }
294
295 pub(crate) fn add_view(&mut self, view: View) {
296 self.views.push(view);
297 }
298
299 pub(crate) fn add_enum_type(&mut self, enum_type: EnumType) {
300 self.enum_types
301 .insert(enum_type.name().to_lowercase(), enum_type);
302 }
303
304 pub(crate) fn add_functions(&mut self, functions: Vec<Function>) {
305 self.functions.extend(functions);
306 }
307
308 pub(crate) fn add_procedures(&mut self, procedures: Vec<Procedure>) {
309 self.procedures.extend(procedures);
310 }
311
312 pub(crate) fn add_other_sql(&mut self, other_sql: OtherSql) {
313 self.other_sql.push(other_sql);
314 }
315}
316
317#[cfg(test)]
318mod tests {
319 use super::*;
320 use crate::model::column::Column;
321 use crate::model::column_type::ColumnType;
322 use crate::model::relation::Relation;
323
324 fn make_schema() -> Schema {
325 Schema::new(Some("schema"))
326 }
327
328 #[test]
329 fn add_and_get_table_and_sort() {
330 let mut schema = make_schema();
331 let table1 = Table::new(
332 Some("schema"),
333 "Table1",
334 Option::<&str>::None,
335 crate::model::types::LockEscalation::Auto,
336 false,
337 vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
338 Vec::new(),
339 Vec::new(),
340 Vec::new(),
341 Vec::new(),
342 Vec::new(),
343 Vec::new(),
344 Vec::new(),
345 Vec::new(),
346 );
347 let table2 = Table::new(
348 Some("schema"),
349 "Table2",
350 Option::<&str>::None,
351 crate::model::types::LockEscalation::Auto,
352 false,
353 Vec::new(),
354 Vec::new(),
355 Vec::new(),
356 Vec::new(),
357 Vec::new(),
358 Vec::new(),
359 Vec::new(),
360 Vec::new(),
361 Vec::new(),
362 );
363 schema.add_table(table1);
364 schema.add_table(table2);
365 assert_eq!(schema.get_table("Table2").name(), "Table2"); let names: Vec<_> = schema.tables().iter().map(|t| t.name()).collect();
367 assert_eq!(names, vec!["Table1", "Table2"]);
368 assert_eq!(schema.get_table("Table1").name(), "Table1");
370 }
371
372 #[test]
373 fn get_enum_type_is_case_insensitive() {
374 let mut schema = make_schema();
378 schema.add_enum_type(EnumType::new("GenderType", Vec::new()));
379
380 assert_eq!(schema.get_enum_type("GenderType").name(), "GenderType");
381 assert_eq!(schema.get_enum_type("gendertype").name(), "GenderType");
382 assert_eq!(schema.get_enum_type("GENDERTYPE").name(), "GenderType");
383 }
384
385 #[test]
386 fn views_filtered_by_database_type() {
387 let mut s = make_schema();
388 s.add_view(View::new(Some("s"), "v1", "sql1", Some(DatabaseType::Postgresql)));
389 s.add_view(View::new(Some("s"), "v2", "sql2", Some(DatabaseType::SqlServer)));
390 let pg = s.views(DatabaseType::Postgresql);
391 assert_eq!(pg.len(), 1);
392 assert_eq!(pg[0].name(), "v1");
393 }
394
395 #[test]
396 fn validate_setnull_error_when_required() {
397 let mut s = make_schema();
398 let parent = Table::new(
399 Some("s"),
400 "parent",
401 Option::<&str>::None,
402 crate::model::types::LockEscalation::Auto,
403 false,
404 vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
405 Vec::new(),
406 Vec::new(),
407 Vec::new(),
408 Vec::new(),
409 Vec::new(),
410 Vec::new(),
411 Vec::new(),
412 Vec::new(),
413 );
414 s.add_table(parent);
415
416 let child = Table::new(
417 Some("s"),
418 "child",
419 Option::<&str>::None,
420 crate::model::types::LockEscalation::Auto,
421 false,
422 vec![Column::new(Some("s"), "pid", ColumnType::Int, 0, 0, true)],
423 Vec::new(),
424 Vec::new(),
425 vec![Relation::new(
426 "parent",
427 "id",
428 "child",
429 "pid",
430 RelationType::SetNull,
431 false,
432 )],
433 Vec::new(),
434 Vec::new(),
435 Vec::new(),
436 Vec::new(),
437 Vec::new(),
438 );
439 s.add_table(child);
440
441 let errors = s.validate();
442 assert_eq!(errors.len(), 1);
443 assert!(errors[0].contains("setnull"));
444 }
445
446 #[test]
447 fn validate_reports_error_instead_of_panicking_when_from_column_is_missing() {
448 let mut s = make_schema();
451 let parent = Table::new(
452 Some("s"),
453 "parent",
454 Option::<&str>::None,
455 crate::model::types::LockEscalation::Auto,
456 false,
457 vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
458 Vec::new(),
459 Vec::new(),
460 Vec::new(),
461 Vec::new(),
462 Vec::new(),
463 Vec::new(),
464 Vec::new(),
465 Vec::new(),
466 );
467 s.add_table(parent);
468
469 let child = Table::new(
470 Some("s"),
471 "child",
472 Option::<&str>::None,
473 crate::model::types::LockEscalation::Auto,
474 false,
475 vec![Column::new(Some("s"), "pid", ColumnType::Int, 0, 0, true)],
476 Vec::new(),
477 Vec::new(),
478 vec![Relation::new(
479 "parent",
480 "id",
481 "child",
482 "does_not_exist",
483 RelationType::SetNull,
484 false,
485 )],
486 Vec::new(),
487 Vec::new(),
488 Vec::new(),
489 Vec::new(),
490 Vec::new(),
491 );
492 s.add_table(child);
493
494 let errors = s.validate();
495 assert_eq!(errors.len(), 1);
496 assert!(errors[0].contains("does_not_exist"));
497 }
498
499 #[test]
500 fn validate_reports_error_for_column_referencing_an_undeclared_enum_type() {
501 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
505 use crate::model::column_type::ColumnType as CT;
506
507 let table = TableBuilder::new(Some("s"), "widget")
508 .add_column(
509 ColumnBuilder::new(Some("s"), "status", CT::Enum)
510 .enum_type(Some("StatusType".to_string()))
511 .build(),
512 )
513 .build();
514 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
515
516 let errors = schema.validate();
517 assert_eq!(errors.len(), 1);
518 assert!(errors[0].contains("StatusType"));
519 }
520
521 #[test]
522 fn validate_reports_error_for_duplicate_table_names() {
523 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
529 use crate::model::column_type::ColumnType as CT;
530
531 let make_table = |name: &str| {
532 TableBuilder::new(Some("s"), name)
533 .add_column(ColumnBuilder::new(Some("s"), "id", CT::Sequence).required(true).build())
534 .build()
535 };
536
537 let schema = SchemaBuilder::new(Some("s"))
538 .add_table(make_table("Users"))
539 .add_table(make_table("users"))
540 .build();
541
542 let errors = schema.validate();
543 assert_eq!(errors.len(), 1);
544 assert!(errors[0].contains("duplicate table name"));
545 assert!(errors[0].contains("users"));
546 }
547
548 #[test]
549 fn validate_reports_error_for_table_with_no_columns() {
550 use crate::builder::{SchemaBuilder, TableBuilder};
553
554 let table = TableBuilder::new(Some("s"), "widget").build();
555 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
556
557 let errors = schema.validate();
558 assert_eq!(errors.len(), 1);
559 assert!(errors[0].contains("widget"));
560 assert!(errors[0].contains("no columns"));
561 }
562
563 #[test]
564 fn validate_reports_error_for_table_with_multiple_identity_columns() {
565 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
569 use crate::model::column_type::ColumnType as CT;
570
571 let table = TableBuilder::new(Some("s"), "widget")
572 .add_column(ColumnBuilder::new(Some("s"), "id", CT::Sequence).required(true).build())
573 .add_column(ColumnBuilder::new(Some("s"), "big_id", CT::LongSequence).build())
574 .build();
575 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
576
577 let errors = schema.validate();
578 assert_eq!(errors.len(), 1);
579 assert!(errors[0].contains("widget"));
580 assert!(errors[0].contains("id"));
581 assert!(errors[0].contains("big_id"));
582 }
583
584 #[test]
585 fn validate_accepts_table_with_a_single_identity_column() {
586 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
587 use crate::model::column_type::ColumnType as CT;
588
589 let table = TableBuilder::new(Some("s"), "widget")
590 .add_column(ColumnBuilder::new(Some("s"), "id", CT::Sequence).required(true).build())
591 .build();
592 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
593
594 assert!(schema.validate().is_empty());
595 }
596
597 #[test]
598 fn validate_reports_error_for_array_column_missing_element_type() {
599 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
600 use crate::model::column_type::ColumnType as CT;
601
602 let table = TableBuilder::new(Some("s"), "widget")
603 .add_column(ColumnBuilder::new(Some("s"), "tags", CT::Array).build())
604 .build();
605 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
606
607 let errors = schema.validate();
608 assert_eq!(errors.len(), 1);
609 assert!(errors[0].contains("tags"));
610 assert!(errors[0].contains("elementType"));
611 }
612
613 #[test]
614 fn validate_accepts_array_column_with_element_type_set() {
615 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
616 use crate::model::column_type::ColumnType as CT;
617
618 let table = TableBuilder::new(Some("s"), "widget")
619 .add_column(
620 ColumnBuilder::new(Some("s"), "tags", CT::Array)
621 .element_type(Some("varchar".to_string()))
622 .build(),
623 )
624 .build();
625 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
626
627 assert!(schema.validate().is_empty());
628 }
629
630 #[test]
631 fn validate_reports_error_for_array_column_with_unparseable_element_type() {
632 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
636 use crate::model::column_type::ColumnType as CT;
637
638 let table = TableBuilder::new(Some("s"), "widget")
639 .add_column(
640 ColumnBuilder::new(Some("s"), "tags", CT::Array)
641 .element_type(Some("not_a_real_type".to_string()))
642 .build(),
643 )
644 .build();
645 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
646
647 let errors = schema.validate();
648 assert_eq!(errors.len(), 1);
649 assert!(errors[0].contains("tags"));
650 assert!(errors[0].contains("not_a_real_type"));
651 }
652
653 #[test]
654 fn validate_reports_error_for_enum_column_with_no_enum_type() {
655 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
659 use crate::model::column_type::ColumnType as CT;
660
661 let table = TableBuilder::new(Some("s"), "widget")
662 .add_column(ColumnBuilder::new(Some("s"), "status", CT::Enum).build())
663 .build();
664 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
665
666 let errors = schema.validate();
667 assert_eq!(errors.len(), 1);
668 assert!(errors[0].contains("status"));
669 assert!(errors[0].contains("enumType"));
670 }
671
672 #[test]
673 fn validate_reports_error_for_unrecognized_boolean_default() {
674 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
675 use crate::model::column_type::ColumnType as CT;
676
677 let table = TableBuilder::new(Some("s"), "widget")
678 .add_column(
679 ColumnBuilder::new(Some("s"), "active", CT::Boolean)
680 .default_constraint(Some("maybe".to_string()))
681 .build(),
682 )
683 .build();
684 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
685
686 let errors = schema.validate();
687 assert_eq!(errors.len(), 1);
688 assert!(errors[0].contains("active"));
689 assert!(errors[0].contains("maybe"));
690 }
691
692 #[test]
693 fn validate_accepts_recognized_boolean_default_spellings() {
694 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
695 use crate::model::column_type::ColumnType as CT;
696
697 for value in ["true", "1", "yes", "on", "false", "0", "no", "off", "null"] {
698 let table = TableBuilder::new(Some("s"), "widget")
699 .add_column(
700 ColumnBuilder::new(Some("s"), "active", CT::Boolean)
701 .default_constraint(Some(value.to_string()))
702 .build(),
703 )
704 .build();
705 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
706
707 assert!(schema.validate().is_empty(), "value: {:?}", value);
708 }
709 }
710
711 #[test]
712 fn validate_accepts_boolean_column_with_no_default() {
713 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
714 use crate::model::column_type::ColumnType as CT;
715
716 let table = TableBuilder::new(Some("s"), "widget")
717 .add_column(ColumnBuilder::new(Some("s"), "active", CT::Boolean).build())
718 .build();
719 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
720
721 assert!(schema.validate().is_empty());
722 }
723
724 #[test]
725 fn validate_reports_error_for_varchar_column_with_no_length() {
726 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
727 use crate::model::column_type::ColumnType as CT;
728
729 let table = TableBuilder::new(Some("s"), "widget")
730 .add_column(ColumnBuilder::new(Some("s"), "name", CT::Varchar).build())
731 .build();
732 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
733
734 let errors = schema.validate();
735 assert_eq!(errors.len(), 1);
736 assert!(errors[0].contains("name"));
737 assert!(errors[0].contains("length"));
738 }
739
740 #[test]
741 fn validate_reports_error_for_char_column_with_zero_length() {
742 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
743 use crate::model::column_type::ColumnType as CT;
744
745 let table = TableBuilder::new(Some("s"), "widget")
746 .add_column(ColumnBuilder::new(Some("s"), "code", CT::Char).length(0).build())
747 .build();
748 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
749
750 let errors = schema.validate();
751 assert_eq!(errors.len(), 1);
752 assert!(errors[0].contains("code"));
753 }
754
755 #[test]
756 fn validate_accepts_char_and_varchar_columns_with_positive_length() {
757 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
758 use crate::model::column_type::ColumnType as CT;
759
760 let table = TableBuilder::new(Some("s"), "widget")
761 .add_column(ColumnBuilder::new(Some("s"), "code", CT::Char).length(1).build())
762 .add_column(ColumnBuilder::new(Some("s"), "name", CT::Varchar).length(100).build())
763 .build();
764 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
765
766 assert!(schema.validate().is_empty());
767 }
768
769 #[test]
770 fn validate_accepts_column_referencing_a_declared_enum_type_case_insensitively() {
771 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
772 use crate::model::column_type::ColumnType as CT;
773 use crate::model::enum_type::EnumType;
774
775 let table = TableBuilder::new(Some("s"), "widget")
776 .add_column(
777 ColumnBuilder::new(Some("s"), "status", CT::Enum)
778 .enum_type(Some("statustype".to_string()))
779 .build(),
780 )
781 .build();
782 let schema = SchemaBuilder::new(Some("s"))
783 .add_table(table)
784 .add_enum_type(EnumType::new("StatusType", Vec::new()))
785 .build();
786
787 assert!(schema.validate().is_empty());
788 }
789
790 }