mz_catalog/durable/upgrade/
v73_to_v74.rs

1// Copyright Materialize, Inc. and contributors. All rights reserved.
2//
3// Use of this software is governed by the Business Source License
4// included in the LICENSE file.
5//
6// As of the Change Date specified in that file, in accordance with
7// the Business Source License, use of this software will be governed
8// by the Apache License, Version 2.0.
9
10use crate::durable::traits::UpgradeFrom;
11use crate::durable::upgrade::MigrationAction;
12use crate::durable::upgrade::{objects_v73 as v73, objects_v74 as v74};
13use crate::wire_compatible;
14
15wire_compatible!(v73::RoleKey with v74::RoleKey);
16
17/// in v74, we add attributes to RoleAttribute.
18pub fn upgrade(
19    snapshot: Vec<v73::StateUpdateKind>,
20) -> Vec<MigrationAction<v73::StateUpdateKind, v74::StateUpdateKind>> {
21    let mut migrations = Vec::new();
22    for update in snapshot {
23        match update.kind {
24            Some(v73::state_update_kind::Kind::Role(old_role)) => {
25                let new_role = v74::state_update_kind::Role::upgrade_from(old_role.clone());
26                let old_role = v73::StateUpdateKind {
27                    kind: Some(v73::state_update_kind::Kind::Role(old_role)),
28                };
29                let new_role = v74::StateUpdateKind {
30                    kind: Some(v74::state_update_kind::Kind::Role(new_role)),
31                };
32
33                let migration = MigrationAction::Update(old_role, new_role);
34                migrations.push(migration);
35            }
36            _ => {
37                // We don't need to do anything for other kinds of updates.
38                // The upgrade from v73 to v74 is only concerned with the Role kind.
39            }
40        }
41    }
42    migrations
43}
44
45impl UpgradeFrom<v73::state_update_kind::Role> for v74::state_update_kind::Role {
46    fn upgrade_from(value: v73::state_update_kind::Role) -> Self {
47        let new_key = value.key.map(|key| v74::RoleKey {
48            id: key.id.map(v74::RoleId::upgrade_from),
49        });
50        let new_value = value.value.map(|value| v74::RoleValue {
51            name: value.name,
52            oid: value.oid,
53            attributes: value.attributes.map(v74::RoleAttributes::upgrade_from),
54            membership: value.membership.map(v74::RoleMembership::upgrade_from),
55            vars: value.vars.map(v74::RoleVars::upgrade_from),
56        });
57        v74::state_update_kind::Role {
58            key: new_key,
59            value: new_value,
60        }
61    }
62}
63
64impl UpgradeFrom<v73::RoleVars> for v74::RoleVars {
65    fn upgrade_from(value: v73::RoleVars) -> Self {
66        v74::RoleVars {
67            entries: value
68                .entries
69                .iter()
70                .map(|val| v74::role_vars::Entry::upgrade_from(val.clone()))
71                .collect(),
72        }
73    }
74}
75
76impl UpgradeFrom<v73::RoleMembership> for v74::RoleMembership {
77    fn upgrade_from(value: v73::RoleMembership) -> Self {
78        v74::RoleMembership {
79            map: value
80                .map
81                .iter()
82                .map(|val| v74::role_membership::Entry::upgrade_from(*val))
83                .collect(),
84        }
85    }
86}
87
88impl UpgradeFrom<v73::role_membership::Entry> for v74::role_membership::Entry {
89    fn upgrade_from(value: v73::role_membership::Entry) -> Self {
90        v74::role_membership::Entry {
91            key: value.key.map(v74::RoleId::upgrade_from),
92            value: value.value.map(v74::RoleId::upgrade_from),
93        }
94    }
95}
96
97impl UpgradeFrom<v73::role_vars::Entry> for v74::role_vars::Entry {
98    fn upgrade_from(value: v73::role_vars::Entry) -> Self {
99        v74::role_vars::Entry {
100            key: value.key,
101            val: value.val.map(v74::role_vars::entry::Val::upgrade_from),
102        }
103    }
104}
105
106impl UpgradeFrom<v73::role_vars::entry::Val> for v74::role_vars::entry::Val {
107    fn upgrade_from(value: v73::role_vars::entry::Val) -> Self {
108        match value {
109            v73::role_vars::entry::Val::Flat(x) => v74::role_vars::entry::Val::Flat(x),
110            v73::role_vars::entry::Val::SqlSet(x) => {
111                v74::role_vars::entry::Val::SqlSet(v74::role_vars::SqlSet::upgrade_from(x))
112            }
113        }
114    }
115}
116impl UpgradeFrom<v73::role_vars::SqlSet> for v74::role_vars::SqlSet {
117    fn upgrade_from(value: v73::role_vars::SqlSet) -> Self {
118        v74::role_vars::SqlSet {
119            entries: value.entries,
120        }
121    }
122}
123
124impl UpgradeFrom<v73::RoleAttributes> for v74::RoleAttributes {
125    fn upgrade_from(value: v73::RoleAttributes) -> Self {
126        v74::RoleAttributes {
127            inherit: value.inherit,
128            ..Default::default()
129        }
130    }
131}
132
133impl UpgradeFrom<v73::RoleId> for v74::RoleId {
134    fn upgrade_from(value: v73::RoleId) -> Self {
135        let value = match value.value {
136            Some(v73::role_id::Value::System(x)) => Some(v74::role_id::Value::System(x)),
137            Some(v73::role_id::Value::User(x)) => Some(v74::role_id::Value::User(x)),
138            Some(v73::role_id::Value::Public(_)) => {
139                Some(v74::role_id::Value::Public(v74::Empty {}))
140            }
141            Some(v73::role_id::Value::Predefined(x)) => Some(v74::role_id::Value::Predefined(x)),
142            None => None,
143        };
144        v74::RoleId { value }
145    }
146}
147
148impl UpgradeFrom<v73::RoleKey> for v74::RoleKey {
149    fn upgrade_from(value: v73::RoleKey) -> Self {
150        Self {
151            id: value.id.map(v74::RoleId::upgrade_from),
152        }
153    }
154}