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