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
100
101
102
103
104
105
106

use super::Resolver;
use crate::_internal::analysis::facts::AlterSequenceActionFact;
use crate::_internal::analysis::mutations::{
    AlterSequenceActionMutation, AlterSequenceMutation, CreateSequenceMutation,
    DropSequenceMutation, Mutation,
};
use crate::_internal::analysis::state::AnalysisState;
use crate::_internal::ast::identifiers::{ObjectId, QualifiedName};

impl Resolver {
    fn resolve_owned_by(
        owned_by: &Option<(QualifiedName, String)>,
        state: &AnalysisState,
    ) -> Option<(ObjectId, String)> {
        owned_by.as_ref().map(|(table_name, column)| {
            (
                Self::resolve_relation_lookup_name(table_name, state),
                column.clone(),
            )
        })
    }

    pub(super) fn resolve_create_sequence(
        name: &QualifiedName,
        if_not_exists: bool,
        owned_by: &Option<(QualifiedName, String)>,
        persistence: &crate::_internal::analysis::facts::PersistenceFact,
        options: &crate::_internal::analysis::facts::IdentitySequenceOptionsFact,
        state: &AnalysisState,
    ) -> Mutation {
        Mutation::CreateSequence(CreateSequenceMutation {
            id: Self::resolve_creation_name(name, state),
            if_not_exists,
            owned_by: Self::resolve_owned_by(owned_by, state),
            persistence: match persistence {
                crate::_internal::analysis::facts::PersistenceFact::Permanent => {
                    crate::_internal::model::sequence::SequencePersistence::Permanent
                }
                crate::_internal::analysis::facts::PersistenceFact::Temporary => {
                    crate::_internal::model::sequence::SequencePersistence::Temporary
                }
                crate::_internal::analysis::facts::PersistenceFact::Unlogged => {
                    crate::_internal::model::sequence::SequencePersistence::Unlogged
                }
            },
            options: crate::_internal::analysis::mutations::IdentitySequenceOptionsMutation {
                data_type: options.data_type.clone(),
                start_value: options.start_value,
                increment: options.increment,
                min_value: options.min_value,
                max_value: options.max_value,
                cache_size: options.cache_size,
                cycle: options.cycle,
                persistence: options.persistence,
                sequence_name: None,
            },
        })
    }

    pub(super) fn resolve_alter_sequence(
        name: &QualifiedName,
        if_exists: bool,
        action: &AlterSequenceActionFact,
        state: &AnalysisState,
    ) -> Mutation {
        let id = Self::resolve_relation_lookup_name(name, state);
        let action = match action {
            AlterSequenceActionFact::OwnedBy(owned_by) => {
                AlterSequenceActionMutation::OwnedBy(Self::resolve_owned_by(owned_by, state))
            }
            AlterSequenceActionFact::OwnerTo(owner) => {
                AlterSequenceActionMutation::OwnerTo(owner.clone())
            }
            AlterSequenceActionFact::RenameTo(new_name) => {
                let mut new_id = ObjectId::new(&id.schema, new_name.resolve());
                new_id.inferred_schema = id.inferred_schema;
                AlterSequenceActionMutation::RenameTo(new_id)
            }
            AlterSequenceActionFact::SetSchema(schema) => {
                AlterSequenceActionMutation::SetSchema(ObjectId::new(schema, &id.name))
            }
            AlterSequenceActionFact::Other => AlterSequenceActionMutation::Other,
        };
        Mutation::AlterSequence(AlterSequenceMutation {
            id,
            if_exists,
            action,
        })
    }

    pub(super) fn resolve_drop_sequence(
        names: &[QualifiedName],
        if_exists: bool,
        cascade: bool,
        state: &AnalysisState,
    ) -> Mutation {
        Mutation::DropSequence(DropSequenceMutation {
            ids: names
                .iter()
                .map(|name| Self::resolve_relation_lookup_name(name, state))
                .collect(),
            if_exists,
            cascade,
        })
    }
}