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 is_full_generated_clause(generated) {
199 errors.push(format!(
200 "ERROR: {}.{} has generated='{}'; `generated` must be the bare \
201 expression (e.g. \"price * qty\"), not a full clause",
202 table.name(),
203 column.name(),
204 generated
205 ));
206 }
207 if column.default_constraint().is_some() {
208 errors.push(format!(
209 "ERROR: {}.{} is a generated column and cannot also have a default",
210 table.name(),
211 column.name()
212 ));
213 }
214 }
215 if seen_column_names
216 .insert(column.name().to_lowercase(), column.name())
217 .is_some()
218 {
219 errors.push(format!(
220 "ERROR: table {} has duplicate column name '{}'; column names must be unique \
221 within a table (comparison is case-insensitive)",
222 table.name(),
223 column.name()
224 ));
225 }
226 }
227
228 let key_kinds = [("key", table.keys()), ("index", table.indexes())];
229 for (kind, keys) in key_kinds {
230 for key in keys {
231 for key_column in key.columns() {
232 if !table.has_column(key_column.name()) {
233 errors.push(format!(
234 "ERROR: table {} has a {} on column '{}', which does not exist",
235 table.name(),
236 kind,
237 key_column.name()
238 ));
239 }
240 }
241 }
242 }
243
244 for relation in table.relations() {
245 for (from_column_name, to_column_name) in relation.column_pairs() {
246 if !table.has_column(from_column_name) {
247 errors.push(format!(
248 "ERROR: {}.{} does not exist. The {}.{} relation refers to it as the source column",
249 table.name(),
250 from_column_name,
251 relation.to_table_name(),
252 to_column_name
253 ));
254 } else if relation.relation_type() == RelationType::SetNull
255 && table.column(from_column_name).is_required()
256 {
257 errors.push(format!(
258 "ERROR: {}.{} is required. The {}.{} relation specifies setnull, which is not allowed",
259 table.name(),
260 from_column_name,
261 relation.to_table_name(),
262 to_column_name
263 ));
264 }
265 }
266 }
267
268 for column in table.columns() {
269 if column.column_type() == crate::model::column_type::ColumnType::Enum
273 && column.enum_type().is_none()
274 {
275 errors.push(format!(
276 "ERROR: {}.{} is an enum column but has no enumType",
277 table.name(),
278 column.name()
279 ));
280 }
281
282 if column.column_type() == crate::model::column_type::ColumnType::Array {
283 match column.element_type() {
284 None => {
285 errors.push(format!(
286 "ERROR: {}.{} is an array column but has no elementType",
287 table.name(),
288 column.name()
289 ));
290 }
291 Some(element_type_name) => {
292 if let Err(e) = crate::model::column_type::ColumnType::from_type_name(
293 element_type_name,
294 ) {
295 errors.push(format!(
296 "ERROR: {}.{} is an array column with an invalid elementType '{}': {}",
297 table.name(),
298 column.name(),
299 element_type_name,
300 e
301 ));
302 }
303 }
304 }
305 }
306
307 if column.column_type() == crate::model::column_type::ColumnType::Boolean
308 && let Some(default_constraint) = column.default_constraint()
309 && crate::model::column::parse_boolean_default(default_constraint).is_err()
310 {
311 errors.push(format!(
312 "ERROR: {}.{} has default '{}', which is not a recognized boolean value \
313 (expected true/false, 1/0, yes/no, on/off, or 'null' for no default)",
314 table.name(),
315 column.name(),
316 default_constraint
317 ));
318 }
319
320 if matches!(
321 column.column_type(),
322 crate::model::column_type::ColumnType::Char
323 | crate::model::column_type::ColumnType::Varchar
324 ) && column.length() <= 0
325 {
326 errors.push(format!(
327 "ERROR: {}.{} is a {:?} column with no length (or length <= 0); \
328 a length attribute greater than zero is required",
329 table.name(),
330 column.name(),
331 column.column_type()
332 ));
333 }
334 }
335 }
336 errors
337 }
338
339 pub(crate) fn add_table(&mut self, table: Table) {
340 let idx = self.tables.len();
341 self.table_map.insert(table.name().to_lowercase(), idx);
342 self.tables.push(table);
343 }
344
345 pub fn sort_tables_by_name(&mut self) {
348 self.tables.sort_by(|a, b| a.name().cmp(b.name()));
349
350 self.table_map.clear();
351 for (idx, table) in self.tables.iter().enumerate() {
352 self.table_map.insert(table.name().to_lowercase(), idx);
353 }
354 }
355
356 pub(crate) fn add_view(&mut self, view: View) {
357 self.views.push(view);
358 }
359
360 pub(crate) fn add_enum_type(&mut self, enum_type: EnumType) {
361 self.enum_types
362 .insert(enum_type.name().to_lowercase(), enum_type);
363 }
364
365 pub(crate) fn add_functions(&mut self, functions: Vec<Function>) {
366 self.functions.extend(functions);
367 }
368
369 pub(crate) fn add_procedures(&mut self, procedures: Vec<Procedure>) {
370 self.procedures.extend(procedures);
371 }
372
373 pub(crate) fn add_other_sql(&mut self, other_sql: OtherSql) {
374 self.other_sql.push(other_sql);
375 }
376}
377
378fn is_full_generated_clause(generated: &str) -> bool {
382 let lower = generated.trim_start().to_ascii_lowercase();
383 match lower.strip_prefix("generated") {
384 Some(rest) if rest.starts_with(char::is_whitespace) => rest
385 .split_whitespace()
386 .next()
387 .is_some_and(|word| word == "always" || word == "by" || word.starts_with("as")),
388 _ => false,
389 }
390}
391
392#[cfg(test)]
393mod tests {
394 use super::*;
395 use crate::model::column::Column;
396 use crate::model::column_type::ColumnType;
397 use crate::model::relation::Relation;
398
399 fn make_schema() -> Schema {
400 Schema::new(Some("schema"))
401 }
402
403 #[test]
404 fn add_and_get_table_and_sort() {
405 let mut schema = make_schema();
406 let table1 = Table::new(
407 Some("schema"),
408 "Table1",
409 Option::<&str>::None,
410 crate::model::types::LockEscalation::Auto,
411 false,
412 vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
413 Vec::new(),
414 Vec::new(),
415 Vec::new(),
416 Vec::new(),
417 Vec::new(),
418 Vec::new(),
419 Vec::new(),
420 Vec::new(),
421 );
422 let table2 = Table::new(
423 Some("schema"),
424 "Table2",
425 Option::<&str>::None,
426 crate::model::types::LockEscalation::Auto,
427 false,
428 Vec::new(),
429 Vec::new(),
430 Vec::new(),
431 Vec::new(),
432 Vec::new(),
433 Vec::new(),
434 Vec::new(),
435 Vec::new(),
436 Vec::new(),
437 );
438 schema.add_table(table1);
439 schema.add_table(table2);
440 assert_eq!(schema.get_table("Table2").name(), "Table2"); let names: Vec<_> = schema.tables().iter().map(|t| t.name()).collect();
442 assert_eq!(names, vec!["Table1", "Table2"]);
443 assert_eq!(schema.get_table("Table1").name(), "Table1");
445 }
446
447 #[test]
448 fn get_enum_type_is_case_insensitive() {
449 let mut schema = make_schema();
453 schema.add_enum_type(EnumType::new("GenderType", Vec::new()));
454
455 assert_eq!(schema.get_enum_type("GenderType").name(), "GenderType");
456 assert_eq!(schema.get_enum_type("gendertype").name(), "GenderType");
457 assert_eq!(schema.get_enum_type("GENDERTYPE").name(), "GenderType");
458 }
459
460 #[test]
461 fn views_filtered_by_database_type() {
462 let mut s = make_schema();
463 s.add_view(View::new(
464 Some("s"),
465 "v1",
466 "sql1",
467 Some(DatabaseType::Postgresql),
468 ));
469 s.add_view(View::new(
470 Some("s"),
471 "v2",
472 "sql2",
473 Some(DatabaseType::SqlServer),
474 ));
475 let pg = s.views(DatabaseType::Postgresql);
476 assert_eq!(pg.len(), 1);
477 assert_eq!(pg[0].name(), "v1");
478 }
479
480 #[test]
481 fn validate_setnull_error_when_required() {
482 let mut s = make_schema();
483 let parent = Table::new(
484 Some("s"),
485 "parent",
486 Option::<&str>::None,
487 crate::model::types::LockEscalation::Auto,
488 false,
489 vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
490 Vec::new(),
491 Vec::new(),
492 Vec::new(),
493 Vec::new(),
494 Vec::new(),
495 Vec::new(),
496 Vec::new(),
497 Vec::new(),
498 );
499 s.add_table(parent);
500
501 let child = Table::new(
502 Some("s"),
503 "child",
504 Option::<&str>::None,
505 crate::model::types::LockEscalation::Auto,
506 false,
507 vec![Column::new(Some("s"), "pid", ColumnType::Int, 0, 0, true)],
508 Vec::new(),
509 Vec::new(),
510 vec![Relation::new(
511 "parent",
512 "id",
513 "child",
514 "pid",
515 RelationType::SetNull,
516 false,
517 )],
518 Vec::new(),
519 Vec::new(),
520 Vec::new(),
521 Vec::new(),
522 Vec::new(),
523 );
524 s.add_table(child);
525
526 let errors = s.validate();
527 assert_eq!(errors.len(), 1);
528 assert!(errors[0].contains("setnull"));
529 }
530
531 #[test]
532 fn validate_reports_error_instead_of_panicking_when_from_column_is_missing() {
533 let mut s = make_schema();
536 let parent = Table::new(
537 Some("s"),
538 "parent",
539 Option::<&str>::None,
540 crate::model::types::LockEscalation::Auto,
541 false,
542 vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
543 Vec::new(),
544 Vec::new(),
545 Vec::new(),
546 Vec::new(),
547 Vec::new(),
548 Vec::new(),
549 Vec::new(),
550 Vec::new(),
551 );
552 s.add_table(parent);
553
554 let child = Table::new(
555 Some("s"),
556 "child",
557 Option::<&str>::None,
558 crate::model::types::LockEscalation::Auto,
559 false,
560 vec![Column::new(Some("s"), "pid", ColumnType::Int, 0, 0, true)],
561 Vec::new(),
562 Vec::new(),
563 vec![Relation::new(
564 "parent",
565 "id",
566 "child",
567 "does_not_exist",
568 RelationType::SetNull,
569 false,
570 )],
571 Vec::new(),
572 Vec::new(),
573 Vec::new(),
574 Vec::new(),
575 Vec::new(),
576 );
577 s.add_table(child);
578
579 let errors = s.validate();
580 assert_eq!(errors.len(), 1);
581 assert!(errors[0].contains("does_not_exist"));
582 }
583
584 #[test]
585 fn validate_reports_error_for_duplicate_table_names() {
586 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
592 use crate::model::column_type::ColumnType as CT;
593
594 let make_table = |name: &str| {
595 TableBuilder::new(Some("s"), name)
596 .add_column(
597 ColumnBuilder::new(Some("s"), "id", CT::Sequence)
598 .required(true)
599 .build(),
600 )
601 .build()
602 };
603
604 let schema = SchemaBuilder::new(Some("s"))
605 .add_table(make_table("Users"))
606 .add_table(make_table("users"))
607 .build();
608
609 let errors = schema.validate();
610 assert_eq!(errors.len(), 1);
611 assert!(errors[0].contains("duplicate table name"));
612 assert!(errors[0].contains("users"));
613 }
614
615 #[test]
616 fn validate_reports_error_for_duplicate_column_names() {
617 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
618 use crate::model::column_type::ColumnType as CT;
619
620 let table = TableBuilder::new(None::<&str>, "t")
621 .add_column(ColumnBuilder::new(None::<&str>, "Name", CT::Int).build())
622 .add_column(ColumnBuilder::new(None::<&str>, "name", CT::Int).build())
623 .build();
624 let errors = SchemaBuilder::new(None::<&str>)
625 .add_table(table)
626 .build()
627 .validate();
628
629 assert_eq!(errors.len(), 1);
630 assert!(errors[0].contains("duplicate column name 'name'"));
631 }
632
633 #[test]
634 fn validate_reports_error_for_key_and_index_columns_that_do_not_exist() {
635 use crate::builder::{ColumnBuilder, KeyBuilder, SchemaBuilder, TableBuilder};
636 use crate::model::column_type::ColumnType as CT;
637 use crate::model::types::KeyType;
638
639 let table = TableBuilder::new(None::<&str>, "t")
640 .add_column(
641 ColumnBuilder::new(None::<&str>, "id", CT::Int)
642 .required(true)
643 .build(),
644 )
645 .add_key(KeyBuilder::new(KeyType::Primary).add_column("Idd").build())
646 .add_index(
647 KeyBuilder::new(KeyType::Index)
648 .add_column("ID")
649 .add_column("nope")
650 .build(),
651 )
652 .build();
653 let errors = SchemaBuilder::new(None::<&str>)
654 .add_table(table)
655 .build()
656 .validate();
657
658 assert_eq!(errors.len(), 2);
659 assert!(errors[0].contains("'Idd'"));
660 assert!(errors[1].contains("'nope'"));
661 }
662
663 #[test]
664 fn validate_reports_missing_from_column_for_non_setnull_relations() {
665 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
667 use crate::model::column_type::ColumnType as CT;
668
669 let table = TableBuilder::new(None::<&str>, "t")
670 .add_column(ColumnBuilder::new(None::<&str>, "id", CT::Int).build())
671 .add_relation(Relation::new(
672 "p",
673 "id",
674 "t",
675 "missing",
676 RelationType::Cascade,
677 false,
678 ))
679 .build();
680 let errors = SchemaBuilder::new(None::<&str>)
681 .add_table(table)
682 .build()
683 .validate();
684
685 assert_eq!(errors.len(), 1);
686 assert!(errors[0].contains("t.missing does not exist"));
687 }
688
689 #[test]
690 fn validate_reports_error_for_table_with_no_columns() {
691 use crate::builder::{SchemaBuilder, TableBuilder};
694
695 let table = TableBuilder::new(Some("s"), "widget").build();
696 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
697
698 let errors = schema.validate();
699 assert_eq!(errors.len(), 1);
700 assert!(errors[0].contains("widget"));
701 assert!(errors[0].contains("no columns"));
702 }
703
704 #[test]
705 fn validate_reports_error_for_table_with_multiple_identity_columns() {
706 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
710 use crate::model::column_type::ColumnType as CT;
711
712 let table = TableBuilder::new(Some("s"), "widget")
713 .add_column(
714 ColumnBuilder::new(Some("s"), "id", CT::Sequence)
715 .required(true)
716 .build(),
717 )
718 .add_column(ColumnBuilder::new(Some("s"), "big_id", CT::LongSequence).build())
719 .build();
720 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
721
722 let errors = schema.validate();
723 assert_eq!(errors.len(), 1);
724 assert!(errors[0].contains("widget"));
725 assert!(errors[0].contains("id"));
726 assert!(errors[0].contains("big_id"));
727 }
728
729 #[test]
730 fn validate_rejects_generated_column_with_full_clause_or_default() {
731 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
732 use crate::model::column_type::ColumnType as CT;
733
734 let table = TableBuilder::new(Some("s"), "widget")
735 .add_column(
736 ColumnBuilder::new(Some("s"), "a", CT::Int)
737 .generated(Some("generated always as (1) stored".to_string()))
738 .build(),
739 )
740 .add_column(
741 ColumnBuilder::new(Some("s"), "b", CT::Int)
742 .generated(Some("1".to_string()))
743 .default_constraint(Some("2".to_string()))
744 .build(),
745 )
746 .build();
747 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
748 let errors = schema.validate();
749 assert_eq!(errors.len(), 2, "{errors:?}");
750 }
751
752 #[test]
753 fn validate_accepts_generated_expression_that_merely_starts_with_generated() {
754 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
755 use crate::model::column_type::ColumnType as CT;
756
757 let table = TableBuilder::new(Some("s"), "widget")
758 .add_column(
759 ColumnBuilder::new(Some("s"), "a", CT::Int)
760 .generated(Some("generated_total * 2".to_string()))
761 .build(),
762 )
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_table_with_a_single_identity_column() {
771 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
772 use crate::model::column_type::ColumnType as CT;
773
774 let table = TableBuilder::new(Some("s"), "widget")
775 .add_column(
776 ColumnBuilder::new(Some("s"), "id", CT::Sequence)
777 .required(true)
778 .build(),
779 )
780 .build();
781 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
782
783 assert!(schema.validate().is_empty());
784 }
785
786 #[test]
787 fn validate_reports_error_for_array_column_missing_element_type() {
788 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
789 use crate::model::column_type::ColumnType as CT;
790
791 let table = TableBuilder::new(Some("s"), "widget")
792 .add_column(ColumnBuilder::new(Some("s"), "tags", CT::Array).build())
793 .build();
794 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
795
796 let errors = schema.validate();
797 assert_eq!(errors.len(), 1);
798 assert!(errors[0].contains("tags"));
799 assert!(errors[0].contains("elementType"));
800 }
801
802 #[test]
803 fn validate_accepts_array_column_with_element_type_set() {
804 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
805 use crate::model::column_type::ColumnType as CT;
806
807 let table = TableBuilder::new(Some("s"), "widget")
808 .add_column(
809 ColumnBuilder::new(Some("s"), "tags", CT::Array)
810 .element_type(Some("varchar".to_string()))
811 .build(),
812 )
813 .build();
814 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
815
816 assert!(schema.validate().is_empty());
817 }
818
819 #[test]
820 fn validate_reports_error_for_array_column_with_unparseable_element_type() {
821 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
825 use crate::model::column_type::ColumnType as CT;
826
827 let table = TableBuilder::new(Some("s"), "widget")
828 .add_column(
829 ColumnBuilder::new(Some("s"), "tags", CT::Array)
830 .element_type(Some("not_a_real_type".to_string()))
831 .build(),
832 )
833 .build();
834 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
835
836 let errors = schema.validate();
837 assert_eq!(errors.len(), 1);
838 assert!(errors[0].contains("tags"));
839 assert!(errors[0].contains("not_a_real_type"));
840 }
841
842 #[test]
843 fn validate_reports_error_for_enum_column_with_no_enum_type() {
844 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
848 use crate::model::column_type::ColumnType as CT;
849
850 let table = TableBuilder::new(Some("s"), "widget")
851 .add_column(ColumnBuilder::new(Some("s"), "status", CT::Enum).build())
852 .build();
853 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
854
855 let errors = schema.validate();
856 assert_eq!(errors.len(), 1);
857 assert!(errors[0].contains("status"));
858 assert!(errors[0].contains("enumType"));
859 }
860
861 #[test]
862 fn validate_reports_error_for_unrecognized_boolean_default() {
863 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
864 use crate::model::column_type::ColumnType as CT;
865
866 let table = TableBuilder::new(Some("s"), "widget")
867 .add_column(
868 ColumnBuilder::new(Some("s"), "active", CT::Boolean)
869 .default_constraint(Some("maybe".to_string()))
870 .build(),
871 )
872 .build();
873 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
874
875 let errors = schema.validate();
876 assert_eq!(errors.len(), 1);
877 assert!(errors[0].contains("active"));
878 assert!(errors[0].contains("maybe"));
879 }
880
881 #[test]
882 fn validate_accepts_recognized_boolean_default_spellings() {
883 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
884 use crate::model::column_type::ColumnType as CT;
885
886 for value in ["true", "1", "yes", "on", "false", "0", "no", "off", "null"] {
887 let table = TableBuilder::new(Some("s"), "widget")
888 .add_column(
889 ColumnBuilder::new(Some("s"), "active", CT::Boolean)
890 .default_constraint(Some(value.to_string()))
891 .build(),
892 )
893 .build();
894 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
895
896 assert!(schema.validate().is_empty(), "value: {:?}", value);
897 }
898 }
899
900 #[test]
901 fn validate_accepts_boolean_column_with_no_default() {
902 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
903 use crate::model::column_type::ColumnType as CT;
904
905 let table = TableBuilder::new(Some("s"), "widget")
906 .add_column(ColumnBuilder::new(Some("s"), "active", CT::Boolean).build())
907 .build();
908 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
909
910 assert!(schema.validate().is_empty());
911 }
912
913 #[test]
914 fn validate_reports_error_for_varchar_column_with_no_length() {
915 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
916 use crate::model::column_type::ColumnType as CT;
917
918 let table = TableBuilder::new(Some("s"), "widget")
919 .add_column(ColumnBuilder::new(Some("s"), "name", CT::Varchar).build())
920 .build();
921 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
922
923 let errors = schema.validate();
924 assert_eq!(errors.len(), 1);
925 assert!(errors[0].contains("name"));
926 assert!(errors[0].contains("length"));
927 }
928
929 #[test]
930 fn validate_reports_error_for_char_column_with_zero_length() {
931 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
932 use crate::model::column_type::ColumnType as CT;
933
934 let table = TableBuilder::new(Some("s"), "widget")
935 .add_column(
936 ColumnBuilder::new(Some("s"), "code", CT::Char)
937 .length(0)
938 .build(),
939 )
940 .build();
941 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
942
943 let errors = schema.validate();
944 assert_eq!(errors.len(), 1);
945 assert!(errors[0].contains("code"));
946 }
947
948 #[test]
949 fn validate_accepts_char_and_varchar_columns_with_positive_length() {
950 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
951 use crate::model::column_type::ColumnType as CT;
952
953 let table = TableBuilder::new(Some("s"), "widget")
954 .add_column(
955 ColumnBuilder::new(Some("s"), "code", CT::Char)
956 .length(1)
957 .build(),
958 )
959 .add_column(
960 ColumnBuilder::new(Some("s"), "name", CT::Varchar)
961 .length(100)
962 .build(),
963 )
964 .build();
965 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
966
967 assert!(schema.validate().is_empty());
968 }
969
970 #[test]
971 fn validate_accepts_column_referencing_a_declared_enum_type_case_insensitively() {
972 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
973 use crate::model::column_type::ColumnType as CT;
974 use crate::model::enum_type::EnumType;
975
976 let table = TableBuilder::new(Some("s"), "widget")
977 .add_column(
978 ColumnBuilder::new(Some("s"), "status", CT::Enum)
979 .enum_type(Some("statustype".to_string()))
980 .build(),
981 )
982 .build();
983 let schema = SchemaBuilder::new(Some("s"))
984 .add_table(table)
985 .add_enum_type(EnumType::new("StatusType", Vec::new()))
986 .build();
987
988 assert!(schema.validate().is_empty());
989 }
990
991 }