mz_catalog_protos/
serialization.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
10//! This module is responsible for serializing objects from crates other than
11//! `mz_catalog` into protobuf.
12//!
13//! The reason this module doesn't exist in the `mz_catalog` crate itself is
14//! because of Rust's orphan rules.
15
16use std::time::Duration;
17
18use mz_compute_types::config::ComputeReplicaLogging;
19use mz_controller_types::ReplicaId;
20use mz_proto::{ProtoMapEntry, ProtoType, RustType, TryFromProtoError};
21use mz_repr::adt::mz_acl_item::{AclMode, MzAclItem};
22use mz_repr::network_policy_id::NetworkPolicyId;
23use mz_repr::role_id::RoleId;
24use mz_repr::{CatalogItemId, GlobalId, RelationVersion};
25use mz_sql::catalog::{
26    AutoProvisionSource, CatalogItemType, ObjectType, RoleAttributes, RoleMembership, RoleVars,
27};
28use mz_sql::names::{
29    CommentObjectId, DatabaseId, ResolvedDatabaseSpecifier, SchemaId, SchemaSpecifier,
30};
31use mz_sql::plan::{
32    ClusterSchedule, NetworkPolicyRule, NetworkPolicyRuleAction, NetworkPolicyRuleDirection,
33    PolicyAddress,
34};
35use mz_sql::session::vars::OwnedVarInput;
36use mz_storage_types::instances::StorageInstanceId;
37
38impl From<String> for crate::objects::StringWrapper {
39    fn from(value: String) -> Self {
40        crate::objects::StringWrapper { inner: value }
41    }
42}
43
44impl RustType<crate::objects::Duration> for Duration {
45    fn into_proto(&self) -> crate::objects::Duration {
46        crate::objects::Duration {
47            secs: self.as_secs(),
48            nanos: self.subsec_nanos(),
49        }
50    }
51
52    fn from_proto(proto: crate::objects::Duration) -> Result<Self, TryFromProtoError> {
53        Ok(Duration::new(proto.secs, proto.nanos))
54    }
55}
56
57impl RustType<crate::objects::RoleId> for RoleId {
58    fn into_proto(&self) -> crate::objects::RoleId {
59        match self {
60            RoleId::User(id) => crate::objects::RoleId::User(*id),
61            RoleId::System(id) => crate::objects::RoleId::System(*id),
62            RoleId::Predefined(id) => crate::objects::RoleId::Predefined(*id),
63            RoleId::Public => crate::objects::RoleId::Public,
64        }
65    }
66
67    fn from_proto(proto: crate::objects::RoleId) -> Result<Self, TryFromProtoError> {
68        let id = match proto {
69            crate::objects::RoleId::User(id) => RoleId::User(id),
70            crate::objects::RoleId::System(id) => RoleId::System(id),
71            crate::objects::RoleId::Predefined(id) => RoleId::Predefined(id),
72            crate::objects::RoleId::Public => RoleId::Public,
73        };
74        Ok(id)
75    }
76}
77
78impl RustType<crate::objects::AclMode> for AclMode {
79    fn into_proto(&self) -> crate::objects::AclMode {
80        crate::objects::AclMode {
81            bitflags: self.bits(),
82        }
83    }
84
85    fn from_proto(proto: crate::objects::AclMode) -> Result<Self, TryFromProtoError> {
86        AclMode::from_bits(proto.bitflags).ok_or_else(|| {
87            TryFromProtoError::InvalidBitFlags(format!("Invalid AclMode from catalog {proto:?}"))
88        })
89    }
90}
91
92impl RustType<crate::objects::MzAclItem> for MzAclItem {
93    fn into_proto(&self) -> crate::objects::MzAclItem {
94        crate::objects::MzAclItem {
95            grantee: self.grantee.into_proto(),
96            grantor: self.grantor.into_proto(),
97            acl_mode: self.acl_mode.into_proto(),
98        }
99    }
100
101    fn from_proto(proto: crate::objects::MzAclItem) -> Result<Self, TryFromProtoError> {
102        Ok(MzAclItem {
103            grantee: proto.grantee.into_rust()?,
104            grantor: proto.grantor.into_rust()?,
105            acl_mode: proto.acl_mode.into_rust()?,
106        })
107    }
108}
109
110impl RustType<crate::objects::AutoProvisionSource> for AutoProvisionSource {
111    fn into_proto(&self) -> crate::objects::AutoProvisionSource {
112        match self {
113            AutoProvisionSource::Oidc => crate::objects::AutoProvisionSource::Oidc,
114            AutoProvisionSource::Frontegg => crate::objects::AutoProvisionSource::Frontegg,
115            AutoProvisionSource::None => crate::objects::AutoProvisionSource::None,
116        }
117    }
118
119    fn from_proto(proto: crate::objects::AutoProvisionSource) -> Result<Self, TryFromProtoError> {
120        Ok(match proto {
121            crate::objects::AutoProvisionSource::Oidc => AutoProvisionSource::Oidc,
122            crate::objects::AutoProvisionSource::Frontegg => AutoProvisionSource::Frontegg,
123            crate::objects::AutoProvisionSource::None => AutoProvisionSource::None,
124        })
125    }
126}
127
128impl RustType<crate::objects::RoleAttributes> for RoleAttributes {
129    fn into_proto(&self) -> crate::objects::RoleAttributes {
130        crate::objects::RoleAttributes {
131            inherit: self.inherit,
132            superuser: self.superuser,
133            login: self.login,
134            auto_provision_source: self.auto_provision_source.into_proto(),
135        }
136    }
137
138    fn from_proto(proto: crate::objects::RoleAttributes) -> Result<Self, TryFromProtoError> {
139        let mut attributes = RoleAttributes::new();
140
141        attributes.inherit = proto.inherit;
142        attributes.superuser = proto.superuser;
143        attributes.login = proto.login;
144        attributes.auto_provision_source = proto.auto_provision_source.into_rust()?;
145
146        Ok(attributes)
147    }
148}
149
150impl RustType<crate::objects::RoleVar> for OwnedVarInput {
151    fn into_proto(&self) -> crate::objects::RoleVar {
152        match self.clone() {
153            OwnedVarInput::Flat(v) => crate::objects::RoleVar::Flat(v),
154            OwnedVarInput::SqlSet(entries) => crate::objects::RoleVar::SqlSet(entries),
155        }
156    }
157
158    fn from_proto(proto: crate::objects::RoleVar) -> Result<Self, TryFromProtoError> {
159        let result = match proto {
160            crate::objects::RoleVar::Flat(v) => OwnedVarInput::Flat(v),
161            crate::objects::RoleVar::SqlSet(entries) => OwnedVarInput::SqlSet(entries),
162        };
163        Ok(result)
164    }
165}
166
167impl RustType<crate::objects::RoleVars> for RoleVars {
168    fn into_proto(&self) -> crate::objects::RoleVars {
169        let entries = self
170            .map
171            .clone()
172            .into_iter()
173            .map(|(key, val)| crate::objects::RoleVarsEntry {
174                key,
175                val: val.into_proto(),
176            })
177            .collect();
178
179        crate::objects::RoleVars { entries }
180    }
181
182    fn from_proto(proto: crate::objects::RoleVars) -> Result<Self, TryFromProtoError> {
183        let map = proto
184            .entries
185            .into_iter()
186            .map(|entry| {
187                let val = entry.val.into_rust()?;
188                Ok::<_, TryFromProtoError>((entry.key, val))
189            })
190            .collect::<Result<_, _>>()?;
191
192        Ok(RoleVars { map })
193    }
194}
195
196impl RustType<crate::objects::NetworkPolicyId> for NetworkPolicyId {
197    fn into_proto(&self) -> crate::objects::NetworkPolicyId {
198        match self {
199            NetworkPolicyId::User(id) => crate::objects::NetworkPolicyId::User(*id),
200            NetworkPolicyId::System(id) => crate::objects::NetworkPolicyId::System(*id),
201        }
202    }
203
204    fn from_proto(proto: crate::objects::NetworkPolicyId) -> Result<Self, TryFromProtoError> {
205        let id = match proto {
206            crate::objects::NetworkPolicyId::User(id) => NetworkPolicyId::User(id),
207            crate::objects::NetworkPolicyId::System(id) => NetworkPolicyId::System(id),
208        };
209        Ok(id)
210    }
211}
212
213impl RustType<crate::objects::CatalogItemType> for CatalogItemType {
214    fn into_proto(&self) -> crate::objects::CatalogItemType {
215        match self {
216            CatalogItemType::Table => crate::objects::CatalogItemType::Table,
217            CatalogItemType::Source => crate::objects::CatalogItemType::Source,
218            CatalogItemType::Sink => crate::objects::CatalogItemType::Sink,
219            CatalogItemType::View => crate::objects::CatalogItemType::View,
220            CatalogItemType::MaterializedView => crate::objects::CatalogItemType::MaterializedView,
221            CatalogItemType::Index => crate::objects::CatalogItemType::Index,
222            CatalogItemType::Type => crate::objects::CatalogItemType::Type,
223            CatalogItemType::Func => crate::objects::CatalogItemType::Func,
224            CatalogItemType::Secret => crate::objects::CatalogItemType::Secret,
225            CatalogItemType::Connection => crate::objects::CatalogItemType::Connection,
226            CatalogItemType::ContinualTask => crate::objects::CatalogItemType::ContinualTask,
227        }
228    }
229
230    fn from_proto(proto: crate::objects::CatalogItemType) -> Result<Self, TryFromProtoError> {
231        let item_type = match proto {
232            crate::objects::CatalogItemType::Table => CatalogItemType::Table,
233            crate::objects::CatalogItemType::Source => CatalogItemType::Source,
234            crate::objects::CatalogItemType::Sink => CatalogItemType::Sink,
235            crate::objects::CatalogItemType::View => CatalogItemType::View,
236            crate::objects::CatalogItemType::MaterializedView => CatalogItemType::MaterializedView,
237            crate::objects::CatalogItemType::Index => CatalogItemType::Index,
238            crate::objects::CatalogItemType::Type => CatalogItemType::Type,
239            crate::objects::CatalogItemType::Func => CatalogItemType::Func,
240            crate::objects::CatalogItemType::Secret => CatalogItemType::Secret,
241            crate::objects::CatalogItemType::Connection => CatalogItemType::Connection,
242            crate::objects::CatalogItemType::ContinualTask => CatalogItemType::ContinualTask,
243            crate::objects::CatalogItemType::Unknown => {
244                return Err(TryFromProtoError::unknown_enum_variant("CatalogItemType"));
245            }
246        };
247        Ok(item_type)
248    }
249}
250
251impl RustType<crate::objects::ObjectType> for ObjectType {
252    fn into_proto(&self) -> crate::objects::ObjectType {
253        match self {
254            ObjectType::Table => crate::objects::ObjectType::Table,
255            ObjectType::View => crate::objects::ObjectType::View,
256            ObjectType::MaterializedView => crate::objects::ObjectType::MaterializedView,
257            ObjectType::Source => crate::objects::ObjectType::Source,
258            ObjectType::Sink => crate::objects::ObjectType::Sink,
259            ObjectType::Index => crate::objects::ObjectType::Index,
260            ObjectType::Type => crate::objects::ObjectType::Type,
261            ObjectType::Role => crate::objects::ObjectType::Role,
262            ObjectType::Cluster => crate::objects::ObjectType::Cluster,
263            ObjectType::ClusterReplica => crate::objects::ObjectType::ClusterReplica,
264            ObjectType::Secret => crate::objects::ObjectType::Secret,
265            ObjectType::Connection => crate::objects::ObjectType::Connection,
266            ObjectType::Database => crate::objects::ObjectType::Database,
267            ObjectType::Schema => crate::objects::ObjectType::Schema,
268            ObjectType::Func => crate::objects::ObjectType::Func,
269            ObjectType::ContinualTask => crate::objects::ObjectType::ContinualTask,
270            ObjectType::NetworkPolicy => crate::objects::ObjectType::NetworkPolicy,
271        }
272    }
273
274    fn from_proto(proto: crate::objects::ObjectType) -> Result<Self, TryFromProtoError> {
275        match proto {
276            crate::objects::ObjectType::Table => Ok(ObjectType::Table),
277            crate::objects::ObjectType::View => Ok(ObjectType::View),
278            crate::objects::ObjectType::MaterializedView => Ok(ObjectType::MaterializedView),
279            crate::objects::ObjectType::Source => Ok(ObjectType::Source),
280            crate::objects::ObjectType::Sink => Ok(ObjectType::Sink),
281            crate::objects::ObjectType::Index => Ok(ObjectType::Index),
282            crate::objects::ObjectType::Type => Ok(ObjectType::Type),
283            crate::objects::ObjectType::Role => Ok(ObjectType::Role),
284            crate::objects::ObjectType::Cluster => Ok(ObjectType::Cluster),
285            crate::objects::ObjectType::ClusterReplica => Ok(ObjectType::ClusterReplica),
286            crate::objects::ObjectType::Secret => Ok(ObjectType::Secret),
287            crate::objects::ObjectType::Connection => Ok(ObjectType::Connection),
288            crate::objects::ObjectType::Database => Ok(ObjectType::Database),
289            crate::objects::ObjectType::Schema => Ok(ObjectType::Schema),
290            crate::objects::ObjectType::Func => Ok(ObjectType::Func),
291            crate::objects::ObjectType::ContinualTask => Ok(ObjectType::ContinualTask),
292            crate::objects::ObjectType::NetworkPolicy => Ok(ObjectType::NetworkPolicy),
293            crate::objects::ObjectType::Unknown => Err(TryFromProtoError::unknown_enum_variant(
294                "ObjectType::Unknown",
295            )),
296        }
297    }
298}
299
300impl RustType<crate::objects::RoleMembership> for RoleMembership {
301    fn into_proto(&self) -> crate::objects::RoleMembership {
302        crate::objects::RoleMembership {
303            map: self
304                .map
305                .iter()
306                .map(|(key, val)| crate::objects::RoleMembershipEntry {
307                    key: key.into_proto(),
308                    value: val.into_proto(),
309                })
310                .collect(),
311        }
312    }
313
314    fn from_proto(proto: crate::objects::RoleMembership) -> Result<Self, TryFromProtoError> {
315        Ok(RoleMembership {
316            map: proto
317                .map
318                .into_iter()
319                .map(|e| {
320                    let key = e.key.into_rust()?;
321                    let val = e.value.into_rust()?;
322
323                    Ok((key, val))
324                })
325                .collect::<Result<_, TryFromProtoError>>()?,
326        })
327    }
328}
329
330impl RustType<crate::objects::ResolvedDatabaseSpecifier> for ResolvedDatabaseSpecifier {
331    fn into_proto(&self) -> crate::objects::ResolvedDatabaseSpecifier {
332        match self {
333            ResolvedDatabaseSpecifier::Ambient => {
334                crate::objects::ResolvedDatabaseSpecifier::Ambient
335            }
336            ResolvedDatabaseSpecifier::Id(database_id) => {
337                crate::objects::ResolvedDatabaseSpecifier::Id(database_id.into_proto())
338            }
339        }
340    }
341
342    fn from_proto(
343        proto: crate::objects::ResolvedDatabaseSpecifier,
344    ) -> Result<Self, TryFromProtoError> {
345        let spec = match proto {
346            crate::objects::ResolvedDatabaseSpecifier::Ambient => {
347                ResolvedDatabaseSpecifier::Ambient
348            }
349            crate::objects::ResolvedDatabaseSpecifier::Id(database_id) => {
350                ResolvedDatabaseSpecifier::Id(database_id.into_rust()?)
351            }
352        };
353        Ok(spec)
354    }
355}
356
357impl RustType<crate::objects::SchemaSpecifier> for SchemaSpecifier {
358    fn into_proto(&self) -> crate::objects::SchemaSpecifier {
359        match self {
360            SchemaSpecifier::Temporary => crate::objects::SchemaSpecifier::Temporary,
361            SchemaSpecifier::Id(schema_id) => {
362                crate::objects::SchemaSpecifier::Id(schema_id.into_proto())
363            }
364        }
365    }
366
367    fn from_proto(proto: crate::objects::SchemaSpecifier) -> Result<Self, TryFromProtoError> {
368        let spec = match proto {
369            crate::objects::SchemaSpecifier::Temporary => SchemaSpecifier::Temporary,
370            crate::objects::SchemaSpecifier::Id(schema_id) => {
371                SchemaSpecifier::Id(schema_id.into_rust()?)
372            }
373        };
374        Ok(spec)
375    }
376}
377
378impl RustType<crate::objects::SchemaId> for SchemaId {
379    fn into_proto(&self) -> crate::objects::SchemaId {
380        match self {
381            SchemaId::User(id) => crate::objects::SchemaId::User(*id),
382            SchemaId::System(id) => crate::objects::SchemaId::System(*id),
383        }
384    }
385
386    fn from_proto(proto: crate::objects::SchemaId) -> Result<Self, TryFromProtoError> {
387        let id = match proto {
388            crate::objects::SchemaId::User(id) => SchemaId::User(id),
389            crate::objects::SchemaId::System(id) => SchemaId::System(id),
390        };
391        Ok(id)
392    }
393}
394
395impl RustType<crate::objects::DatabaseId> for DatabaseId {
396    fn into_proto(&self) -> crate::objects::DatabaseId {
397        match self {
398            DatabaseId::User(id) => crate::objects::DatabaseId::User(*id),
399            DatabaseId::System(id) => crate::objects::DatabaseId::System(*id),
400        }
401    }
402
403    fn from_proto(proto: crate::objects::DatabaseId) -> Result<Self, TryFromProtoError> {
404        match proto {
405            crate::objects::DatabaseId::User(id) => Ok(DatabaseId::User(id)),
406            crate::objects::DatabaseId::System(id) => Ok(DatabaseId::System(id)),
407        }
408    }
409}
410
411impl RustType<crate::objects::CommentObject> for CommentObjectId {
412    fn into_proto(&self) -> crate::objects::CommentObject {
413        match self {
414            CommentObjectId::Table(global_id) => {
415                crate::objects::CommentObject::Table(global_id.into_proto())
416            }
417            CommentObjectId::View(global_id) => {
418                crate::objects::CommentObject::View(global_id.into_proto())
419            }
420            CommentObjectId::MaterializedView(global_id) => {
421                crate::objects::CommentObject::MaterializedView(global_id.into_proto())
422            }
423            CommentObjectId::Source(global_id) => {
424                crate::objects::CommentObject::Source(global_id.into_proto())
425            }
426            CommentObjectId::Sink(global_id) => {
427                crate::objects::CommentObject::Sink(global_id.into_proto())
428            }
429            CommentObjectId::Index(global_id) => {
430                crate::objects::CommentObject::Index(global_id.into_proto())
431            }
432            CommentObjectId::Func(global_id) => {
433                crate::objects::CommentObject::Func(global_id.into_proto())
434            }
435            CommentObjectId::Connection(global_id) => {
436                crate::objects::CommentObject::Connection(global_id.into_proto())
437            }
438            CommentObjectId::Type(global_id) => {
439                crate::objects::CommentObject::Type(global_id.into_proto())
440            }
441            CommentObjectId::Secret(global_id) => {
442                crate::objects::CommentObject::Secret(global_id.into_proto())
443            }
444            CommentObjectId::Role(role_id) => {
445                crate::objects::CommentObject::Role(role_id.into_proto())
446            }
447            CommentObjectId::Database(database_id) => {
448                crate::objects::CommentObject::Database(database_id.into_proto())
449            }
450            CommentObjectId::ContinualTask(global_id) => {
451                crate::objects::CommentObject::ContinualTask(global_id.into_proto())
452            }
453            CommentObjectId::NetworkPolicy(network_policy_id) => {
454                crate::objects::CommentObject::NetworkPolicy(network_policy_id.into_proto())
455            }
456            CommentObjectId::Schema((database, schema)) => {
457                crate::objects::CommentObject::Schema(crate::objects::ResolvedSchema {
458                    database: database.into_proto(),
459                    schema: schema.into_proto(),
460                })
461            }
462            CommentObjectId::Cluster(cluster_id) => {
463                crate::objects::CommentObject::Cluster(cluster_id.into_proto())
464            }
465            CommentObjectId::ClusterReplica((cluster_id, replica_id)) => {
466                let cluster_replica_id = crate::objects::ClusterReplicaId {
467                    cluster_id: cluster_id.into_proto(),
468                    replica_id: replica_id.into_proto(),
469                };
470                crate::objects::CommentObject::ClusterReplica(cluster_replica_id)
471            }
472        }
473    }
474
475    fn from_proto(proto: crate::objects::CommentObject) -> Result<Self, TryFromProtoError> {
476        let id = match proto {
477            crate::objects::CommentObject::Table(item_id) => {
478                CommentObjectId::Table(item_id.into_rust()?)
479            }
480            crate::objects::CommentObject::View(item_id) => {
481                CommentObjectId::View(item_id.into_rust()?)
482            }
483            crate::objects::CommentObject::MaterializedView(item_id) => {
484                CommentObjectId::MaterializedView(item_id.into_rust()?)
485            }
486            crate::objects::CommentObject::Source(item_id) => {
487                CommentObjectId::Source(item_id.into_rust()?)
488            }
489            crate::objects::CommentObject::Sink(item_id) => {
490                CommentObjectId::Sink(item_id.into_rust()?)
491            }
492            crate::objects::CommentObject::Index(item_id) => {
493                CommentObjectId::Index(item_id.into_rust()?)
494            }
495            crate::objects::CommentObject::Func(item_id) => {
496                CommentObjectId::Func(item_id.into_rust()?)
497            }
498            crate::objects::CommentObject::Connection(item_id) => {
499                CommentObjectId::Connection(item_id.into_rust()?)
500            }
501            crate::objects::CommentObject::Type(item_id) => {
502                CommentObjectId::Type(item_id.into_rust()?)
503            }
504            crate::objects::CommentObject::Secret(item_id) => {
505                CommentObjectId::Secret(item_id.into_rust()?)
506            }
507            crate::objects::CommentObject::ContinualTask(item_id) => {
508                CommentObjectId::ContinualTask(item_id.into_rust()?)
509            }
510            crate::objects::CommentObject::NetworkPolicy(global_id) => {
511                CommentObjectId::NetworkPolicy(global_id.into_rust()?)
512            }
513            crate::objects::CommentObject::Role(role_id) => {
514                CommentObjectId::Role(role_id.into_rust()?)
515            }
516            crate::objects::CommentObject::Database(database_id) => {
517                CommentObjectId::Database(database_id.into_rust()?)
518            }
519            crate::objects::CommentObject::Schema(resolved_schema) => {
520                let database = resolved_schema.database.into_rust()?;
521                let schema = resolved_schema.schema.into_rust()?;
522                CommentObjectId::Schema((database, schema))
523            }
524            crate::objects::CommentObject::Cluster(cluster_id) => {
525                CommentObjectId::Cluster(cluster_id.into_rust()?)
526            }
527            crate::objects::CommentObject::ClusterReplica(cluster_replica_id) => {
528                let cluster_id = cluster_replica_id.cluster_id.into_rust()?;
529                let replica_id = cluster_replica_id.replica_id.into_rust()?;
530                CommentObjectId::ClusterReplica((cluster_id, replica_id))
531            }
532        };
533        Ok(id)
534    }
535}
536
537impl RustType<crate::objects::EpochMillis> for u64 {
538    fn into_proto(&self) -> crate::objects::EpochMillis {
539        crate::objects::EpochMillis { millis: *self }
540    }
541
542    fn from_proto(proto: crate::objects::EpochMillis) -> Result<Self, TryFromProtoError> {
543        Ok(proto.millis)
544    }
545}
546
547impl RustType<crate::objects::CatalogItemId> for CatalogItemId {
548    fn into_proto(&self) -> crate::objects::CatalogItemId {
549        match self {
550            CatalogItemId::System(x) => crate::objects::CatalogItemId::System(*x),
551            CatalogItemId::IntrospectionSourceIndex(x) => {
552                crate::objects::CatalogItemId::IntrospectionSourceIndex(*x)
553            }
554            CatalogItemId::User(x) => crate::objects::CatalogItemId::User(*x),
555            CatalogItemId::Transient(x) => crate::objects::CatalogItemId::Transient(*x),
556        }
557    }
558
559    fn from_proto(proto: crate::objects::CatalogItemId) -> Result<Self, TryFromProtoError> {
560        match proto {
561            crate::objects::CatalogItemId::System(x) => Ok(CatalogItemId::System(x)),
562            crate::objects::CatalogItemId::IntrospectionSourceIndex(x) => {
563                Ok(CatalogItemId::IntrospectionSourceIndex(x))
564            }
565            crate::objects::CatalogItemId::User(x) => Ok(CatalogItemId::User(x)),
566            crate::objects::CatalogItemId::Transient(x) => Ok(CatalogItemId::Transient(x)),
567        }
568    }
569}
570
571impl RustType<crate::objects::GlobalId> for GlobalId {
572    fn into_proto(&self) -> crate::objects::GlobalId {
573        match self {
574            GlobalId::System(x) => crate::objects::GlobalId::System(*x),
575            GlobalId::IntrospectionSourceIndex(x) => {
576                crate::objects::GlobalId::IntrospectionSourceIndex(*x)
577            }
578            GlobalId::User(x) => crate::objects::GlobalId::User(*x),
579            GlobalId::Transient(x) => crate::objects::GlobalId::Transient(*x),
580            GlobalId::Explain => crate::objects::GlobalId::Explain,
581        }
582    }
583
584    fn from_proto(proto: crate::objects::GlobalId) -> Result<Self, TryFromProtoError> {
585        match proto {
586            crate::objects::GlobalId::System(x) => Ok(GlobalId::System(x)),
587            crate::objects::GlobalId::IntrospectionSourceIndex(x) => {
588                Ok(GlobalId::IntrospectionSourceIndex(x))
589            }
590            crate::objects::GlobalId::User(x) => Ok(GlobalId::User(x)),
591            crate::objects::GlobalId::Transient(x) => Ok(GlobalId::Transient(x)),
592            crate::objects::GlobalId::Explain => Ok(GlobalId::Explain),
593        }
594    }
595}
596
597impl RustType<crate::objects::ClusterId> for StorageInstanceId {
598    fn into_proto(&self) -> crate::objects::ClusterId {
599        match self {
600            StorageInstanceId::User(id) => crate::objects::ClusterId::User(*id),
601            StorageInstanceId::System(id) => crate::objects::ClusterId::System(*id),
602        }
603    }
604
605    fn from_proto(proto: crate::objects::ClusterId) -> Result<Self, TryFromProtoError> {
606        let id = match proto {
607            crate::objects::ClusterId::User(id) => {
608                StorageInstanceId::user(id).ok_or_else(|| {
609                    TryFromProtoError::InvalidPersistState(format!(
610                        "{id} is not a valid StorageInstanceId"
611                    ))
612                })?
613            }
614            crate::objects::ClusterId::System(id) => {
615                StorageInstanceId::system(id).ok_or_else(|| {
616                    TryFromProtoError::InvalidPersistState(format!(
617                        "{id} is not a valid StorageInstanceId"
618                    ))
619                })?
620            }
621        };
622        Ok(id)
623    }
624}
625
626impl RustType<crate::objects::ReplicaId> for ReplicaId {
627    fn into_proto(&self) -> crate::objects::ReplicaId {
628        match self {
629            Self::System(id) => crate::objects::ReplicaId::System(*id),
630            Self::User(id) => crate::objects::ReplicaId::User(*id),
631        }
632    }
633
634    fn from_proto(proto: crate::objects::ReplicaId) -> Result<Self, TryFromProtoError> {
635        match proto {
636            crate::objects::ReplicaId::System(id) => Ok(Self::System(id)),
637            crate::objects::ReplicaId::User(id) => Ok(Self::User(id)),
638        }
639    }
640}
641
642impl ProtoMapEntry<String, String> for crate::objects::OptimizerFeatureOverride {
643    fn from_rust<'a>(entry: (&'a String, &'a String)) -> Self {
644        crate::objects::OptimizerFeatureOverride {
645            name: entry.0.into_proto(),
646            value: entry.1.into_proto(),
647        }
648    }
649
650    fn into_rust(self) -> Result<(String, String), TryFromProtoError> {
651        Ok((self.name.into_rust()?, self.value.into_rust()?))
652    }
653}
654
655impl RustType<crate::objects::ClusterSchedule> for ClusterSchedule {
656    fn into_proto(&self) -> crate::objects::ClusterSchedule {
657        match self {
658            ClusterSchedule::Manual => crate::objects::ClusterSchedule::Manual,
659            ClusterSchedule::Refresh {
660                hydration_time_estimate,
661            } => crate::objects::ClusterSchedule::Refresh(
662                crate::objects::ClusterScheduleRefreshOptions {
663                    rehydration_time_estimate: hydration_time_estimate.into_proto(),
664                },
665            ),
666        }
667    }
668
669    fn from_proto(proto: crate::objects::ClusterSchedule) -> Result<Self, TryFromProtoError> {
670        match proto {
671            crate::objects::ClusterSchedule::Manual => Ok(ClusterSchedule::Manual),
672            crate::objects::ClusterSchedule::Refresh(csro) => Ok(ClusterSchedule::Refresh {
673                hydration_time_estimate: csro.rehydration_time_estimate.into_rust()?,
674            }),
675        }
676    }
677}
678
679impl RustType<crate::objects::ReplicaLogging> for ComputeReplicaLogging {
680    fn into_proto(&self) -> crate::objects::ReplicaLogging {
681        crate::objects::ReplicaLogging {
682            log_logging: self.log_logging,
683            interval: self.interval.into_proto(),
684        }
685    }
686
687    fn from_proto(proto: crate::objects::ReplicaLogging) -> Result<Self, TryFromProtoError> {
688        Ok(ComputeReplicaLogging {
689            log_logging: proto.log_logging,
690            interval: proto.interval.into_rust()?,
691        })
692    }
693}
694
695impl RustType<crate::objects::Version> for RelationVersion {
696    fn into_proto(&self) -> crate::objects::Version {
697        crate::objects::Version {
698            value: self.into_raw(),
699        }
700    }
701
702    fn from_proto(proto: crate::objects::Version) -> Result<Self, TryFromProtoError> {
703        Ok(RelationVersion::from_raw(proto.value))
704    }
705}
706
707impl RustType<crate::objects::NetworkPolicyRule> for NetworkPolicyRule {
708    fn into_proto(&self) -> crate::objects::NetworkPolicyRule {
709        crate::objects::NetworkPolicyRule {
710            name: self.name.clone(),
711            action: match self.action {
712                NetworkPolicyRuleAction::Allow => crate::objects::NetworkPolicyRuleAction::Allow,
713            },
714            direction: match self.direction {
715                NetworkPolicyRuleDirection::Ingress => {
716                    crate::objects::NetworkPolicyRuleDirection::Ingress
717                }
718            },
719            address: self.address.clone().to_string(),
720        }
721    }
722
723    fn from_proto(proto: crate::objects::NetworkPolicyRule) -> Result<Self, TryFromProtoError> {
724        Ok(NetworkPolicyRule {
725            name: proto.name,
726            action: match proto.action {
727                crate::objects::NetworkPolicyRuleAction::Allow => NetworkPolicyRuleAction::Allow,
728            },
729            address: PolicyAddress::from(proto.address),
730            direction: match proto.direction {
731                crate::objects::NetworkPolicyRuleDirection::Ingress => {
732                    NetworkPolicyRuleDirection::Ingress
733                }
734            },
735        })
736    }
737}
mz_catalog_protos/serialization.rs

mz_catalog_protos/
serialization.rs
