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.table_map.get(&name_lower)
87            .unwrap_or_else(|| panic!("Unable to locate a table with the name '{}'", name))
88    }
89
90    pub fn get_optional_table(&self, name: &str) -> Option<&Table> {
91        let name_lower = name.to_lowercase();
92        self.table_map.get(&name_lower).map(|&idx| &self.tables[idx])
93    }
94
95    pub fn all_views(&self) -> &[View] {
96        &self.views
97    }
98
99    pub fn views(&self, database_type: DatabaseType) -> Vec<View> {
100        self.views
101            .iter()
102            .filter(|view| view.database_type().is_none() || view.database_type().unwrap() == database_type)
103            .cloned()
104            .collect()
105    }
106
107    pub fn enum_types(&self) -> impl Iterator<Item = &EnumType> {
108        let mut enum_types: Vec<&EnumType> = self.enum_types.values().collect();
109        enum_types.sort_by(|a, b| a.name().cmp(b.name()));
110        enum_types.into_iter()
111    }
112
113    pub fn get_enum_type(&self, type_name: &str) -> &EnumType {
114        self.enum_types
115            .get(&type_name.to_lowercase())
116            .unwrap_or_else(|| panic!("Unable to locate an enum type with the name '{}'", type_name))
117    }
118
119    pub fn functions(&self) -> &[Function] {
120        &self.functions
121    }
122
123    pub fn procedures(&self) -> &[Procedure] {
124        &self.procedures
125    }
126
127    pub fn other_sql(&self) -> &[OtherSql] {
128        &self.other_sql
129    }
130
131    pub fn validate(&self) -> Vec<String> {
132        let mut errors: Vec<String> = Vec::new();
133
134        let mut seen_table_names: HashMap<String, &str> = HashMap::new();
135        for table in &self.tables {
136            let name_lower = table.name().to_lowercase();
137            if seen_table_names.contains_key(&name_lower) {
138                errors.push(format!(
139                    "ERROR: duplicate table name '{}'; table names must be unique within a schema \
140                     (comparison is case-insensitive)",
141                    table.name()
142                ));
143            } else {
144                seen_table_names.insert(name_lower, table.name());
145            }
146        }
147
148        for table in &self.tables {
149            if table.columns().is_empty() {
150                errors.push(format!(
151                    "ERROR: table {} has no columns; generated `create table` SQL would be invalid",
152                    table.name()
153                ));
154            }
155
156            let identity_columns: Vec<&str> = table
157                .columns()
158                .iter()
159                .filter(|c| {
160                    matches!(
161                        c.column_type(),
162                        crate::model::column_type::ColumnType::Sequence
163                            | crate::model::column_type::ColumnType::LongSequence
164                    )
165                })
166                .map(|c| c.name())
167                .collect();
168            if identity_columns.len() > 1 {
169                errors.push(format!(
170                    "ERROR: table {} has more than one identity column ({}); \
171                     a table may have at most one sequence/longsequence column",
172                    table.name(),
173                    identity_columns.join(", ")
174                ));
175            }
176
177            for relation in table.relations() {
178                if relation.relation_type() == RelationType::SetNull {
179                    let from_column_name = relation.from_column_name();
180                    match table.has_column(from_column_name) {
181                        true if table.column(from_column_name).is_required() => {
182                            errors.push(format!(
183                                "ERROR: {}.{} is required. The {}.{} relation specifies setnull, which is not allowed",
184                                table.name(),
185                                from_column_name,
186                                relation.to_table_name(),
187                                relation.to_column_name()
188                            ));
189                        }
190                        true => {}
191                        false => {
192                            errors.push(format!(
193                                "ERROR: {}.{} does not exist. The {}.{} relation refers to it as the source column",
194                                table.name(),
195                                from_column_name,
196                                relation.to_table_name(),
197                                relation.to_column_name()
198                            ));
199                        }
200                    }
201                }
202            }
203
204            for column in table.columns() {
205                if let Some(enum_type_name) = column.enum_type()
206                    && !self.enum_types.contains_key(&enum_type_name.to_lowercase())
207                {
208                    errors.push(format!(
209                        "ERROR: {}.{} references enum type '{}' which is not defined in this schema",
210                        table.name(),
211                        column.name(),
212                        enum_type_name
213                    ));
214                }
215
216                if column.column_type() == crate::model::column_type::ColumnType::Enum && column.enum_type().is_none() {
217                    errors.push(format!(
218                        "ERROR: {}.{} is an enum column but has no enumType",
219                        table.name(),
220                        column.name()
221                    ));
222                }
223
224                if column.column_type() == crate::model::column_type::ColumnType::Array {
225                    match column.element_type() {
226                        None => {
227                            errors.push(format!(
228                                "ERROR: {}.{} is an array column but has no elementType",
229                                table.name(),
230                                column.name()
231                            ));
232                        }
233                        Some(element_type_name) => {
234                            if let Err(e) = crate::model::column_type::ColumnType::from_type_name(element_type_name) {
235                                errors.push(format!(
236                                    "ERROR: {}.{} is an array column with an invalid elementType '{}': {}",
237                                    table.name(),
238                                    column.name(),
239                                    element_type_name,
240                                    e
241                                ));
242                            }
243                        }
244                    }
245                }
246
247                if column.column_type() == crate::model::column_type::ColumnType::Boolean
248                    && let Some(default_constraint) = column.default_constraint()
249                    && crate::model::column::parse_boolean_default(default_constraint).is_err()
250                {
251                    errors.push(format!(
252                        "ERROR: {}.{} has default '{}', which is not a recognized boolean value \
253                         (expected true/false, 1/0, yes/no, on/off, or 'null' for no default)",
254                        table.name(),
255                        column.name(),
256                        default_constraint
257                    ));
258                }
259
260                if matches!(
261                    column.column_type(),
262                    crate::model::column_type::ColumnType::Char | crate::model::column_type::ColumnType::Varchar
263                ) && column.length() <= 0
264                {
265                    errors.push(format!(
266                        "ERROR: {}.{} is a {:?} column with no length (or length <= 0); \
267                         a length attribute greater than zero is required",
268                        table.name(),
269                        column.name(),
270                        column.column_type()
271                    ));
272                }
273            }
274        }
275        errors
276    }
277
278    pub(crate) fn add_table(&mut self, table: Table) {
279        let idx = self.tables.len();
280        self.table_map.insert(table.name().to_lowercase(), idx);
281        self.tables.push(table);
282    }
283
284    /// Sorts the schema's tables alphabetically by name, in place. Must be called after all
285    /// tables have been added, since it rebuilds the name -> index lookup used by `get_table`.
286    pub fn sort_tables_by_name(&mut self) {
287        self.tables.sort_by(|a, b| a.name().cmp(b.name()));
288
289        self.table_map.clear();
290        for (idx, table) in self.tables.iter().enumerate() {
291            self.table_map.insert(table.name().to_lowercase(), idx);
292        }
293    }
294
295    pub(crate) fn add_view(&mut self, view: View) {
296        self.views.push(view);
297    }
298
299    pub(crate) fn add_enum_type(&mut self, enum_type: EnumType) {
300        self.enum_types
301            .insert(enum_type.name().to_lowercase(), enum_type);
302    }
303
304    pub(crate) fn add_functions(&mut self, functions: Vec<Function>) {
305        self.functions.extend(functions);
306    }
307
308    pub(crate) fn add_procedures(&mut self, procedures: Vec<Procedure>) {
309        self.procedures.extend(procedures);
310    }
311
312    pub(crate) fn add_other_sql(&mut self, other_sql: OtherSql) {
313        self.other_sql.push(other_sql);
314    }
315}
316
317#[cfg(test)]
318mod tests {
319    use super::*;
320    use crate::model::column::Column;
321    use crate::model::column_type::ColumnType;
322    use crate::model::relation::Relation;
323
324    fn make_schema() -> Schema {
325        Schema::new(Some("schema"))
326    }
327
328    #[test]
329    fn add_and_get_table_and_sort() {
330        let mut schema = make_schema();
331        let table1 = Table::new(
332            Some("schema"),
333            "Table1",
334            Option::<&str>::None,
335            crate::model::types::LockEscalation::Auto,
336            false,
337            vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
338            Vec::new(),
339            Vec::new(),
340            Vec::new(),
341            Vec::new(),
342            Vec::new(),
343            Vec::new(),
344            Vec::new(),
345            Vec::new(),
346        );
347        let table2 = Table::new(
348            Some("schema"),
349            "Table2",
350            Option::<&str>::None,
351            crate::model::types::LockEscalation::Auto,
352            false,
353            Vec::new(),
354            Vec::new(),
355            Vec::new(),
356            Vec::new(),
357            Vec::new(),
358            Vec::new(),
359            Vec::new(),
360            Vec::new(),
361            Vec::new(),
362        );
363        schema.add_table(table1);
364        schema.add_table(table2);
365        assert_eq!(schema.get_table("Table2").name(), "Table2"); // case-insensitive
366        let names: Vec<_> = schema.tables().iter().map(|t| t.name()).collect();
367        assert_eq!(names, vec!["Table1", "Table2"]);
368        // table_map rebuilt so get_table still works
369        assert_eq!(schema.get_table("Table1").name(), "Table1");
370    }
371
372    #[test]
373    fn get_enum_type_is_case_insensitive() {
374        // Matches the case-insensitive lookup used everywhere else in the model
375        // (Table::column/has_column, Schema::get_table); a column declaring
376        // `enumType="gendertype"` must still resolve an enum declared as `GenderType`.
377        let mut schema = make_schema();
378        schema.add_enum_type(EnumType::new("GenderType", Vec::new()));
379
380        assert_eq!(schema.get_enum_type("GenderType").name(), "GenderType");
381        assert_eq!(schema.get_enum_type("gendertype").name(), "GenderType");
382        assert_eq!(schema.get_enum_type("GENDERTYPE").name(), "GenderType");
383    }
384
385    #[test]
386    fn views_filtered_by_database_type() {
387        let mut s = make_schema();
388        s.add_view(View::new(Some("s"), "v1", "sql1", Some(DatabaseType::Postgresql)));
389        s.add_view(View::new(Some("s"), "v2", "sql2", Some(DatabaseType::SqlServer)));
390        let pg = s.views(DatabaseType::Postgresql);
391        assert_eq!(pg.len(), 1);
392        assert_eq!(pg[0].name(), "v1");
393    }
394
395    #[test]
396    fn validate_setnull_error_when_required() {
397        let mut s = make_schema();
398        let parent = Table::new(
399            Some("s"),
400            "parent",
401            Option::<&str>::None,
402            crate::model::types::LockEscalation::Auto,
403            false,
404            vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
405            Vec::new(),
406            Vec::new(),
407            Vec::new(),
408            Vec::new(),
409            Vec::new(),
410            Vec::new(),
411            Vec::new(),
412            Vec::new(),
413        );
414        s.add_table(parent);
415
416        let child = Table::new(
417            Some("s"),
418            "child",
419            Option::<&str>::None,
420            crate::model::types::LockEscalation::Auto,
421            false,
422            vec![Column::new(Some("s"), "pid", ColumnType::Int, 0, 0, true)],
423            Vec::new(),
424            Vec::new(),
425            vec![Relation::new(
426                "parent",
427                "id",
428                "child",
429                "pid",
430                RelationType::SetNull,
431                false,
432            )],
433            Vec::new(),
434            Vec::new(),
435            Vec::new(),
436            Vec::new(),
437            Vec::new(),
438        );
439        s.add_table(child);
440
441        let errors = s.validate();
442        assert_eq!(errors.len(), 1);
443        assert!(errors[0].contains("setnull"));
444    }
445
446    #[test]
447    fn validate_reports_error_instead_of_panicking_when_from_column_is_missing() {
448        // A relation whose `src` attribute doesn't match any real column on the table
449        // (e.g. a typo in the XML) must surface as a validation error, not panic.
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                "does_not_exist",
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("does_not_exist"));
497    }
498
499    #[test]
500    fn validate_reports_error_for_column_referencing_an_undeclared_enum_type() {
501        // A column's `enumType` attribute referencing a name with no matching `<enum>`
502        // declaration must surface as a validation error - previously nothing caught
503        // this, and it panicked deep in SQL generation instead (`get_enum_type`).
504        use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
505        use crate::model::column_type::ColumnType as CT;
506
507        let table = TableBuilder::new(Some("s"), "widget")
508            .add_column(
509                ColumnBuilder::new(Some("s"), "status", CT::Enum)
510                    .enum_type(Some("StatusType".to_string()))
511                    .build(),
512            )
513            .build();
514        let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
515
516        let errors = schema.validate();
517        assert_eq!(errors.len(), 1);
518        assert!(errors[0].contains("StatusType"));
519    }
520
521    #[test]
522    fn validate_reports_error_for_duplicate_table_names() {
523        // Two tables with the same name (case-insensitive) collapse to a single entry in
524        // the lookup index (H22): the second silently wins, so relations to the first
525        // resolve against the wrong table and the generated SQL fails to create the
526        // second table. This must be caught up front rather than silently corrupting
527        // lookups.
528        use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
529        use crate::model::column_type::ColumnType as CT;
530
531        let make_table = |name: &str| {
532            TableBuilder::new(Some("s"), name)
533                .add_column(ColumnBuilder::new(Some("s"), "id", CT::Sequence).required(true).build())
534                .build()
535        };
536
537        let schema = SchemaBuilder::new(Some("s"))
538            .add_table(make_table("Users"))
539            .add_table(make_table("users"))
540            .build();
541
542        let errors = schema.validate();
543        assert_eq!(errors.len(), 1);
544        assert!(errors[0].contains("duplicate table name"));
545        assert!(errors[0].contains("users"));
546    }
547
548    #[test]
549    fn validate_reports_error_for_table_with_no_columns() {
550        // A table with zero columns generates invalid `create table t (\n)` DDL; this
551        // must be caught up front rather than crash/emit invalid SQL during generation.
552        use crate::builder::{SchemaBuilder, TableBuilder};
553
554        let table = TableBuilder::new(Some("s"), "widget").build();
555        let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
556
557        let errors = schema.validate();
558        assert_eq!(errors.len(), 1);
559        assert!(errors[0].contains("widget"));
560        assert!(errors[0].contains("no columns"));
561    }
562
563    #[test]
564    fn validate_reports_error_for_table_with_multiple_identity_columns() {
565        // SQL Server permits at most one `identity` column per table (Msg 2744); a table
566        // with both a Sequence and a LongSequence column must be rejected up front rather
567        // than silently emitting a second `identity(1,1)` that fails at execution time.
568        use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
569        use crate::model::column_type::ColumnType as CT;
570
571        let table = TableBuilder::new(Some("s"), "widget")
572            .add_column(ColumnBuilder::new(Some("s"), "id", CT::Sequence).required(true).build())
573            .add_column(ColumnBuilder::new(Some("s"), "big_id", CT::LongSequence).build())
574            .build();
575        let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
576
577        let errors = schema.validate();
578        assert_eq!(errors.len(), 1);
579        assert!(errors[0].contains("widget"));
580        assert!(errors[0].contains("id"));
581        assert!(errors[0].contains("big_id"));
582    }
583
584    #[test]
585    fn validate_accepts_table_with_a_single_identity_column() {
586        use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
587        use crate::model::column_type::ColumnType as CT;
588
589        let table = TableBuilder::new(Some("s"), "widget")
590            .add_column(ColumnBuilder::new(Some("s"), "id", CT::Sequence).required(true).build())
591            .build();
592        let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
593
594        assert!(schema.validate().is_empty());
595    }
596
597    #[test]
598    fn validate_reports_error_for_array_column_missing_element_type() {
599        use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
600        use crate::model::column_type::ColumnType as CT;
601
602        let table = TableBuilder::new(Some("s"), "widget")
603            .add_column(ColumnBuilder::new(Some("s"), "tags", CT::Array).build())
604            .build();
605        let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
606
607        let errors = schema.validate();
608        assert_eq!(errors.len(), 1);
609        assert!(errors[0].contains("tags"));
610        assert!(errors[0].contains("elementType"));
611    }
612
613    #[test]
614    fn validate_accepts_array_column_with_element_type_set() {
615        use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
616        use crate::model::column_type::ColumnType as CT;
617
618        let table = TableBuilder::new(Some("s"), "widget")
619            .add_column(
620                ColumnBuilder::new(Some("s"), "tags", CT::Array)
621                    .element_type(Some("varchar".to_string()))
622                    .build(),
623            )
624            .build();
625        let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
626
627        assert!(schema.validate().is_empty());
628    }
629
630    #[test]
631    fn validate_reports_error_for_array_column_with_unparseable_element_type() {
632        // `postgres_column_type_generator.rs::array_sql` panics on an `elementType` that
633        // doesn't name a real column type (H23); `validate()` only checked that
634        // `elementType` was *present*, not that it was meaningful.
635        use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
636        use crate::model::column_type::ColumnType as CT;
637
638        let table = TableBuilder::new(Some("s"), "widget")
639            .add_column(
640                ColumnBuilder::new(Some("s"), "tags", CT::Array)
641                    .element_type(Some("not_a_real_type".to_string()))
642                    .build(),
643            )
644            .build();
645        let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
646
647        let errors = schema.validate();
648        assert_eq!(errors.len(), 1);
649        assert!(errors[0].contains("tags"));
650        assert!(errors[0].contains("not_a_real_type"));
651    }
652
653    #[test]
654    fn validate_reports_error_for_enum_column_with_no_enum_type() {
655        // `<column type="enum"/>` with no `enumType` attribute previously passed
656        // `validate()` and panicked in every generator's `enum_sql()` via
657        // `column.enum_type().as_ref().unwrap()` (H23).
658        use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
659        use crate::model::column_type::ColumnType as CT;
660
661        let table = TableBuilder::new(Some("s"), "widget")
662            .add_column(ColumnBuilder::new(Some("s"), "status", CT::Enum).build())
663            .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("status"));
669        assert!(errors[0].contains("enumType"));
670    }
671
672    #[test]
673    fn validate_reports_error_for_unrecognized_boolean_default() {
674        use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
675        use crate::model::column_type::ColumnType as CT;
676
677        let table = TableBuilder::new(Some("s"), "widget")
678            .add_column(
679                ColumnBuilder::new(Some("s"), "active", CT::Boolean)
680                    .default_constraint(Some("maybe".to_string()))
681                    .build(),
682            )
683            .build();
684        let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
685
686        let errors = schema.validate();
687        assert_eq!(errors.len(), 1);
688        assert!(errors[0].contains("active"));
689        assert!(errors[0].contains("maybe"));
690    }
691
692    #[test]
693    fn validate_accepts_recognized_boolean_default_spellings() {
694        use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
695        use crate::model::column_type::ColumnType as CT;
696
697        for value in ["true", "1", "yes", "on", "false", "0", "no", "off", "null"] {
698            let table = TableBuilder::new(Some("s"), "widget")
699                .add_column(
700                    ColumnBuilder::new(Some("s"), "active", CT::Boolean)
701                        .default_constraint(Some(value.to_string()))
702                        .build(),
703                )
704                .build();
705            let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
706
707            assert!(schema.validate().is_empty(), "value: {:?}", value);
708        }
709    }
710
711    #[test]
712    fn validate_accepts_boolean_column_with_no_default() {
713        use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
714        use crate::model::column_type::ColumnType as CT;
715
716        let table = TableBuilder::new(Some("s"), "widget")
717            .add_column(ColumnBuilder::new(Some("s"), "active", CT::Boolean).build())
718            .build();
719        let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
720
721        assert!(schema.validate().is_empty());
722    }
723
724    #[test]
725    fn validate_reports_error_for_varchar_column_with_no_length() {
726        use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
727        use crate::model::column_type::ColumnType as CT;
728
729        let table = TableBuilder::new(Some("s"), "widget")
730            .add_column(ColumnBuilder::new(Some("s"), "name", CT::Varchar).build())
731            .build();
732        let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
733
734        let errors = schema.validate();
735        assert_eq!(errors.len(), 1);
736        assert!(errors[0].contains("name"));
737        assert!(errors[0].contains("length"));
738    }
739
740    #[test]
741    fn validate_reports_error_for_char_column_with_zero_length() {
742        use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
743        use crate::model::column_type::ColumnType as CT;
744
745        let table = TableBuilder::new(Some("s"), "widget")
746            .add_column(ColumnBuilder::new(Some("s"), "code", CT::Char).length(0).build())
747            .build();
748        let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
749
750        let errors = schema.validate();
751        assert_eq!(errors.len(), 1);
752        assert!(errors[0].contains("code"));
753    }
754
755    #[test]
756    fn validate_accepts_char_and_varchar_columns_with_positive_length() {
757        use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
758        use crate::model::column_type::ColumnType as CT;
759
760        let table = TableBuilder::new(Some("s"), "widget")
761            .add_column(ColumnBuilder::new(Some("s"), "code", CT::Char).length(1).build())
762            .add_column(ColumnBuilder::new(Some("s"), "name", CT::Varchar).length(100).build())
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_column_referencing_a_declared_enum_type_case_insensitively() {
771        use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
772        use crate::model::column_type::ColumnType as CT;
773        use crate::model::enum_type::EnumType;
774
775        let table = TableBuilder::new(Some("s"), "widget")
776            .add_column(
777                ColumnBuilder::new(Some("s"), "status", CT::Enum)
778                    .enum_type(Some("statustype".to_string()))
779                    .build(),
780            )
781            .build();
782        let schema = SchemaBuilder::new(Some("s"))
783            .add_table(table)
784            .add_enum_type(EnumType::new("StatusType", Vec::new()))
785            .build();
786
787        assert!(schema.validate().is_empty());
788    }
789
790    // #[test]
791    // fn build_reverse_relations_creates_back_refs() {
792    //     let mut s = make_schema();
793    //     let mut parent = Table::new(
794    //         Some("s"),
795    //         "p",
796    //         Option::<&str>::None,
797    //         crate::model::types::LockEscalation::Auto,
798    //         false,
799    //         vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
800    //         Vec::new(),
801    //         Vec::new(),
802    //         Vec::new(),
803    //         Vec::new(),
804    //         Vec::new(),
805    //         Vec::new(),
806    //         Vec::new(),
807    //         Vec::new(),
808    //     );
809    //     let mut child = Table::new(
810    //         Some("s"),
811    //         "c",
812    //         Option::<&str>::None,
813    //         crate::model::types::LockEscalation::Auto,
814    //         false,
815    //         vec![Column::new(Some("s"), "pid", ColumnType::Int, 0, 0, false)],
816    //         Vec::new(),
817    //         Vec::new(),
818    //         vec![Relation::new(
819    //             "p",
820    //             "id",
821    //             "c",
822    //             "pid",
823    //             RelationType::Cascade,
824    //             false,
825    //         )],
826    //         Vec::new(),
827    //         Vec::new(),
828    //         Vec::new(),
829    //         Vec::new(),
830    //         Vec::new(),
831    //     );
832    //     s.add_table(parent);
833    //     s.add_table(child);
834    //
835    //     s.build_reverse_relations();
836    //     let p_ref = s.get_table("p");
837    //     assert_eq!(p_ref.reverse_relations().len(), 1);
838    //     let rr = &p_ref.reverse_relations()[0];
839    //     assert_eq!(rr.from_table_name(), "c");
840    //     assert_eq!(rr.to_table_name(), "p");
841    // }
842}