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 column.column_type() == crate::model::column_type::ColumnType::Decimal {
321 if column.length() <= 0 {
322 errors.push(format!(
323 "ERROR: {}.{} is a decimal column with no length (or length <= 0); \
324 length is the precision and must be greater than zero",
325 table.name(),
326 column.name()
327 ));
328 } else if column.scale() > column.length() {
329 errors.push(format!(
330 "ERROR: {}.{} is a decimal column with scale {} greater than its \
331 length (precision) {}",
332 table.name(),
333 column.name(),
334 column.scale(),
335 column.length()
336 ));
337 }
338 }
339
340 if matches!(
341 column.column_type(),
342 crate::model::column_type::ColumnType::Char
343 | crate::model::column_type::ColumnType::Varchar
344 ) && column.length() <= 0
345 {
346 errors.push(format!(
347 "ERROR: {}.{} is a {:?} column with no length (or length <= 0); \
348 a length attribute greater than zero is required",
349 table.name(),
350 column.name(),
351 column.column_type()
352 ));
353 }
354 }
355 }
356 errors
357 }
358
359 pub(crate) fn add_table(&mut self, table: Table) {
360 let idx = self.tables.len();
361 self.table_map.insert(table.name().to_lowercase(), idx);
362 self.tables.push(table);
363 }
364
365 pub fn sort_tables_by_name(&mut self) {
368 self.tables.sort_by(|a, b| a.name().cmp(b.name()));
369
370 self.table_map.clear();
371 for (idx, table) in self.tables.iter().enumerate() {
372 self.table_map.insert(table.name().to_lowercase(), idx);
373 }
374 }
375
376 pub(crate) fn add_view(&mut self, view: View) {
377 self.views.push(view);
378 }
379
380 pub(crate) fn add_enum_type(&mut self, enum_type: EnumType) {
381 self.enum_types
382 .insert(enum_type.name().to_lowercase(), enum_type);
383 }
384
385 pub(crate) fn add_functions(&mut self, functions: Vec<Function>) {
386 self.functions.extend(functions);
387 }
388
389 pub(crate) fn add_procedures(&mut self, procedures: Vec<Procedure>) {
390 self.procedures.extend(procedures);
391 }
392
393 pub(crate) fn add_other_sql(&mut self, other_sql: OtherSql) {
394 self.other_sql.push(other_sql);
395 }
396}
397
398fn is_full_generated_clause(generated: &str) -> bool {
402 let lower = generated.trim_start().to_ascii_lowercase();
403 match lower.strip_prefix("generated") {
404 Some(rest) if rest.starts_with(char::is_whitespace) => rest
405 .split_whitespace()
406 .next()
407 .is_some_and(|word| word == "always" || word == "by" || word.starts_with("as")),
408 _ => false,
409 }
410}
411
412#[cfg(test)]
413mod tests {
414 use super::*;
415 use crate::model::column::Column;
416 use crate::model::column_type::ColumnType;
417 use crate::model::relation::Relation;
418
419 fn make_schema() -> Schema {
420 Schema::new(Some("schema"))
421 }
422
423 #[test]
424 fn add_and_get_table_and_sort() {
425 let mut schema = make_schema();
426 let table1 = Table::new(
427 Some("schema"),
428 "Table1",
429 Option::<&str>::None,
430 crate::model::types::LockEscalation::Auto,
431 false,
432 vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
433 Vec::new(),
434 Vec::new(),
435 Vec::new(),
436 Vec::new(),
437 Vec::new(),
438 Vec::new(),
439 Vec::new(),
440 Vec::new(),
441 );
442 let table2 = Table::new(
443 Some("schema"),
444 "Table2",
445 Option::<&str>::None,
446 crate::model::types::LockEscalation::Auto,
447 false,
448 Vec::new(),
449 Vec::new(),
450 Vec::new(),
451 Vec::new(),
452 Vec::new(),
453 Vec::new(),
454 Vec::new(),
455 Vec::new(),
456 Vec::new(),
457 );
458 schema.add_table(table1);
459 schema.add_table(table2);
460 assert_eq!(schema.get_table("Table2").name(), "Table2"); let names: Vec<_> = schema.tables().iter().map(|t| t.name()).collect();
462 assert_eq!(names, vec!["Table1", "Table2"]);
463 assert_eq!(schema.get_table("Table1").name(), "Table1");
465 }
466
467 #[test]
468 fn get_enum_type_is_case_insensitive() {
469 let mut schema = make_schema();
473 schema.add_enum_type(EnumType::new("GenderType", Vec::new()));
474
475 assert_eq!(schema.get_enum_type("GenderType").name(), "GenderType");
476 assert_eq!(schema.get_enum_type("gendertype").name(), "GenderType");
477 assert_eq!(schema.get_enum_type("GENDERTYPE").name(), "GenderType");
478 }
479
480 #[test]
481 fn views_filtered_by_database_type() {
482 let mut s = make_schema();
483 s.add_view(View::new(
484 Some("s"),
485 "v1",
486 "sql1",
487 Some(DatabaseType::Postgresql),
488 ));
489 s.add_view(View::new(
490 Some("s"),
491 "v2",
492 "sql2",
493 Some(DatabaseType::SqlServer),
494 ));
495 let pg = s.views(DatabaseType::Postgresql);
496 assert_eq!(pg.len(), 1);
497 assert_eq!(pg[0].name(), "v1");
498 }
499
500 #[test]
501 fn validate_setnull_error_when_required() {
502 let mut s = make_schema();
503 let parent = Table::new(
504 Some("s"),
505 "parent",
506 Option::<&str>::None,
507 crate::model::types::LockEscalation::Auto,
508 false,
509 vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
510 Vec::new(),
511 Vec::new(),
512 Vec::new(),
513 Vec::new(),
514 Vec::new(),
515 Vec::new(),
516 Vec::new(),
517 Vec::new(),
518 );
519 s.add_table(parent);
520
521 let child = Table::new(
522 Some("s"),
523 "child",
524 Option::<&str>::None,
525 crate::model::types::LockEscalation::Auto,
526 false,
527 vec![Column::new(Some("s"), "pid", ColumnType::Int, 0, 0, true)],
528 Vec::new(),
529 Vec::new(),
530 vec![Relation::new(
531 "parent",
532 "id",
533 "child",
534 "pid",
535 RelationType::SetNull,
536 false,
537 )],
538 Vec::new(),
539 Vec::new(),
540 Vec::new(),
541 Vec::new(),
542 Vec::new(),
543 );
544 s.add_table(child);
545
546 let errors = s.validate();
547 assert_eq!(errors.len(), 1);
548 assert!(errors[0].contains("setnull"));
549 }
550
551 #[test]
552 fn validate_reports_error_instead_of_panicking_when_from_column_is_missing() {
553 let mut s = make_schema();
556 let parent = Table::new(
557 Some("s"),
558 "parent",
559 Option::<&str>::None,
560 crate::model::types::LockEscalation::Auto,
561 false,
562 vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
563 Vec::new(),
564 Vec::new(),
565 Vec::new(),
566 Vec::new(),
567 Vec::new(),
568 Vec::new(),
569 Vec::new(),
570 Vec::new(),
571 );
572 s.add_table(parent);
573
574 let child = Table::new(
575 Some("s"),
576 "child",
577 Option::<&str>::None,
578 crate::model::types::LockEscalation::Auto,
579 false,
580 vec![Column::new(Some("s"), "pid", ColumnType::Int, 0, 0, true)],
581 Vec::new(),
582 Vec::new(),
583 vec![Relation::new(
584 "parent",
585 "id",
586 "child",
587 "does_not_exist",
588 RelationType::SetNull,
589 false,
590 )],
591 Vec::new(),
592 Vec::new(),
593 Vec::new(),
594 Vec::new(),
595 Vec::new(),
596 );
597 s.add_table(child);
598
599 let errors = s.validate();
600 assert_eq!(errors.len(), 1);
601 assert!(errors[0].contains("does_not_exist"));
602 }
603
604 #[test]
605 fn validate_reports_error_for_duplicate_table_names() {
606 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
612 use crate::model::column_type::ColumnType as CT;
613
614 let make_table = |name: &str| {
615 TableBuilder::new(Some("s"), name)
616 .add_column(
617 ColumnBuilder::new(Some("s"), "id", CT::Sequence)
618 .required(true)
619 .build(),
620 )
621 .build()
622 };
623
624 let schema = SchemaBuilder::new(Some("s"))
625 .add_table(make_table("Users"))
626 .add_table(make_table("users"))
627 .build();
628
629 let errors = schema.validate();
630 assert_eq!(errors.len(), 1);
631 assert!(errors[0].contains("duplicate table name"));
632 assert!(errors[0].contains("users"));
633 }
634
635 #[test]
636 fn validate_reports_error_for_duplicate_column_names() {
637 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
638 use crate::model::column_type::ColumnType as CT;
639
640 let table = TableBuilder::new(None::<&str>, "t")
641 .add_column(ColumnBuilder::new(None::<&str>, "Name", CT::Int).build())
642 .add_column(ColumnBuilder::new(None::<&str>, "name", CT::Int).build())
643 .build();
644 let errors = SchemaBuilder::new(None::<&str>)
645 .add_table(table)
646 .build()
647 .validate();
648
649 assert_eq!(errors.len(), 1);
650 assert!(errors[0].contains("duplicate column name 'name'"));
651 }
652
653 #[test]
654 fn validate_reports_error_for_key_and_index_columns_that_do_not_exist() {
655 use crate::builder::{ColumnBuilder, KeyBuilder, SchemaBuilder, TableBuilder};
656 use crate::model::column_type::ColumnType as CT;
657 use crate::model::types::KeyType;
658
659 let table = TableBuilder::new(None::<&str>, "t")
660 .add_column(
661 ColumnBuilder::new(None::<&str>, "id", CT::Int)
662 .required(true)
663 .build(),
664 )
665 .add_key(KeyBuilder::new(KeyType::Primary).add_column("Idd").build())
666 .add_index(
667 KeyBuilder::new(KeyType::Index)
668 .add_column("ID")
669 .add_column("nope")
670 .build(),
671 )
672 .build();
673 let errors = SchemaBuilder::new(None::<&str>)
674 .add_table(table)
675 .build()
676 .validate();
677
678 assert_eq!(errors.len(), 2);
679 assert!(errors[0].contains("'Idd'"));
680 assert!(errors[1].contains("'nope'"));
681 }
682
683 #[test]
684 fn validate_reports_missing_from_column_for_non_setnull_relations() {
685 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
687 use crate::model::column_type::ColumnType as CT;
688
689 let table = TableBuilder::new(None::<&str>, "t")
690 .add_column(ColumnBuilder::new(None::<&str>, "id", CT::Int).build())
691 .add_relation(Relation::new(
692 "p",
693 "id",
694 "t",
695 "missing",
696 RelationType::Cascade,
697 false,
698 ))
699 .build();
700 let errors = SchemaBuilder::new(None::<&str>)
701 .add_table(table)
702 .build()
703 .validate();
704
705 assert_eq!(errors.len(), 1);
706 assert!(errors[0].contains("t.missing does not exist"));
707 }
708
709 #[test]
710 fn validate_reports_error_for_table_with_no_columns() {
711 use crate::builder::{SchemaBuilder, TableBuilder};
714
715 let table = TableBuilder::new(Some("s"), "widget").build();
716 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
717
718 let errors = schema.validate();
719 assert_eq!(errors.len(), 1);
720 assert!(errors[0].contains("widget"));
721 assert!(errors[0].contains("no columns"));
722 }
723
724 #[test]
725 fn validate_reports_error_for_table_with_multiple_identity_columns() {
726 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
730 use crate::model::column_type::ColumnType as CT;
731
732 let table = TableBuilder::new(Some("s"), "widget")
733 .add_column(
734 ColumnBuilder::new(Some("s"), "id", CT::Sequence)
735 .required(true)
736 .build(),
737 )
738 .add_column(ColumnBuilder::new(Some("s"), "big_id", CT::LongSequence).build())
739 .build();
740 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
741
742 let errors = schema.validate();
743 assert_eq!(errors.len(), 1);
744 assert!(errors[0].contains("widget"));
745 assert!(errors[0].contains("id"));
746 assert!(errors[0].contains("big_id"));
747 }
748
749 #[test]
750 fn validate_rejects_generated_column_with_full_clause_or_default() {
751 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
752 use crate::model::column_type::ColumnType as CT;
753
754 let table = TableBuilder::new(Some("s"), "widget")
755 .add_column(
756 ColumnBuilder::new(Some("s"), "a", CT::Int)
757 .generated(Some("generated always as (1) stored".to_string()))
758 .build(),
759 )
760 .add_column(
761 ColumnBuilder::new(Some("s"), "b", CT::Int)
762 .generated(Some("1".to_string()))
763 .default_constraint(Some("2".to_string()))
764 .build(),
765 )
766 .build();
767 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
768 let errors = schema.validate();
769 assert_eq!(errors.len(), 2, "{errors:?}");
770 }
771
772 #[test]
773 fn validate_accepts_generated_expression_that_merely_starts_with_generated() {
774 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
775 use crate::model::column_type::ColumnType as CT;
776
777 let table = TableBuilder::new(Some("s"), "widget")
778 .add_column(
779 ColumnBuilder::new(Some("s"), "a", CT::Int)
780 .generated(Some("generated_total * 2".to_string()))
781 .build(),
782 )
783 .build();
784 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
785
786 assert!(schema.validate().is_empty());
787 }
788
789 #[test]
790 fn validate_accepts_table_with_a_single_identity_column() {
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"), "id", CT::Sequence)
797 .required(true)
798 .build(),
799 )
800 .build();
801 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
802
803 assert!(schema.validate().is_empty());
804 }
805
806 #[test]
807 fn validate_reports_error_for_array_column_missing_element_type() {
808 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
809 use crate::model::column_type::ColumnType as CT;
810
811 let table = TableBuilder::new(Some("s"), "widget")
812 .add_column(ColumnBuilder::new(Some("s"), "tags", CT::Array).build())
813 .build();
814 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
815
816 let errors = schema.validate();
817 assert_eq!(errors.len(), 1);
818 assert!(errors[0].contains("tags"));
819 assert!(errors[0].contains("elementType"));
820 }
821
822 #[test]
823 fn validate_accepts_array_column_with_element_type_set() {
824 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("varchar".to_string()))
831 .build(),
832 )
833 .build();
834 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
835
836 assert!(schema.validate().is_empty());
837 }
838
839 #[test]
840 fn validate_reports_error_for_array_column_with_unparseable_element_type() {
841 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
845 use crate::model::column_type::ColumnType as CT;
846
847 let table = TableBuilder::new(Some("s"), "widget")
848 .add_column(
849 ColumnBuilder::new(Some("s"), "tags", CT::Array)
850 .element_type(Some("not_a_real_type".to_string()))
851 .build(),
852 )
853 .build();
854 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
855
856 let errors = schema.validate();
857 assert_eq!(errors.len(), 1);
858 assert!(errors[0].contains("tags"));
859 assert!(errors[0].contains("not_a_real_type"));
860 }
861
862 #[test]
863 fn validate_reports_error_for_enum_column_with_no_enum_type() {
864 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
868 use crate::model::column_type::ColumnType as CT;
869
870 let table = TableBuilder::new(Some("s"), "widget")
871 .add_column(ColumnBuilder::new(Some("s"), "status", CT::Enum).build())
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("status"));
878 assert!(errors[0].contains("enumType"));
879 }
880
881 #[test]
882 fn validate_reports_error_for_unrecognized_boolean_default() {
883 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
884 use crate::model::column_type::ColumnType as CT;
885
886 let table = TableBuilder::new(Some("s"), "widget")
887 .add_column(
888 ColumnBuilder::new(Some("s"), "active", CT::Boolean)
889 .default_constraint(Some("maybe".to_string()))
890 .build(),
891 )
892 .build();
893 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
894
895 let errors = schema.validate();
896 assert_eq!(errors.len(), 1);
897 assert!(errors[0].contains("active"));
898 assert!(errors[0].contains("maybe"));
899 }
900
901 #[test]
902 fn validate_accepts_recognized_boolean_default_spellings() {
903 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
904 use crate::model::column_type::ColumnType as CT;
905
906 for value in ["true", "1", "yes", "on", "false", "0", "no", "off", "null"] {
907 let table = TableBuilder::new(Some("s"), "widget")
908 .add_column(
909 ColumnBuilder::new(Some("s"), "active", CT::Boolean)
910 .default_constraint(Some(value.to_string()))
911 .build(),
912 )
913 .build();
914 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
915
916 assert!(schema.validate().is_empty(), "value: {:?}", value);
917 }
918 }
919
920 #[test]
921 fn validate_accepts_boolean_column_with_no_default() {
922 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
923 use crate::model::column_type::ColumnType as CT;
924
925 let table = TableBuilder::new(Some("s"), "widget")
926 .add_column(ColumnBuilder::new(Some("s"), "active", CT::Boolean).build())
927 .build();
928 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
929
930 assert!(schema.validate().is_empty());
931 }
932
933 #[test]
934 fn validate_checks_decimal_precision_and_scale() {
935 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
936 use crate::model::column_type::ColumnType as CT;
937
938 let validate = |length: i32, scale: i32| {
939 let table = TableBuilder::new(Some("s"), "widget")
940 .add_column(
941 ColumnBuilder::new(Some("s"), "amount", CT::Decimal)
942 .length(length)
943 .scale(scale)
944 .build(),
945 )
946 .build();
947 SchemaBuilder::new(Some("s"))
948 .add_table(table)
949 .build()
950 .validate()
951 };
952
953 assert!(validate(10, 2).is_empty());
954 assert!(validate(10, 10).is_empty());
955 let errors = validate(0, 0);
956 assert_eq!(errors.len(), 1);
957 assert!(errors[0].contains("amount") && errors[0].contains("precision"));
958 let errors = validate(5, 6);
959 assert_eq!(errors.len(), 1);
960 assert!(errors[0].contains("scale 6"));
961 }
962
963 #[test]
964 fn validate_reports_error_for_varchar_column_with_no_length() {
965 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
966 use crate::model::column_type::ColumnType as CT;
967
968 let table = TableBuilder::new(Some("s"), "widget")
969 .add_column(ColumnBuilder::new(Some("s"), "name", CT::Varchar).build())
970 .build();
971 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
972
973 let errors = schema.validate();
974 assert_eq!(errors.len(), 1);
975 assert!(errors[0].contains("name"));
976 assert!(errors[0].contains("length"));
977 }
978
979 #[test]
980 fn validate_reports_error_for_char_column_with_zero_length() {
981 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
982 use crate::model::column_type::ColumnType as CT;
983
984 let table = TableBuilder::new(Some("s"), "widget")
985 .add_column(
986 ColumnBuilder::new(Some("s"), "code", CT::Char)
987 .length(0)
988 .build(),
989 )
990 .build();
991 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
992
993 let errors = schema.validate();
994 assert_eq!(errors.len(), 1);
995 assert!(errors[0].contains("code"));
996 }
997
998 #[test]
999 fn validate_accepts_char_and_varchar_columns_with_positive_length() {
1000 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
1001 use crate::model::column_type::ColumnType as CT;
1002
1003 let table = TableBuilder::new(Some("s"), "widget")
1004 .add_column(
1005 ColumnBuilder::new(Some("s"), "code", CT::Char)
1006 .length(1)
1007 .build(),
1008 )
1009 .add_column(
1010 ColumnBuilder::new(Some("s"), "name", CT::Varchar)
1011 .length(100)
1012 .build(),
1013 )
1014 .build();
1015 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
1016
1017 assert!(schema.validate().is_empty());
1018 }
1019
1020 #[test]
1021 fn validate_accepts_column_referencing_a_declared_enum_type_case_insensitively() {
1022 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
1023 use crate::model::column_type::ColumnType as CT;
1024 use crate::model::enum_type::EnumType;
1025
1026 let table = TableBuilder::new(Some("s"), "widget")
1027 .add_column(
1028 ColumnBuilder::new(Some("s"), "status", CT::Enum)
1029 .enum_type(Some("statustype".to_string()))
1030 .build(),
1031 )
1032 .build();
1033 let schema = SchemaBuilder::new(Some("s"))
1034 .add_table(table)
1035 .add_enum_type(EnumType::new("StatusType", Vec::new()))
1036 .build();
1037
1038 assert!(schema.validate().is_empty());
1039 }
1040
1041 }