schema_guard 1.9.1

Schema Guard: Relation Database (Schema) Management tool
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use postgres::Transaction;
use serde::Serialize;
use yaml_rust::Yaml;

use crate::loader::InfoSchemaType;
use crate::table::Table;
use crate::utils::{Named, OrderedHashMap};

#[derive(Debug, Clone, Serialize)]
pub struct Schema {
    #[serde(rename = "schemaName")]
    pub schema_name: String,
    pub owner: String,
    /// tableName: table(with name)
    #[serde(with = "crate::table::ytables")]
    pub tables: OrderedHashMap<Table>,
    /// the table definition loaded from file
    #[serde(skip)]
    pub file: String,
}

impl Named for Schema {
    fn get_name(&self) -> String {
        self.schema_name.clone()
    }
}

impl Default for Schema {
    fn default() -> Self {
        Schema {
            schema_name: "".to_string(),
            owner: "".to_string(),
            tables: OrderedHashMap::new(),
            file: "".to_string(),
        }
    }
}

impl Schema {
    #[inline]
    pub fn schema_name(input: &Yaml) -> String {
        match input["schemaName"].as_str() {
            None => "public".into(),
            Some(s) => s.into(),
        }
    }

    #[inline]
    pub fn new(input: &Yaml, file: &str) -> Self {
        Schema {
            schema_name: Schema::schema_name(input),
            owner: crate::utils::as_str(input, "schemaName", ""),
            tables: OrderedHashMap::new(),
            file: file.to_string(),
        }
    }

    #[inline]
    pub fn append(&mut self, input: &Yaml) -> Result<(), String> {
        if let Some(tbls) = input["tables"].as_vec() {
            for t in tbls {
                let t = &t["table"];
                match t["tableName"].as_str() {
                    None => {
                        return Err(format!("no table name set in file: {}", self.file));
                    }
                    Some(tn) => {
                        if self.tables.map.contains_key(tn) {
                            return Err(format!(
                                "duplicate table definition: {} found in file: {}",
                                tn, self.file
                            ));
                        } else {
                            let _ = self.tables.append(Table::new(
                                t,
                                tn,
                                Some(&self.file),
                            )?);
                        }
                    }
                }
            }
        }
        Ok(())
    }

    #[inline]
    /// return statements to execute
    pub fn deploy_all_tables(&self, schema: &mut InfoSchemaType, db: &mut Transaction, retry: bool, dry_run: Option<&dyn Fn(Vec<String>) -> Result<(), String>>) -> Result<usize, String> {
        let mut cnt = 0;
        for t in &self.tables.list {
            if t.deploy(schema, db, &self.schema_name, retry, self.file.as_str(), dry_run)? {
                cnt += 1;
            }
        }
        Ok(cnt)
    }

    #[inline]
    /// return statements to execute
    pub fn deploy_all_fk(&self, schemas: &OrderedHashMap<Schema>, schema: &mut InfoSchemaType, db: &mut Transaction, retry: bool, dry_run: Option<&dyn Fn(Vec<String>) -> Result<(), String>>) -> Result<usize, String> {
        let mut cnt = 0;
        for t in &self.tables.list {
            if t.deploy_fk(schemas, schema, db, &self.schema_name, retry, self.file.as_str(), dry_run)? {
                cnt += 1;
            }
        }
        Ok(cnt)
    }

}