elefant-tools 0.0.2

A library for doing things like pg_dump and pg_restore, with extra features, and probably more bugs.
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

use crate::models::extension::PostgresExtension;
use crate::models::schema::PostgresSchema;
use crate::object_id::ObjectId;
use crate::{default, TimescaleDbUserDefinedJob};
use serde::{Deserialize, Serialize};

#[derive(Debug, Eq, PartialEq, Default, Clone, Serialize, Deserialize)]
pub struct PostgresDatabase {
    pub schemas: Vec<PostgresSchema>,
    pub enabled_extensions: Vec<PostgresExtension>,
    pub timescale_support: TimescaleSupport,
    pub object_id: ObjectId,
}

#[derive(Debug, Eq, PartialEq, Default, Clone, Serialize, Deserialize)]
pub struct TimescaleSupport {
    pub is_enabled: bool,
    pub timescale_toolkit_is_enabled: bool,
    pub user_defined_jobs: Vec<TimescaleDbUserDefinedJob>,
}

impl PostgresDatabase {
    pub fn get_or_create_schema_mut(&mut self, schema_name: &str) -> &mut PostgresSchema {
        if let Some(position) = self.schemas.iter().position(|s| s.name == schema_name) {
            self.schemas.get_mut(position).unwrap()
        } else {
            let new_schema = PostgresSchema {
                name: schema_name.to_string(),
                ..default()
            };

            self.schemas.push(new_schema);
            self.schemas.last_mut().unwrap()
        }
    }

    pub fn filtered_to_schema(&self, schema: &str) -> Self {
        PostgresDatabase {
            timescale_support: TimescaleSupport {
                user_defined_jobs: self
                    .timescale_support
                    .user_defined_jobs
                    .iter()
                    .filter(|j| j.function_schema == schema)
                    .cloned()
                    .collect(),
                ..self.timescale_support.clone()
            },
            schemas: self
                .schemas
                .iter()
                .filter(|s| s.name == schema)
                .cloned()
                .collect(),
            ..self.clone()
        }
    }

    pub fn with_renamed_schema(&self, old_schema_name: &str, new_schema_name: &str) -> Self {
        PostgresDatabase {
            timescale_support: TimescaleSupport {
                user_defined_jobs: self
                    .timescale_support
                    .user_defined_jobs
                    .iter()
                    .map(|j| {
                        if j.function_schema == old_schema_name {
                            TimescaleDbUserDefinedJob {
                                function_schema: new_schema_name.to_string(),
                                ..j.clone()
                            }
                        } else {
                            j.clone()
                        }
                    })
                    .collect(),
                ..self.timescale_support.clone()
            },
            schemas: self
                .schemas
                .iter()
                .map(|s| {
                    if s.name == old_schema_name {
                        PostgresSchema {
                            name: new_schema_name.to_string(),
                            ..s.clone()
                        }
                    } else {
                        s.clone()
                    }
                })
                .collect(),
            ..self.clone()
        }
    }

    pub(crate) fn try_get_schema(&self, schema_name: &str) -> Option<&PostgresSchema> {
        self.schemas.iter().find(|s| s.name == schema_name)
    }
}