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