safe-migrate 0.9.0

Check PostgreSQL migrations against a synchronized database baseline
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

use super::Resolver;
use crate::_internal::analysis::facts::{
    RelationTargetFact, SearchPathTarget, TimeoutSetting, TimeoutSettingValue,
};
use crate::_internal::analysis::mutations::{
    LockTableMutation, Mutation, RelationTargetMutation, ReleaseSavepointMutation,
    RollbackToSavepointMutation, SavepointMutation, SearchPathChange, TimeoutSettingChange,
    TruncateMutation,
};
use crate::_internal::analysis::state::AnalysisState;
use crate::_internal::ast::identifiers::QualifiedName;

impl Resolver {
    pub(super) fn resolve_search_path(target: &SearchPathTarget, local: bool) -> Mutation {
        Mutation::SearchPath(SearchPathChange {
            target: target.clone(),
            local,
        })
    }

    pub(super) fn resolve_timeout(
        setting: TimeoutSetting,
        value: &TimeoutSettingValue,
        local: bool,
    ) -> Mutation {
        Mutation::TimeoutSetting(TimeoutSettingChange {
            setting,
            value: value.clone(),
            local,
        })
    }

    pub(super) fn resolve_rollback_to_savepoint(name: &str) -> Mutation {
        Mutation::RollbackToSavepoint(RollbackToSavepointMutation {
            name: name.to_string(),
        })
    }

    pub(super) fn resolve_savepoint(name: &str) -> Mutation {
        Mutation::Savepoint(SavepointMutation {
            name: name.to_string(),
        })
    }

    pub(super) fn resolve_release_savepoint(name: &str) -> Mutation {
        Mutation::ReleaseSavepoint(ReleaseSavepointMutation {
            name: name.to_string(),
        })
    }

    pub(super) fn resolve_vacuum(
        relation: Option<&QualifiedName>,
        is_full: bool,
        state: &AnalysisState,
    ) -> Mutation {
        Mutation::Vacuum {
            table_id: relation.map(|relation| Self::resolve_relation_lookup_name(relation, state)),
            is_full,
        }
    }

    pub(super) fn resolve_lock(
        targets: &[RelationTargetFact],
        mode: crate::_internal::analysis::facts::LockModeFact,
        nowait: bool,
        state: &AnalysisState,
    ) -> Mutation {
        Mutation::LockTable(LockTableMutation {
            targets: targets
                .iter()
                .map(|target| RelationTargetMutation {
                    id: Self::resolve_relation_lookup_name(&target.name, state),
                    only: target.only,
                })
                .collect(),
            mode,
            nowait,
        })
    }

    pub(super) fn resolve_truncate(
        targets: &[RelationTargetFact],
        cascade: bool,
        restart_identity: bool,
        state: &AnalysisState,
    ) -> Mutation {
        Mutation::Truncate(TruncateMutation {
            targets: targets
                .iter()
                .map(|target| RelationTargetMutation {
                    id: Self::resolve_relation_lookup_name(&target.name, state),
                    only: target.only,
                })
                .collect(),
            cascade,
            restart_identity,
        })
    }
}