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