schema-model 0.2.0

A set of tools to manage relational database schemas
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

use crate::model::enum_type::EnumType;
use crate::model::function::Function;
use crate::model::other_sql::OtherSql;
use crate::model::procedure::Procedure;
use crate::model::schema::Schema;
use crate::model::table::Table;
use crate::model::view::View;

/// SchemaBuilder accumulates intermediate state and produces an immutable Schema on build.
#[derive(Debug, Default)]
pub struct SchemaBuilder {
    schema: Schema,
}

impl SchemaBuilder {
    pub fn new<S: Into<String>>(schema_name: Option<S>) -> Self {
        Self {
            schema: Schema::new(schema_name.map(|s| s.into())),
        }
    }

    /// Add a fully prepared Table value.
    pub fn add_table(mut self, table: Table) -> Self {
        self.schema.add_table(table);
        self
    }
    /// Add a View.
    pub fn add_view(mut self, view: View) -> Self {
        self.schema.add_view(view);
        self
    }
    /// Add an enum type.
    pub fn add_enum_type(mut self, enum_type: EnumType) -> Self {
        self.schema.add_enum_type(enum_type);
        self
    }
    /// Add functions.
    pub fn add_functions(mut self, functions: Vec<Function>) -> Self {
        self.schema.add_functions(functions);
        self
    }
    /// Add procedures.
    pub fn add_procedures(mut self, procedures: Vec<Procedure>) -> Self {
        self.schema.add_procedures(procedures);
        self
    }
    /// Add an OtherSql.
    pub fn add_other_sql(mut self, other_sql: OtherSql) -> Self {
        self.schema.add_other_sql(other_sql);
        self
    }

    pub fn case_sensitive_text(mut self, value: bool) -> Self {
        self.schema.set_case_sensitive_text(value);
        self
    }

    /// Finalize and return the fully-populated Schema.
    pub fn build(self) -> Schema {
        self.schema
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::builder::{ColumnBuilder, KeyBuilder, TableBuilder};
    use crate::model::column_type::ColumnType;
    use crate::model::types::KeyType;

    #[test]
    fn build_schema_with_table_and_pk() {
        let table = TableBuilder::new(None, "users")
            .add_column(
                ColumnBuilder::new(None, "id", ColumnType::Int)
                    .required(true)
                    .build(),
            )
            .add_column(ColumnBuilder::new(None, "name", ColumnType::Varchar).build())
            .add_key(KeyBuilder::new(KeyType::Primary).add_column("id").build())
            .build();

        let schema = SchemaBuilder::new(None::<&str>).add_table(table).build();

        assert_eq!(schema.tables().len(), 1);
        assert_eq!(schema.tables()[0].name(), "users");
    }
}