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
87 .table_map
88 .get(&name_lower)
89 .unwrap_or_else(|| panic!("Unable to locate a table with the name '{}'", name))
90 }
91
92 pub fn get_optional_table(&self, name: &str) -> Option<&Table> {
93 let name_lower = name.to_lowercase();
94 self.table_map
95 .get(&name_lower)
96 .map(|&idx| &self.tables[idx])
97 }
98
99 pub fn all_views(&self) -> &[View] {
100 &self.views
101 }
102
103 pub fn views(&self, database_type: DatabaseType) -> Vec<View> {
104 self.views
105 .iter()
106 .filter(|view| {
107 view.database_type().is_none() || view.database_type().unwrap() == database_type
108 })
109 .cloned()
110 .collect()
111 }
112
113 pub fn enum_types(&self) -> impl Iterator<Item = &EnumType> {
114 let mut enum_types: Vec<&EnumType> = self.enum_types.values().collect();
115 enum_types.sort_by(|a, b| a.name().cmp(b.name()));
116 enum_types.into_iter()
117 }
118
119 pub fn get_optional_enum_type(&self, type_name: &str) -> Option<&EnumType> {
122 self.enum_types.get(&type_name.to_lowercase())
123 }
124
125 pub fn get_enum_type(&self, type_name: &str) -> &EnumType {
126 self.enum_types
127 .get(&type_name.to_lowercase())
128 .unwrap_or_else(|| {
129 panic!(
130 "Unable to locate an enum type with the name '{}'",
131 type_name
132 )
133 })
134 }
135
136 pub fn functions(&self) -> &[Function] {
137 &self.functions
138 }
139
140 pub fn procedures(&self) -> &[Procedure] {
141 &self.procedures
142 }
143
144 pub fn other_sql(&self) -> &[OtherSql] {
145 &self.other_sql
146 }
147
148 pub fn validate(&self) -> Vec<String> {
149 let mut errors: Vec<String> = Vec::new();
150
151 let mut seen_table_names: HashMap<String, &str> = HashMap::new();
152 for table in &self.tables {
153 let name_lower = table.name().to_lowercase();
154 match seen_table_names.entry(name_lower) {
155 std::collections::hash_map::Entry::Occupied(_) => errors.push(format!(
156 "ERROR: duplicate table name '{}'; table names must be unique within a schema \
157 (comparison is case-insensitive)",
158 table.name()
159 )),
160 std::collections::hash_map::Entry::Vacant(slot) => {
161 slot.insert(table.name());
162 }
163 }
164 }
165
166 for table in &self.tables {
167 if table.columns().is_empty() {
168 errors.push(format!(
169 "ERROR: table {} has no columns; generated `create table` SQL would be invalid",
170 table.name()
171 ));
172 }
173
174 let identity_columns: Vec<&str> = table
175 .columns()
176 .iter()
177 .filter(|c| {
178 matches!(
179 c.column_type(),
180 crate::model::column_type::ColumnType::Sequence
181 | crate::model::column_type::ColumnType::LongSequence
182 )
183 })
184 .map(|c| c.name())
185 .collect();
186 if identity_columns.len() > 1 {
187 errors.push(format!(
188 "ERROR: table {} has more than one identity column ({}); \
189 a table may have at most one sequence/longsequence column",
190 table.name(),
191 identity_columns.join(", ")
192 ));
193 }
194
195 let mut seen_column_names: HashMap<String, &str> = HashMap::new();
196 for column in table.columns() {
197 if let Some(generated) = column.generated() {
198 if generated
199 .trim_start()
200 .to_ascii_lowercase()
201 .starts_with("generated")
202 {
203 errors.push(format!(
204 "ERROR: {}.{} has generated='{}'; `generated` must be the bare \
205 expression (e.g. \"price * qty\"), not a full clause",
206 table.name(),
207 column.name(),
208 generated
209 ));
210 }
211 if column.default_constraint().is_some() {
212 errors.push(format!(
213 "ERROR: {}.{} is a generated column and cannot also have a default",
214 table.name(),
215 column.name()
216 ));
217 }
218 }
219 if seen_column_names
220 .insert(column.name().to_lowercase(), column.name())
221 .is_some()
222 {
223 errors.push(format!(
224 "ERROR: table {} has duplicate column name '{}'; column names must be unique \
225 within a table (comparison is case-insensitive)",
226 table.name(),
227 column.name()
228 ));
229 }
230 }
231
232 let key_kinds = [("key", table.keys()), ("index", table.indexes())];
233 for (kind, keys) in key_kinds {
234 for key in keys {
235 for key_column in key.columns() {
236 if !table.has_column(key_column.name()) {
237 errors.push(format!(
238 "ERROR: table {} has a {} on column '{}', which does not exist",
239 table.name(),
240 kind,
241 key_column.name()
242 ));
243 }
244 }
245 }
246 }
247
248 for relation in table.relations() {
249 for (from_column_name, to_column_name) in relation.column_pairs() {
250 if !table.has_column(from_column_name) {
251 errors.push(format!(
252 "ERROR: {}.{} does not exist. The {}.{} relation refers to it as the source column",
253 table.name(),
254 from_column_name,
255 relation.to_table_name(),
256 to_column_name
257 ));
258 } else if relation.relation_type() == RelationType::SetNull
259 && table.column(from_column_name).is_required()
260 {
261 errors.push(format!(
262 "ERROR: {}.{} is required. The {}.{} relation specifies setnull, which is not allowed",
263 table.name(),
264 from_column_name,
265 relation.to_table_name(),
266 to_column_name
267 ));
268 }
269 }
270 }
271
272 for column in table.columns() {
273 if column.column_type() == crate::model::column_type::ColumnType::Enum
277 && column.enum_type().is_none()
278 {
279 errors.push(format!(
280 "ERROR: {}.{} is an enum column but has no enumType",
281 table.name(),
282 column.name()
283 ));
284 }
285
286 if column.column_type() == crate::model::column_type::ColumnType::Array {
287 match column.element_type() {
288 None => {
289 errors.push(format!(
290 "ERROR: {}.{} is an array column but has no elementType",
291 table.name(),
292 column.name()
293 ));
294 }
295 Some(element_type_name) => {
296 if let Err(e) = crate::model::column_type::ColumnType::from_type_name(
297 element_type_name,
298 ) {
299 errors.push(format!(
300 "ERROR: {}.{} is an array column with an invalid elementType '{}': {}",
301 table.name(),
302 column.name(),
303 element_type_name,
304 e
305 ));
306 }
307 }
308 }
309 }
310
311 if column.column_type() == crate::model::column_type::ColumnType::Boolean
312 && let Some(default_constraint) = column.default_constraint()
313 && crate::model::column::parse_boolean_default(default_constraint).is_err()
314 {
315 errors.push(format!(
316 "ERROR: {}.{} has default '{}', which is not a recognized boolean value \
317 (expected true/false, 1/0, yes/no, on/off, or 'null' for no default)",
318 table.name(),
319 column.name(),
320 default_constraint
321 ));
322 }
323
324 if matches!(
325 column.column_type(),
326 crate::model::column_type::ColumnType::Char
327 | crate::model::column_type::ColumnType::Varchar
328 ) && column.length() <= 0
329 {
330 errors.push(format!(
331 "ERROR: {}.{} is a {:?} column with no length (or length <= 0); \
332 a length attribute greater than zero is required",
333 table.name(),
334 column.name(),
335 column.column_type()
336 ));
337 }
338 }
339 }
340 errors
341 }
342
343 pub(crate) fn add_table(&mut self, table: Table) {
344 let idx = self.tables.len();
345 self.table_map.insert(table.name().to_lowercase(), idx);
346 self.tables.push(table);
347 }
348
349 pub fn sort_tables_by_name(&mut self) {
352 self.tables.sort_by(|a, b| a.name().cmp(b.name()));
353
354 self.table_map.clear();
355 for (idx, table) in self.tables.iter().enumerate() {
356 self.table_map.insert(table.name().to_lowercase(), idx);
357 }
358 }
359
360 pub(crate) fn add_view(&mut self, view: View) {
361 self.views.push(view);
362 }
363
364 pub(crate) fn add_enum_type(&mut self, enum_type: EnumType) {
365 self.enum_types
366 .insert(enum_type.name().to_lowercase(), enum_type);
367 }
368
369 pub(crate) fn add_functions(&mut self, functions: Vec<Function>) {
370 self.functions.extend(functions);
371 }
372
373 pub(crate) fn add_procedures(&mut self, procedures: Vec<Procedure>) {
374 self.procedures.extend(procedures);
375 }
376
377 pub(crate) fn add_other_sql(&mut self, other_sql: OtherSql) {
378 self.other_sql.push(other_sql);
379 }
380}
381
382#[cfg(test)]
383mod tests {
384 use super::*;
385 use crate::model::column::Column;
386 use crate::model::column_type::ColumnType;
387 use crate::model::relation::Relation;
388
389 fn make_schema() -> Schema {
390 Schema::new(Some("schema"))
391 }
392
393 #[test]
394 fn add_and_get_table_and_sort() {
395 let mut schema = make_schema();
396 let table1 = Table::new(
397 Some("schema"),
398 "Table1",
399 Option::<&str>::None,
400 crate::model::types::LockEscalation::Auto,
401 false,
402 vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
403 Vec::new(),
404 Vec::new(),
405 Vec::new(),
406 Vec::new(),
407 Vec::new(),
408 Vec::new(),
409 Vec::new(),
410 Vec::new(),
411 );
412 let table2 = Table::new(
413 Some("schema"),
414 "Table2",
415 Option::<&str>::None,
416 crate::model::types::LockEscalation::Auto,
417 false,
418 Vec::new(),
419 Vec::new(),
420 Vec::new(),
421 Vec::new(),
422 Vec::new(),
423 Vec::new(),
424 Vec::new(),
425 Vec::new(),
426 Vec::new(),
427 );
428 schema.add_table(table1);
429 schema.add_table(table2);
430 assert_eq!(schema.get_table("Table2").name(), "Table2"); let names: Vec<_> = schema.tables().iter().map(|t| t.name()).collect();
432 assert_eq!(names, vec!["Table1", "Table2"]);
433 assert_eq!(schema.get_table("Table1").name(), "Table1");
435 }
436
437 #[test]
438 fn get_enum_type_is_case_insensitive() {
439 let mut schema = make_schema();
443 schema.add_enum_type(EnumType::new("GenderType", Vec::new()));
444
445 assert_eq!(schema.get_enum_type("GenderType").name(), "GenderType");
446 assert_eq!(schema.get_enum_type("gendertype").name(), "GenderType");
447 assert_eq!(schema.get_enum_type("GENDERTYPE").name(), "GenderType");
448 }
449
450 #[test]
451 fn views_filtered_by_database_type() {
452 let mut s = make_schema();
453 s.add_view(View::new(
454 Some("s"),
455 "v1",
456 "sql1",
457 Some(DatabaseType::Postgresql),
458 ));
459 s.add_view(View::new(
460 Some("s"),
461 "v2",
462 "sql2",
463 Some(DatabaseType::SqlServer),
464 ));
465 let pg = s.views(DatabaseType::Postgresql);
466 assert_eq!(pg.len(), 1);
467 assert_eq!(pg[0].name(), "v1");
468 }
469
470 #[test]
471 fn validate_setnull_error_when_required() {
472 let mut s = make_schema();
473 let parent = Table::new(
474 Some("s"),
475 "parent",
476 Option::<&str>::None,
477 crate::model::types::LockEscalation::Auto,
478 false,
479 vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
480 Vec::new(),
481 Vec::new(),
482 Vec::new(),
483 Vec::new(),
484 Vec::new(),
485 Vec::new(),
486 Vec::new(),
487 Vec::new(),
488 );
489 s.add_table(parent);
490
491 let child = Table::new(
492 Some("s"),
493 "child",
494 Option::<&str>::None,
495 crate::model::types::LockEscalation::Auto,
496 false,
497 vec![Column::new(Some("s"), "pid", ColumnType::Int, 0, 0, true)],
498 Vec::new(),
499 Vec::new(),
500 vec![Relation::new(
501 "parent",
502 "id",
503 "child",
504 "pid",
505 RelationType::SetNull,
506 false,
507 )],
508 Vec::new(),
509 Vec::new(),
510 Vec::new(),
511 Vec::new(),
512 Vec::new(),
513 );
514 s.add_table(child);
515
516 let errors = s.validate();
517 assert_eq!(errors.len(), 1);
518 assert!(errors[0].contains("setnull"));
519 }
520
521 #[test]
522 fn validate_reports_error_instead_of_panicking_when_from_column_is_missing() {
523 let mut s = make_schema();
526 let parent = Table::new(
527 Some("s"),
528 "parent",
529 Option::<&str>::None,
530 crate::model::types::LockEscalation::Auto,
531 false,
532 vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
533 Vec::new(),
534 Vec::new(),
535 Vec::new(),
536 Vec::new(),
537 Vec::new(),
538 Vec::new(),
539 Vec::new(),
540 Vec::new(),
541 );
542 s.add_table(parent);
543
544 let child = Table::new(
545 Some("s"),
546 "child",
547 Option::<&str>::None,
548 crate::model::types::LockEscalation::Auto,
549 false,
550 vec![Column::new(Some("s"), "pid", ColumnType::Int, 0, 0, true)],
551 Vec::new(),
552 Vec::new(),
553 vec![Relation::new(
554 "parent",
555 "id",
556 "child",
557 "does_not_exist",
558 RelationType::SetNull,
559 false,
560 )],
561 Vec::new(),
562 Vec::new(),
563 Vec::new(),
564 Vec::new(),
565 Vec::new(),
566 );
567 s.add_table(child);
568
569 let errors = s.validate();
570 assert_eq!(errors.len(), 1);
571 assert!(errors[0].contains("does_not_exist"));
572 }
573
574 #[test]
575 fn validate_reports_error_for_duplicate_table_names() {
576 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
582 use crate::model::column_type::ColumnType as CT;
583
584 let make_table = |name: &str| {
585 TableBuilder::new(Some("s"), name)
586 .add_column(
587 ColumnBuilder::new(Some("s"), "id", CT::Sequence)
588 .required(true)
589 .build(),
590 )
591 .build()
592 };
593
594 let schema = SchemaBuilder::new(Some("s"))
595 .add_table(make_table("Users"))
596 .add_table(make_table("users"))
597 .build();
598
599 let errors = schema.validate();
600 assert_eq!(errors.len(), 1);
601 assert!(errors[0].contains("duplicate table name"));
602 assert!(errors[0].contains("users"));
603 }
604
605 #[test]
606 fn validate_reports_error_for_duplicate_column_names() {
607 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
608 use crate::model::column_type::ColumnType as CT;
609
610 let table = TableBuilder::new(None::<&str>, "t")
611 .add_column(ColumnBuilder::new(None::<&str>, "Name", CT::Int).build())
612 .add_column(ColumnBuilder::new(None::<&str>, "name", CT::Int).build())
613 .build();
614 let errors = SchemaBuilder::new(None::<&str>)
615 .add_table(table)
616 .build()
617 .validate();
618
619 assert_eq!(errors.len(), 1);
620 assert!(errors[0].contains("duplicate column name 'name'"));
621 }
622
623 #[test]
624 fn validate_reports_error_for_key_and_index_columns_that_do_not_exist() {
625 use crate::builder::{ColumnBuilder, KeyBuilder, SchemaBuilder, TableBuilder};
626 use crate::model::column_type::ColumnType as CT;
627 use crate::model::types::KeyType;
628
629 let table = TableBuilder::new(None::<&str>, "t")
630 .add_column(
631 ColumnBuilder::new(None::<&str>, "id", CT::Int)
632 .required(true)
633 .build(),
634 )
635 .add_key(KeyBuilder::new(KeyType::Primary).add_column("Idd").build())
636 .add_index(
637 KeyBuilder::new(KeyType::Index)
638 .add_column("ID")
639 .add_column("nope")
640 .build(),
641 )
642 .build();
643 let errors = SchemaBuilder::new(None::<&str>)
644 .add_table(table)
645 .build()
646 .validate();
647
648 assert_eq!(errors.len(), 2);
649 assert!(errors[0].contains("'Idd'"));
650 assert!(errors[1].contains("'nope'"));
651 }
652
653 #[test]
654 fn validate_reports_missing_from_column_for_non_setnull_relations() {
655 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
657 use crate::model::column_type::ColumnType as CT;
658
659 let table = TableBuilder::new(None::<&str>, "t")
660 .add_column(ColumnBuilder::new(None::<&str>, "id", CT::Int).build())
661 .add_relation(Relation::new(
662 "p",
663 "id",
664 "t",
665 "missing",
666 RelationType::Cascade,
667 false,
668 ))
669 .build();
670 let errors = SchemaBuilder::new(None::<&str>)
671 .add_table(table)
672 .build()
673 .validate();
674
675 assert_eq!(errors.len(), 1);
676 assert!(errors[0].contains("t.missing does not exist"));
677 }
678
679 #[test]
680 fn validate_reports_error_for_table_with_no_columns() {
681 use crate::builder::{SchemaBuilder, TableBuilder};
684
685 let table = TableBuilder::new(Some("s"), "widget").build();
686 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
687
688 let errors = schema.validate();
689 assert_eq!(errors.len(), 1);
690 assert!(errors[0].contains("widget"));
691 assert!(errors[0].contains("no columns"));
692 }
693
694 #[test]
695 fn validate_reports_error_for_table_with_multiple_identity_columns() {
696 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
700 use crate::model::column_type::ColumnType as CT;
701
702 let table = TableBuilder::new(Some("s"), "widget")
703 .add_column(
704 ColumnBuilder::new(Some("s"), "id", CT::Sequence)
705 .required(true)
706 .build(),
707 )
708 .add_column(ColumnBuilder::new(Some("s"), "big_id", CT::LongSequence).build())
709 .build();
710 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
711
712 let errors = schema.validate();
713 assert_eq!(errors.len(), 1);
714 assert!(errors[0].contains("widget"));
715 assert!(errors[0].contains("id"));
716 assert!(errors[0].contains("big_id"));
717 }
718
719 #[test]
720 fn validate_rejects_generated_column_with_full_clause_or_default() {
721 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
722 use crate::model::column_type::ColumnType as CT;
723
724 let table = TableBuilder::new(Some("s"), "widget")
725 .add_column(
726 ColumnBuilder::new(Some("s"), "a", CT::Int)
727 .generated(Some("generated always as (1) stored".to_string()))
728 .build(),
729 )
730 .add_column(
731 ColumnBuilder::new(Some("s"), "b", CT::Int)
732 .generated(Some("1".to_string()))
733 .default_constraint(Some("2".to_string()))
734 .build(),
735 )
736 .build();
737 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
738 let errors = schema.validate();
739 assert_eq!(errors.len(), 2, "{errors:?}");
740 }
741
742 #[test]
743 fn validate_accepts_table_with_a_single_identity_column() {
744 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
745 use crate::model::column_type::ColumnType as CT;
746
747 let table = TableBuilder::new(Some("s"), "widget")
748 .add_column(
749 ColumnBuilder::new(Some("s"), "id", CT::Sequence)
750 .required(true)
751 .build(),
752 )
753 .build();
754 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
755
756 assert!(schema.validate().is_empty());
757 }
758
759 #[test]
760 fn validate_reports_error_for_array_column_missing_element_type() {
761 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
762 use crate::model::column_type::ColumnType as CT;
763
764 let table = TableBuilder::new(Some("s"), "widget")
765 .add_column(ColumnBuilder::new(Some("s"), "tags", CT::Array).build())
766 .build();
767 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
768
769 let errors = schema.validate();
770 assert_eq!(errors.len(), 1);
771 assert!(errors[0].contains("tags"));
772 assert!(errors[0].contains("elementType"));
773 }
774
775 #[test]
776 fn validate_accepts_array_column_with_element_type_set() {
777 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
778 use crate::model::column_type::ColumnType as CT;
779
780 let table = TableBuilder::new(Some("s"), "widget")
781 .add_column(
782 ColumnBuilder::new(Some("s"), "tags", CT::Array)
783 .element_type(Some("varchar".to_string()))
784 .build(),
785 )
786 .build();
787 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
788
789 assert!(schema.validate().is_empty());
790 }
791
792 #[test]
793 fn validate_reports_error_for_array_column_with_unparseable_element_type() {
794 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
798 use crate::model::column_type::ColumnType as CT;
799
800 let table = TableBuilder::new(Some("s"), "widget")
801 .add_column(
802 ColumnBuilder::new(Some("s"), "tags", CT::Array)
803 .element_type(Some("not_a_real_type".to_string()))
804 .build(),
805 )
806 .build();
807 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
808
809 let errors = schema.validate();
810 assert_eq!(errors.len(), 1);
811 assert!(errors[0].contains("tags"));
812 assert!(errors[0].contains("not_a_real_type"));
813 }
814
815 #[test]
816 fn validate_reports_error_for_enum_column_with_no_enum_type() {
817 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
821 use crate::model::column_type::ColumnType as CT;
822
823 let table = TableBuilder::new(Some("s"), "widget")
824 .add_column(ColumnBuilder::new(Some("s"), "status", CT::Enum).build())
825 .build();
826 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
827
828 let errors = schema.validate();
829 assert_eq!(errors.len(), 1);
830 assert!(errors[0].contains("status"));
831 assert!(errors[0].contains("enumType"));
832 }
833
834 #[test]
835 fn validate_reports_error_for_unrecognized_boolean_default() {
836 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
837 use crate::model::column_type::ColumnType as CT;
838
839 let table = TableBuilder::new(Some("s"), "widget")
840 .add_column(
841 ColumnBuilder::new(Some("s"), "active", CT::Boolean)
842 .default_constraint(Some("maybe".to_string()))
843 .build(),
844 )
845 .build();
846 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
847
848 let errors = schema.validate();
849 assert_eq!(errors.len(), 1);
850 assert!(errors[0].contains("active"));
851 assert!(errors[0].contains("maybe"));
852 }
853
854 #[test]
855 fn validate_accepts_recognized_boolean_default_spellings() {
856 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
857 use crate::model::column_type::ColumnType as CT;
858
859 for value in ["true", "1", "yes", "on", "false", "0", "no", "off", "null"] {
860 let table = TableBuilder::new(Some("s"), "widget")
861 .add_column(
862 ColumnBuilder::new(Some("s"), "active", CT::Boolean)
863 .default_constraint(Some(value.to_string()))
864 .build(),
865 )
866 .build();
867 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
868
869 assert!(schema.validate().is_empty(), "value: {:?}", value);
870 }
871 }
872
873 #[test]
874 fn validate_accepts_boolean_column_with_no_default() {
875 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
876 use crate::model::column_type::ColumnType as CT;
877
878 let table = TableBuilder::new(Some("s"), "widget")
879 .add_column(ColumnBuilder::new(Some("s"), "active", CT::Boolean).build())
880 .build();
881 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
882
883 assert!(schema.validate().is_empty());
884 }
885
886 #[test]
887 fn validate_reports_error_for_varchar_column_with_no_length() {
888 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
889 use crate::model::column_type::ColumnType as CT;
890
891 let table = TableBuilder::new(Some("s"), "widget")
892 .add_column(ColumnBuilder::new(Some("s"), "name", CT::Varchar).build())
893 .build();
894 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
895
896 let errors = schema.validate();
897 assert_eq!(errors.len(), 1);
898 assert!(errors[0].contains("name"));
899 assert!(errors[0].contains("length"));
900 }
901
902 #[test]
903 fn validate_reports_error_for_char_column_with_zero_length() {
904 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
905 use crate::model::column_type::ColumnType as CT;
906
907 let table = TableBuilder::new(Some("s"), "widget")
908 .add_column(
909 ColumnBuilder::new(Some("s"), "code", CT::Char)
910 .length(0)
911 .build(),
912 )
913 .build();
914 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
915
916 let errors = schema.validate();
917 assert_eq!(errors.len(), 1);
918 assert!(errors[0].contains("code"));
919 }
920
921 #[test]
922 fn validate_accepts_char_and_varchar_columns_with_positive_length() {
923 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
924 use crate::model::column_type::ColumnType as CT;
925
926 let table = TableBuilder::new(Some("s"), "widget")
927 .add_column(
928 ColumnBuilder::new(Some("s"), "code", CT::Char)
929 .length(1)
930 .build(),
931 )
932 .add_column(
933 ColumnBuilder::new(Some("s"), "name", CT::Varchar)
934 .length(100)
935 .build(),
936 )
937 .build();
938 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
939
940 assert!(schema.validate().is_empty());
941 }
942
943 #[test]
944 fn validate_accepts_column_referencing_a_declared_enum_type_case_insensitively() {
945 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
946 use crate::model::column_type::ColumnType as CT;
947 use crate::model::enum_type::EnumType;
948
949 let table = TableBuilder::new(Some("s"), "widget")
950 .add_column(
951 ColumnBuilder::new(Some("s"), "status", CT::Enum)
952 .enum_type(Some("statustype".to_string()))
953 .build(),
954 )
955 .build();
956 let schema = SchemaBuilder::new(Some("s"))
957 .add_table(table)
958 .add_enum_type(EnumType::new("StatusType", Vec::new()))
959 .build();
960
961 assert!(schema.validate().is_empty());
962 }
963
964 }