Skip to main content

schema_model/model/
schema.rs

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    // Case-insensitive map: store lowercase name -> index in tables vec
20    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    /// Same as `get_table_mut`, but returns `None` instead of panicking when no table
75    /// with this name exists - useful for callers (e.g. the XML parser) resolving
76    /// possibly-malformed input, where a missing table should surface as an error
77    /// rather than crash.
78    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    /// Like `get_enum_type`, but returns `None` instead of panicking when this schema
120    /// declares no enum with that name.
121    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                // Whether `enumType` resolves is checked in `DatabaseModel::validate()`, not
252                // here: a column may legitimately reference a database-level `<enum>` that
253                // lives in the default schema (M5), which a single schema can't see.
254                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    /// Sorts the schema's tables alphabetically by name, in place. Must be called after all
328    /// tables have been added, since it rebuilds the name -> index lookup used by `get_table`.
329    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"); // case-insensitive
409        let names: Vec<_> = schema.tables().iter().map(|t| t.name()).collect();
410        assert_eq!(names, vec!["Table1", "Table2"]);
411        // table_map rebuilt so get_table still works
412        assert_eq!(schema.get_table("Table1").name(), "Table1");
413    }
414
415    #[test]
416    fn get_enum_type_is_case_insensitive() {
417        // Matches the case-insensitive lookup used everywhere else in the model
418        // (Table::column/has_column, Schema::get_table); a column declaring
419        // `enumType="gendertype"` must still resolve an enum declared as `GenderType`.
420        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        // A relation whose `src` attribute doesn't match any real column on the table
502        // (e.g. a typo in the XML) must surface as a validation error, not panic.
503        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        // Two tables with the same name (case-insensitive) collapse to a single entry in
555        // the lookup index (H22): the second silently wins, so relations to the first
556        // resolve against the wrong table and the generated SQL fails to create the
557        // second table. This must be caught up front rather than silently corrupting
558        // lookups.
559        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        // M11: the existence check used to run only inside the SetNull arm.
634        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        // A table with zero columns generates invalid `create table t (\n)` DDL; this
660        // must be caught up front rather than crash/emit invalid SQL during generation.
661        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        // SQL Server permits at most one `identity` column per table (Msg 2744); a table
675        // with both a Sequence and a LongSequence column must be rejected up front rather
676        // than silently emitting a second `identity(1,1)` that fails at execution time.
677        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        // `postgres_column_type_generator.rs::array_sql` panics on an `elementType` that
750        // doesn't name a real column type (H23); `validate()` only checked that
751        // `elementType` was *present*, not that it was meaningful.
752        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        // `<column type="enum"/>` with no `enumType` attribute previously passed
773        // `validate()` and panicked in every generator's `enum_sql()` via
774        // `column.enum_type().as_ref().unwrap()` (H23).
775        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    // #[test]
920    // fn build_reverse_relations_creates_back_refs() {
921    //     let mut s = make_schema();
922    //     let mut parent = Table::new(
923    //         Some("s"),
924    //         "p",
925    //         Option::<&str>::None,
926    //         crate::model::types::LockEscalation::Auto,
927    //         false,
928    //         vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
929    //         Vec::new(),
930    //         Vec::new(),
931    //         Vec::new(),
932    //         Vec::new(),
933    //         Vec::new(),
934    //         Vec::new(),
935    //         Vec::new(),
936    //         Vec::new(),
937    //     );
938    //     let mut child = Table::new(
939    //         Some("s"),
940    //         "c",
941    //         Option::<&str>::None,
942    //         crate::model::types::LockEscalation::Auto,
943    //         false,
944    //         vec![Column::new(Some("s"), "pid", ColumnType::Int, 0, 0, false)],
945    //         Vec::new(),
946    //         Vec::new(),
947    //         vec![Relation::new(
948    //             "p",
949    //             "id",
950    //             "c",
951    //             "pid",
952    //             RelationType::Cascade,
953    //             false,
954    //         )],
955    //         Vec::new(),
956    //         Vec::new(),
957    //         Vec::new(),
958    //         Vec::new(),
959    //         Vec::new(),
960    //     );
961    //     s.add_table(parent);
962    //     s.add_table(child);
963    //
964    //     s.build_reverse_relations();
965    //     let p_ref = s.get_table("p");
966    //     assert_eq!(p_ref.reverse_relations().len(), 1);
967    //     let rr = &p_ref.reverse_relations()[0];
968    //     assert_eq!(rr.from_table_name(), "c");
969    //     assert_eq!(rr.to_table_name(), "p");
970    // }
971}