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 seen_column_names
198 .insert(column.name().to_lowercase(), column.name())
199 .is_some()
200 {
201 errors.push(format!(
202 "ERROR: table {} has duplicate column name '{}'; column names must be unique \
203 within a table (comparison is case-insensitive)",
204 table.name(),
205 column.name()
206 ));
207 }
208 }
209
210 let key_kinds = [("key", table.keys()), ("index", table.indexes())];
211 for (kind, keys) in key_kinds {
212 for key in keys {
213 for key_column in key.columns() {
214 if !table.has_column(key_column.name()) {
215 errors.push(format!(
216 "ERROR: table {} has a {} on column '{}', which does not exist",
217 table.name(),
218 kind,
219 key_column.name()
220 ));
221 }
222 }
223 }
224 }
225
226 for relation in table.relations() {
227 for (from_column_name, to_column_name) in relation.column_pairs() {
228 if !table.has_column(from_column_name) {
229 errors.push(format!(
230 "ERROR: {}.{} does not exist. The {}.{} relation refers to it as the source column",
231 table.name(),
232 from_column_name,
233 relation.to_table_name(),
234 to_column_name
235 ));
236 } else if relation.relation_type() == RelationType::SetNull
237 && table.column(from_column_name).is_required()
238 {
239 errors.push(format!(
240 "ERROR: {}.{} is required. The {}.{} relation specifies setnull, which is not allowed",
241 table.name(),
242 from_column_name,
243 relation.to_table_name(),
244 to_column_name
245 ));
246 }
247 }
248 }
249
250 for column in table.columns() {
251 if column.column_type() == crate::model::column_type::ColumnType::Enum
255 && column.enum_type().is_none()
256 {
257 errors.push(format!(
258 "ERROR: {}.{} is an enum column but has no enumType",
259 table.name(),
260 column.name()
261 ));
262 }
263
264 if column.column_type() == crate::model::column_type::ColumnType::Array {
265 match column.element_type() {
266 None => {
267 errors.push(format!(
268 "ERROR: {}.{} is an array column but has no elementType",
269 table.name(),
270 column.name()
271 ));
272 }
273 Some(element_type_name) => {
274 if let Err(e) = crate::model::column_type::ColumnType::from_type_name(
275 element_type_name,
276 ) {
277 errors.push(format!(
278 "ERROR: {}.{} is an array column with an invalid elementType '{}': {}",
279 table.name(),
280 column.name(),
281 element_type_name,
282 e
283 ));
284 }
285 }
286 }
287 }
288
289 if column.column_type() == crate::model::column_type::ColumnType::Boolean
290 && let Some(default_constraint) = column.default_constraint()
291 && crate::model::column::parse_boolean_default(default_constraint).is_err()
292 {
293 errors.push(format!(
294 "ERROR: {}.{} has default '{}', which is not a recognized boolean value \
295 (expected true/false, 1/0, yes/no, on/off, or 'null' for no default)",
296 table.name(),
297 column.name(),
298 default_constraint
299 ));
300 }
301
302 if matches!(
303 column.column_type(),
304 crate::model::column_type::ColumnType::Char
305 | crate::model::column_type::ColumnType::Varchar
306 ) && column.length() <= 0
307 {
308 errors.push(format!(
309 "ERROR: {}.{} is a {:?} column with no length (or length <= 0); \
310 a length attribute greater than zero is required",
311 table.name(),
312 column.name(),
313 column.column_type()
314 ));
315 }
316 }
317 }
318 errors
319 }
320
321 pub(crate) fn add_table(&mut self, table: Table) {
322 let idx = self.tables.len();
323 self.table_map.insert(table.name().to_lowercase(), idx);
324 self.tables.push(table);
325 }
326
327 pub fn sort_tables_by_name(&mut self) {
330 self.tables.sort_by(|a, b| a.name().cmp(b.name()));
331
332 self.table_map.clear();
333 for (idx, table) in self.tables.iter().enumerate() {
334 self.table_map.insert(table.name().to_lowercase(), idx);
335 }
336 }
337
338 pub(crate) fn add_view(&mut self, view: View) {
339 self.views.push(view);
340 }
341
342 pub(crate) fn add_enum_type(&mut self, enum_type: EnumType) {
343 self.enum_types
344 .insert(enum_type.name().to_lowercase(), enum_type);
345 }
346
347 pub(crate) fn add_functions(&mut self, functions: Vec<Function>) {
348 self.functions.extend(functions);
349 }
350
351 pub(crate) fn add_procedures(&mut self, procedures: Vec<Procedure>) {
352 self.procedures.extend(procedures);
353 }
354
355 pub(crate) fn add_other_sql(&mut self, other_sql: OtherSql) {
356 self.other_sql.push(other_sql);
357 }
358}
359
360#[cfg(test)]
361mod tests {
362 use super::*;
363 use crate::model::column::Column;
364 use crate::model::column_type::ColumnType;
365 use crate::model::relation::Relation;
366
367 fn make_schema() -> Schema {
368 Schema::new(Some("schema"))
369 }
370
371 #[test]
372 fn add_and_get_table_and_sort() {
373 let mut schema = make_schema();
374 let table1 = Table::new(
375 Some("schema"),
376 "Table1",
377 Option::<&str>::None,
378 crate::model::types::LockEscalation::Auto,
379 false,
380 vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
381 Vec::new(),
382 Vec::new(),
383 Vec::new(),
384 Vec::new(),
385 Vec::new(),
386 Vec::new(),
387 Vec::new(),
388 Vec::new(),
389 );
390 let table2 = Table::new(
391 Some("schema"),
392 "Table2",
393 Option::<&str>::None,
394 crate::model::types::LockEscalation::Auto,
395 false,
396 Vec::new(),
397 Vec::new(),
398 Vec::new(),
399 Vec::new(),
400 Vec::new(),
401 Vec::new(),
402 Vec::new(),
403 Vec::new(),
404 Vec::new(),
405 );
406 schema.add_table(table1);
407 schema.add_table(table2);
408 assert_eq!(schema.get_table("Table2").name(), "Table2"); let names: Vec<_> = schema.tables().iter().map(|t| t.name()).collect();
410 assert_eq!(names, vec!["Table1", "Table2"]);
411 assert_eq!(schema.get_table("Table1").name(), "Table1");
413 }
414
415 #[test]
416 fn get_enum_type_is_case_insensitive() {
417 let mut schema = make_schema();
421 schema.add_enum_type(EnumType::new("GenderType", Vec::new()));
422
423 assert_eq!(schema.get_enum_type("GenderType").name(), "GenderType");
424 assert_eq!(schema.get_enum_type("gendertype").name(), "GenderType");
425 assert_eq!(schema.get_enum_type("GENDERTYPE").name(), "GenderType");
426 }
427
428 #[test]
429 fn views_filtered_by_database_type() {
430 let mut s = make_schema();
431 s.add_view(View::new(
432 Some("s"),
433 "v1",
434 "sql1",
435 Some(DatabaseType::Postgresql),
436 ));
437 s.add_view(View::new(
438 Some("s"),
439 "v2",
440 "sql2",
441 Some(DatabaseType::SqlServer),
442 ));
443 let pg = s.views(DatabaseType::Postgresql);
444 assert_eq!(pg.len(), 1);
445 assert_eq!(pg[0].name(), "v1");
446 }
447
448 #[test]
449 fn validate_setnull_error_when_required() {
450 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 "pid",
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("setnull"));
497 }
498
499 #[test]
500 fn validate_reports_error_instead_of_panicking_when_from_column_is_missing() {
501 let mut s = make_schema();
504 let parent = Table::new(
505 Some("s"),
506 "parent",
507 Option::<&str>::None,
508 crate::model::types::LockEscalation::Auto,
509 false,
510 vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
511 Vec::new(),
512 Vec::new(),
513 Vec::new(),
514 Vec::new(),
515 Vec::new(),
516 Vec::new(),
517 Vec::new(),
518 Vec::new(),
519 );
520 s.add_table(parent);
521
522 let child = Table::new(
523 Some("s"),
524 "child",
525 Option::<&str>::None,
526 crate::model::types::LockEscalation::Auto,
527 false,
528 vec![Column::new(Some("s"), "pid", ColumnType::Int, 0, 0, true)],
529 Vec::new(),
530 Vec::new(),
531 vec![Relation::new(
532 "parent",
533 "id",
534 "child",
535 "does_not_exist",
536 RelationType::SetNull,
537 false,
538 )],
539 Vec::new(),
540 Vec::new(),
541 Vec::new(),
542 Vec::new(),
543 Vec::new(),
544 );
545 s.add_table(child);
546
547 let errors = s.validate();
548 assert_eq!(errors.len(), 1);
549 assert!(errors[0].contains("does_not_exist"));
550 }
551
552 #[test]
553 fn validate_reports_error_for_duplicate_table_names() {
554 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
560 use crate::model::column_type::ColumnType as CT;
561
562 let make_table = |name: &str| {
563 TableBuilder::new(Some("s"), name)
564 .add_column(
565 ColumnBuilder::new(Some("s"), "id", CT::Sequence)
566 .required(true)
567 .build(),
568 )
569 .build()
570 };
571
572 let schema = SchemaBuilder::new(Some("s"))
573 .add_table(make_table("Users"))
574 .add_table(make_table("users"))
575 .build();
576
577 let errors = schema.validate();
578 assert_eq!(errors.len(), 1);
579 assert!(errors[0].contains("duplicate table name"));
580 assert!(errors[0].contains("users"));
581 }
582
583 #[test]
584 fn validate_reports_error_for_duplicate_column_names() {
585 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
586 use crate::model::column_type::ColumnType as CT;
587
588 let table = TableBuilder::new(None::<&str>, "t")
589 .add_column(ColumnBuilder::new(None::<&str>, "Name", CT::Int).build())
590 .add_column(ColumnBuilder::new(None::<&str>, "name", CT::Int).build())
591 .build();
592 let errors = SchemaBuilder::new(None::<&str>)
593 .add_table(table)
594 .build()
595 .validate();
596
597 assert_eq!(errors.len(), 1);
598 assert!(errors[0].contains("duplicate column name 'name'"));
599 }
600
601 #[test]
602 fn validate_reports_error_for_key_and_index_columns_that_do_not_exist() {
603 use crate::builder::{ColumnBuilder, KeyBuilder, SchemaBuilder, TableBuilder};
604 use crate::model::column_type::ColumnType as CT;
605 use crate::model::types::KeyType;
606
607 let table = TableBuilder::new(None::<&str>, "t")
608 .add_column(
609 ColumnBuilder::new(None::<&str>, "id", CT::Int)
610 .required(true)
611 .build(),
612 )
613 .add_key(KeyBuilder::new(KeyType::Primary).add_column("Idd").build())
614 .add_index(
615 KeyBuilder::new(KeyType::Index)
616 .add_column("ID")
617 .add_column("nope")
618 .build(),
619 )
620 .build();
621 let errors = SchemaBuilder::new(None::<&str>)
622 .add_table(table)
623 .build()
624 .validate();
625
626 assert_eq!(errors.len(), 2);
627 assert!(errors[0].contains("'Idd'"));
628 assert!(errors[1].contains("'nope'"));
629 }
630
631 #[test]
632 fn validate_reports_missing_from_column_for_non_setnull_relations() {
633 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
635 use crate::model::column_type::ColumnType as CT;
636
637 let table = TableBuilder::new(None::<&str>, "t")
638 .add_column(ColumnBuilder::new(None::<&str>, "id", CT::Int).build())
639 .add_relation(Relation::new(
640 "p",
641 "id",
642 "t",
643 "missing",
644 RelationType::Cascade,
645 false,
646 ))
647 .build();
648 let errors = SchemaBuilder::new(None::<&str>)
649 .add_table(table)
650 .build()
651 .validate();
652
653 assert_eq!(errors.len(), 1);
654 assert!(errors[0].contains("t.missing does not exist"));
655 }
656
657 #[test]
658 fn validate_reports_error_for_table_with_no_columns() {
659 use crate::builder::{SchemaBuilder, TableBuilder};
662
663 let table = TableBuilder::new(Some("s"), "widget").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("widget"));
669 assert!(errors[0].contains("no columns"));
670 }
671
672 #[test]
673 fn validate_reports_error_for_table_with_multiple_identity_columns() {
674 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
678 use crate::model::column_type::ColumnType as CT;
679
680 let table = TableBuilder::new(Some("s"), "widget")
681 .add_column(
682 ColumnBuilder::new(Some("s"), "id", CT::Sequence)
683 .required(true)
684 .build(),
685 )
686 .add_column(ColumnBuilder::new(Some("s"), "big_id", CT::LongSequence).build())
687 .build();
688 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
689
690 let errors = schema.validate();
691 assert_eq!(errors.len(), 1);
692 assert!(errors[0].contains("widget"));
693 assert!(errors[0].contains("id"));
694 assert!(errors[0].contains("big_id"));
695 }
696
697 #[test]
698 fn validate_accepts_table_with_a_single_identity_column() {
699 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 .build();
709 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
710
711 assert!(schema.validate().is_empty());
712 }
713
714 #[test]
715 fn validate_reports_error_for_array_column_missing_element_type() {
716 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
717 use crate::model::column_type::ColumnType as CT;
718
719 let table = TableBuilder::new(Some("s"), "widget")
720 .add_column(ColumnBuilder::new(Some("s"), "tags", CT::Array).build())
721 .build();
722 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
723
724 let errors = schema.validate();
725 assert_eq!(errors.len(), 1);
726 assert!(errors[0].contains("tags"));
727 assert!(errors[0].contains("elementType"));
728 }
729
730 #[test]
731 fn validate_accepts_array_column_with_element_type_set() {
732 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
733 use crate::model::column_type::ColumnType as CT;
734
735 let table = TableBuilder::new(Some("s"), "widget")
736 .add_column(
737 ColumnBuilder::new(Some("s"), "tags", CT::Array)
738 .element_type(Some("varchar".to_string()))
739 .build(),
740 )
741 .build();
742 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
743
744 assert!(schema.validate().is_empty());
745 }
746
747 #[test]
748 fn validate_reports_error_for_array_column_with_unparseable_element_type() {
749 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
753 use crate::model::column_type::ColumnType as CT;
754
755 let table = TableBuilder::new(Some("s"), "widget")
756 .add_column(
757 ColumnBuilder::new(Some("s"), "tags", CT::Array)
758 .element_type(Some("not_a_real_type".to_string()))
759 .build(),
760 )
761 .build();
762 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
763
764 let errors = schema.validate();
765 assert_eq!(errors.len(), 1);
766 assert!(errors[0].contains("tags"));
767 assert!(errors[0].contains("not_a_real_type"));
768 }
769
770 #[test]
771 fn validate_reports_error_for_enum_column_with_no_enum_type() {
772 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
776 use crate::model::column_type::ColumnType as CT;
777
778 let table = TableBuilder::new(Some("s"), "widget")
779 .add_column(ColumnBuilder::new(Some("s"), "status", CT::Enum).build())
780 .build();
781 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
782
783 let errors = schema.validate();
784 assert_eq!(errors.len(), 1);
785 assert!(errors[0].contains("status"));
786 assert!(errors[0].contains("enumType"));
787 }
788
789 #[test]
790 fn validate_reports_error_for_unrecognized_boolean_default() {
791 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
792 use crate::model::column_type::ColumnType as CT;
793
794 let table = TableBuilder::new(Some("s"), "widget")
795 .add_column(
796 ColumnBuilder::new(Some("s"), "active", CT::Boolean)
797 .default_constraint(Some("maybe".to_string()))
798 .build(),
799 )
800 .build();
801 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
802
803 let errors = schema.validate();
804 assert_eq!(errors.len(), 1);
805 assert!(errors[0].contains("active"));
806 assert!(errors[0].contains("maybe"));
807 }
808
809 #[test]
810 fn validate_accepts_recognized_boolean_default_spellings() {
811 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
812 use crate::model::column_type::ColumnType as CT;
813
814 for value in ["true", "1", "yes", "on", "false", "0", "no", "off", "null"] {
815 let table = TableBuilder::new(Some("s"), "widget")
816 .add_column(
817 ColumnBuilder::new(Some("s"), "active", CT::Boolean)
818 .default_constraint(Some(value.to_string()))
819 .build(),
820 )
821 .build();
822 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
823
824 assert!(schema.validate().is_empty(), "value: {:?}", value);
825 }
826 }
827
828 #[test]
829 fn validate_accepts_boolean_column_with_no_default() {
830 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
831 use crate::model::column_type::ColumnType as CT;
832
833 let table = TableBuilder::new(Some("s"), "widget")
834 .add_column(ColumnBuilder::new(Some("s"), "active", CT::Boolean).build())
835 .build();
836 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
837
838 assert!(schema.validate().is_empty());
839 }
840
841 #[test]
842 fn validate_reports_error_for_varchar_column_with_no_length() {
843 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
844 use crate::model::column_type::ColumnType as CT;
845
846 let table = TableBuilder::new(Some("s"), "widget")
847 .add_column(ColumnBuilder::new(Some("s"), "name", CT::Varchar).build())
848 .build();
849 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
850
851 let errors = schema.validate();
852 assert_eq!(errors.len(), 1);
853 assert!(errors[0].contains("name"));
854 assert!(errors[0].contains("length"));
855 }
856
857 #[test]
858 fn validate_reports_error_for_char_column_with_zero_length() {
859 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
860 use crate::model::column_type::ColumnType as CT;
861
862 let table = TableBuilder::new(Some("s"), "widget")
863 .add_column(
864 ColumnBuilder::new(Some("s"), "code", CT::Char)
865 .length(0)
866 .build(),
867 )
868 .build();
869 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
870
871 let errors = schema.validate();
872 assert_eq!(errors.len(), 1);
873 assert!(errors[0].contains("code"));
874 }
875
876 #[test]
877 fn validate_accepts_char_and_varchar_columns_with_positive_length() {
878 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
879 use crate::model::column_type::ColumnType as CT;
880
881 let table = TableBuilder::new(Some("s"), "widget")
882 .add_column(
883 ColumnBuilder::new(Some("s"), "code", CT::Char)
884 .length(1)
885 .build(),
886 )
887 .add_column(
888 ColumnBuilder::new(Some("s"), "name", CT::Varchar)
889 .length(100)
890 .build(),
891 )
892 .build();
893 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
894
895 assert!(schema.validate().is_empty());
896 }
897
898 #[test]
899 fn validate_accepts_column_referencing_a_declared_enum_type_case_insensitively() {
900 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
901 use crate::model::column_type::ColumnType as CT;
902 use crate::model::enum_type::EnumType;
903
904 let table = TableBuilder::new(Some("s"), "widget")
905 .add_column(
906 ColumnBuilder::new(Some("s"), "status", CT::Enum)
907 .enum_type(Some("statustype".to_string()))
908 .build(),
909 )
910 .build();
911 let schema = SchemaBuilder::new(Some("s"))
912 .add_table(table)
913 .add_enum_type(EnumType::new("StatusType", Vec::new()))
914 .build();
915
916 assert!(schema.validate().is_empty());
917 }
918
919 }