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        }
227    }
228
229    fn from_proto(proto: crate::objects::CatalogItemType) -> Result<Self, TryFromProtoError> {
230        let item_type = match proto {
231            crate::objects::CatalogItemType::Table => CatalogItemType::Table,
232            crate::objects::CatalogItemType::Source => CatalogItemType::Source,
233            crate::objects::CatalogItemType::Sink => CatalogItemType::Sink,
234            crate::objects::CatalogItemType::View => CatalogItemType::View,
235            crate::objects::CatalogItemType::MaterializedView => CatalogItemType::MaterializedView,
236            crate::objects::CatalogItemType::Index => CatalogItemType::Index,
237            crate::objects::CatalogItemType::Type => CatalogItemType::Type,
238            crate::objects::CatalogItemType::Func => CatalogItemType::Func,
239            crate::objects::CatalogItemType::Secret => CatalogItemType::Secret,
240            crate::objects::CatalogItemType::Connection => CatalogItemType::Connection,
241            crate::objects::CatalogItemType::Unknown => {
242                return Err(TryFromProtoError::unknown_enum_variant("CatalogItemType"));
243            }
244        };
245        Ok(item_type)
246    }
247}
248
249impl RustType<crate::objects::ObjectType> for ObjectType {
250    fn into_proto(&self) -> crate::objects::ObjectType {
251        match self {
252            ObjectType::Table => crate::objects::ObjectType::Table,
253            ObjectType::View => crate::objects::ObjectType::View,
254            ObjectType::MaterializedView => crate::objects::ObjectType::MaterializedView,
255            ObjectType::Source => crate::objects::ObjectType::Source,
256            ObjectType::Sink => crate::objects::ObjectType::Sink,
257            ObjectType::Index => crate::objects::ObjectType::Index,
258            ObjectType::Type => crate::objects::ObjectType::Type,
259            ObjectType::Role => crate::objects::ObjectType::Role,
260            ObjectType::Cluster => crate::objects::ObjectType::Cluster,
261            ObjectType::ClusterReplica => crate::objects::ObjectType::ClusterReplica,
262            ObjectType::Secret => crate::objects::ObjectType::Secret,
263            ObjectType::Connection => crate::objects::ObjectType::Connection,
264            ObjectType::Database => crate::objects::ObjectType::Database,
265            ObjectType::Schema => crate::objects::ObjectType::Schema,
266            ObjectType::Func => crate::objects::ObjectType::Func,
267            ObjectType::NetworkPolicy => crate::objects::ObjectType::NetworkPolicy,
268        }
269    }
270
271    fn from_proto(proto: crate::objects::ObjectType) -> Result<Self, TryFromProtoError> {
272        match proto {
273            crate::objects::ObjectType::Table => Ok(ObjectType::Table),
274            crate::objects::ObjectType::View => Ok(ObjectType::View),
275            crate::objects::ObjectType::MaterializedView => Ok(ObjectType::MaterializedView),
276            crate::objects::ObjectType::Source => Ok(ObjectType::Source),
277            crate::objects::ObjectType::Sink => Ok(ObjectType::Sink),
278            crate::objects::ObjectType::Index => Ok(ObjectType::Index),
279            crate::objects::ObjectType::Type => Ok(ObjectType::Type),
280            crate::objects::ObjectType::Role => Ok(ObjectType::Role),
281            crate::objects::ObjectType::Cluster => Ok(ObjectType::Cluster),
282            crate::objects::ObjectType::ClusterReplica => Ok(ObjectType::ClusterReplica),
283            crate::objects::ObjectType::Secret => Ok(ObjectType::Secret),
284            crate::objects::ObjectType::Connection => Ok(ObjectType::Connection),
285            crate::objects::ObjectType::Database => Ok(ObjectType::Database),
286            crate::objects::ObjectType::Schema => Ok(ObjectType::Schema),
287            crate::objects::ObjectType::Func => Ok(ObjectType::Func),
288            crate::objects::ObjectType::NetworkPolicy => Ok(ObjectType::NetworkPolicy),
289            crate::objects::ObjectType::Unknown => Err(TryFromProtoError::unknown_enum_variant(
290                "ObjectType::Unknown",
291            )),
292        }
293    }
294}
295
296impl RustType<crate::objects::RoleMembership> for RoleMembership {
297    fn into_proto(&self) -> crate::objects::RoleMembership {
298        crate::objects::RoleMembership {
299            map: self
300                .map
301                .iter()
302                .map(|(key, val)| crate::objects::RoleMembershipEntry {
303                    key: key.into_proto(),
304                    value: val.into_proto(),
305                })
306                .collect(),
307        }
308    }
309
310    fn from_proto(proto: crate::objects::RoleMembership) -> Result<Self, TryFromProtoError> {
311        Ok(RoleMembership {
312            map: proto
313                .map
314                .into_iter()
315                .map(|e| {
316                    let key = e.key.into_rust()?;
317                    let val = e.value.into_rust()?;
318
319                    Ok((key, val))
320                })
321                .collect::<Result<_, TryFromProtoError>>()?,
322        })
323    }
324}
325
326impl RustType<crate::objects::ResolvedDatabaseSpecifier> for ResolvedDatabaseSpecifier {
327    fn into_proto(&self) -> crate::objects::ResolvedDatabaseSpecifier {
328        match self {
329            ResolvedDatabaseSpecifier::Ambient => {
330                crate::objects::ResolvedDatabaseSpecifier::Ambient
331            }
332            ResolvedDatabaseSpecifier::Id(database_id) => {
333                crate::objects::ResolvedDatabaseSpecifier::Id(database_id.into_proto())
334            }
335        }
336    }
337
338    fn from_proto(
339        proto: crate::objects::ResolvedDatabaseSpecifier,
340    ) -> Result<Self, TryFromProtoError> {
341        let spec = match proto {
342            crate::objects::ResolvedDatabaseSpecifier::Ambient => {
343                ResolvedDatabaseSpecifier::Ambient
344            }
345            crate::objects::ResolvedDatabaseSpecifier::Id(database_id) => {
346                ResolvedDatabaseSpecifier::Id(database_id.into_rust()?)
347            }
348        };
349        Ok(spec)
350    }
351}
352
353impl RustType<crate::objects::SchemaSpecifier> for SchemaSpecifier {
354    fn into_proto(&self) -> crate::objects::SchemaSpecifier {
355        match self {
356            SchemaSpecifier::Temporary => crate::objects::SchemaSpecifier::Temporary,
357            SchemaSpecifier::Id(schema_id) => {
358                crate::objects::SchemaSpecifier::Id(schema_id.into_proto())
359            }
360        }
361    }
362
363    fn from_proto(proto: crate::objects::SchemaSpecifier) -> Result<Self, TryFromProtoError> {
364        let spec = match proto {
365            crate::objects::SchemaSpecifier::Temporary => SchemaSpecifier::Temporary,
366            crate::objects::SchemaSpecifier::Id(schema_id) => {
367                SchemaSpecifier::Id(schema_id.into_rust()?)
368            }
369        };
370        Ok(spec)
371    }
372}
373
374impl RustType<crate::objects::SchemaId> for SchemaId {
375    fn into_proto(&self) -> crate::objects::SchemaId {
376        match self {
377            SchemaId::User(id) => crate::objects::SchemaId::User(*id),
378            SchemaId::System(id) => crate::objects::SchemaId::System(*id),
379        }
380    }
381
382    fn from_proto(proto: crate::objects::SchemaId) -> Result<Self, TryFromProtoError> {
383        let id = match proto {
384            crate::objects::SchemaId::User(id) => SchemaId::User(id),
385            crate::objects::SchemaId::System(id) => SchemaId::System(id),
386        };
387        Ok(id)
388    }
389}
390
391impl RustType<crate::objects::DatabaseId> for DatabaseId {
392    fn into_proto(&self) -> crate::objects::DatabaseId {
393        match self {
394            DatabaseId::User(id) => crate::objects::DatabaseId::User(*id),
395            DatabaseId::System(id) => crate::objects::DatabaseId::System(*id),
396        }
397    }
398
399    fn from_proto(proto: crate::objects::DatabaseId) -> Result<Self, TryFromProtoError> {
400        match proto {
401            crate::objects::DatabaseId::User(id) => Ok(DatabaseId::User(id)),
402            crate::objects::DatabaseId::System(id) => Ok(DatabaseId::System(id)),
403        }
404    }
405}
406
407impl RustType<crate::objects::CommentObject> for CommentObjectId {
408    fn into_proto(&self) -> crate::objects::CommentObject {
409        match self {
410            CommentObjectId::Table(global_id) => {
411                crate::objects::CommentObject::Table(global_id.into_proto())
412            }
413            CommentObjectId::View(global_id) => {
414                crate::objects::CommentObject::View(global_id.into_proto())
415            }
416            CommentObjectId::MaterializedView(global_id) => {
417                crate::objects::CommentObject::MaterializedView(global_id.into_proto())
418            }
419            CommentObjectId::Source(global_id) => {
420                crate::objects::CommentObject::Source(global_id.into_proto())
421            }
422            CommentObjectId::Sink(global_id) => {
423                crate::objects::CommentObject::Sink(global_id.into_proto())
424            }
425            CommentObjectId::Index(global_id) => {
426                crate::objects::CommentObject::Index(global_id.into_proto())
427            }
428            CommentObjectId::Func(global_id) => {
429                crate::objects::CommentObject::Func(global_id.into_proto())
430            }
431            CommentObjectId::Connection(global_id) => {
432                crate::objects::CommentObject::Connection(global_id.into_proto())
433            }
434            CommentObjectId::Type(global_id) => {
435                crate::objects::CommentObject::Type(global_id.into_proto())
436            }
437            CommentObjectId::Secret(global_id) => {
438                crate::objects::CommentObject::Secret(global_id.into_proto())
439            }
440            CommentObjectId::Role(role_id) => {
441                crate::objects::CommentObject::Role(role_id.into_proto())
442            }
443            CommentObjectId::Database(database_id) => {
444                crate::objects::CommentObject::Database(database_id.into_proto())
445            }
446            CommentObjectId::NetworkPolicy(network_policy_id) => {
447                crate::objects::CommentObject::NetworkPolicy(network_policy_id.into_proto())
448            }
449            CommentObjectId::Schema((database, schema)) => {
450                crate::objects::CommentObject::Schema(crate::objects::ResolvedSchema {
451                    database: database.into_proto(),
452                    schema: schema.into_proto(),
453                })
454            }
455            CommentObjectId::Cluster(cluster_id) => {
456                crate::objects::CommentObject::Cluster(cluster_id.into_proto())
457            }
458            CommentObjectId::ClusterReplica((cluster_id, replica_id)) => {
459                let cluster_replica_id = crate::objects::ClusterReplicaId {
460                    cluster_id: cluster_id.into_proto(),
461                    replica_id: replica_id.into_proto(),
462                };
463                crate::objects::CommentObject::ClusterReplica(cluster_replica_id)
464            }
465        }
466    }
467
468    fn from_proto(proto: crate::objects::CommentObject) -> Result<Self, TryFromProtoError> {
469        let id = match proto {
470            crate::objects::CommentObject::Table(item_id) => {
471                CommentObjectId::Table(item_id.into_rust()?)
472            }
473            crate::objects::CommentObject::View(item_id) => {
474                CommentObjectId::View(item_id.into_rust()?)
475            }
476            crate::objects::CommentObject::MaterializedView(item_id) => {
477                CommentObjectId::MaterializedView(item_id.into_rust()?)
478            }
479            crate::objects::CommentObject::Source(item_id) => {
480                CommentObjectId::Source(item_id.into_rust()?)
481            }
482            crate::objects::CommentObject::Sink(item_id) => {
483                CommentObjectId::Sink(item_id.into_rust()?)
484            }
485            crate::objects::CommentObject::Index(item_id) => {
486                CommentObjectId::Index(item_id.into_rust()?)
487            }
488            crate::objects::CommentObject::Func(item_id) => {
489                CommentObjectId::Func(item_id.into_rust()?)
490            }
491            crate::objects::CommentObject::Connection(item_id) => {
492                CommentObjectId::Connection(item_id.into_rust()?)
493            }
494            crate::objects::CommentObject::Type(item_id) => {
495                CommentObjectId::Type(item_id.into_rust()?)
496            }
497            crate::objects::CommentObject::Secret(item_id) => {
498                CommentObjectId::Secret(item_id.into_rust()?)
499            }
500            crate::objects::CommentObject::NetworkPolicy(global_id) => {
501                CommentObjectId::NetworkPolicy(global_id.into_rust()?)
502            }
503            crate::objects::CommentObject::Role(role_id) => {
504                CommentObjectId::Role(role_id.into_rust()?)
505            }
506            crate::objects::CommentObject::Database(database_id) => {
507                CommentObjectId::Database(database_id.into_rust()?)
508            }
509            crate::objects::CommentObject::Schema(resolved_schema) => {
510                let database = resolved_schema.database.into_rust()?;
511                let schema = resolved_schema.schema.into_rust()?;
512                CommentObjectId::Schema((database, schema))
513            }
514            crate::objects::CommentObject::Cluster(cluster_id) => {
515                CommentObjectId::Cluster(cluster_id.into_rust()?)
516            }
517            crate::objects::CommentObject::ClusterReplica(cluster_replica_id) => {
518                let cluster_id = cluster_replica_id.cluster_id.into_rust()?;
519                let replica_id = cluster_replica_id.replica_id.into_rust()?;
520                CommentObjectId::ClusterReplica((cluster_id, replica_id))
521            }
522        };
523        Ok(id)
524    }
525}
526
527impl RustType<crate::objects::EpochMillis> for u64 {
528    fn into_proto(&self) -> crate::objects::EpochMillis {
529        crate::objects::EpochMillis { millis: *self }
530    }
531
532    fn from_proto(proto: crate::objects::EpochMillis) -> Result<Self, TryFromProtoError> {
533        Ok(proto.millis)
534    }
535}
536
537impl RustType<crate::objects::CatalogItemId> for CatalogItemId {
538    fn into_proto(&self) -> crate::objects::CatalogItemId {
539        match self {
540            CatalogItemId::System(x) => crate::objects::CatalogItemId::System(*x),
541            CatalogItemId::IntrospectionSourceIndex(x) => {
542                crate::objects::CatalogItemId::IntrospectionSourceIndex(*x)
543            }
544            CatalogItemId::User(x) => crate::objects::CatalogItemId::User(*x),
545            CatalogItemId::Transient(x) => crate::objects::CatalogItemId::Transient(*x),
546        }
547    }
548
549    fn from_proto(proto: crate::objects::CatalogItemId) -> Result<Self, TryFromProtoError> {
550        match proto {
551            crate::objects::CatalogItemId::System(x) => Ok(CatalogItemId::System(x)),
552            crate::objects::CatalogItemId::IntrospectionSourceIndex(x) => {
553                Ok(CatalogItemId::IntrospectionSourceIndex(x))
554            }
555            crate::objects::CatalogItemId::User(x) => Ok(CatalogItemId::User(x)),
556            crate::objects::CatalogItemId::Transient(x) => Ok(CatalogItemId::Transient(x)),
557        }
558    }
559}
560
561impl RustType<crate::objects::GlobalId> for GlobalId {
562    fn into_proto(&self) -> crate::objects::GlobalId {
563        match self {
564            GlobalId::System(x) => crate::objects::GlobalId::System(*x),
565            GlobalId::IntrospectionSourceIndex(x) => {
566                crate::objects::GlobalId::IntrospectionSourceIndex(*x)
567            }
568            GlobalId::User(x) => crate::objects::GlobalId::User(*x),
569            GlobalId::Transient(x) => crate::objects::GlobalId::Transient(*x),
570            GlobalId::Explain => crate::objects::GlobalId::Explain,
571        }
572    }
573
574    fn from_proto(proto: crate::objects::GlobalId) -> Result<Self, TryFromProtoError> {
575        match proto {
576            crate::objects::GlobalId::System(x) => Ok(GlobalId::System(x)),
577            crate::objects::GlobalId::IntrospectionSourceIndex(x) => {
578                Ok(GlobalId::IntrospectionSourceIndex(x))
579            }
580            crate::objects::GlobalId::User(x) => Ok(GlobalId::User(x)),
581            crate::objects::GlobalId::Transient(x) => Ok(GlobalId::Transient(x)),
582            crate::objects::GlobalId::Explain => Ok(GlobalId::Explain),
583        }
584    }
585}
586
587impl RustType<crate::objects::ClusterId> for StorageInstanceId {
588    fn into_proto(&self) -> crate::objects::ClusterId {
589        match self {
590            StorageInstanceId::User(id) => crate::objects::ClusterId::User(*id),
591            StorageInstanceId::System(id) => crate::objects::ClusterId::System(*id),
592        }
593    }
594
595    fn from_proto(proto: crate::objects::ClusterId) -> Result<Self, TryFromProtoError> {
596        let id = match proto {
597            crate::objects::ClusterId::User(id) => {
598                StorageInstanceId::user(id).ok_or_else(|| {
599                    TryFromProtoError::InvalidPersistState(format!(
600                        "{id} is not a valid StorageInstanceId"
601                    ))
602                })?
603            }
604            crate::objects::ClusterId::System(id) => {
605                StorageInstanceId::system(id).ok_or_else(|| {
606                    TryFromProtoError::InvalidPersistState(format!(
607                        "{id} is not a valid StorageInstanceId"
608                    ))
609                })?
610            }
611        };
612        Ok(id)
613    }
614}
615
616impl RustType<crate::objects::ReplicaId> for ReplicaId {
617    fn into_proto(&self) -> crate::objects::ReplicaId {
618        match self {
619            Self::System(id) => crate::objects::ReplicaId::System(*id),
620            Self::User(id) => crate::objects::ReplicaId::User(*id),
621        }
622    }
623
624    fn from_proto(proto: crate::objects::ReplicaId) -> Result<Self, TryFromProtoError> {
625        match proto {
626            crate::objects::ReplicaId::System(id) => Ok(Self::System(id)),
627            crate::objects::ReplicaId::User(id) => Ok(Self::User(id)),
628        }
629    }
630}
631
632impl ProtoMapEntry<String, String> for crate::objects::OptimizerFeatureOverride {
633    fn from_rust<'a>(entry: (&'a String, &'a String)) -> Self {
634        crate::objects::OptimizerFeatureOverride {
635            name: entry.0.into_proto(),
636            value: entry.1.into_proto(),
637        }
638    }
639
640    fn into_rust(self) -> Result<(String, String), TryFromProtoError> {
641        Ok((self.name.into_rust()?, self.value.into_rust()?))
642    }
643}
644
645impl RustType<crate::objects::ClusterSchedule> for ClusterSchedule {
646    fn into_proto(&self) -> crate::objects::ClusterSchedule {
647        match self {
648            ClusterSchedule::Manual => crate::objects::ClusterSchedule::Manual,
649            ClusterSchedule::Refresh {
650                hydration_time_estimate,
651            } => crate::objects::ClusterSchedule::Refresh(
652                crate::objects::ClusterScheduleRefreshOptions {
653                    rehydration_time_estimate: hydration_time_estimate.into_proto(),
654                },
655            ),
656        }
657    }
658
659    fn from_proto(proto: crate::objects::ClusterSchedule) -> Result<Self, TryFromProtoError> {
660        match proto {
661            crate::objects::ClusterSchedule::Manual => Ok(ClusterSchedule::Manual),
662            crate::objects::ClusterSchedule::Refresh(csro) => Ok(ClusterSchedule::Refresh {
663                hydration_time_estimate: csro.rehydration_time_estimate.into_rust()?,
664            }),
665        }
666    }
667}
668
669impl RustType<crate::objects::ReplicaLogging> for ComputeReplicaLogging {
670    fn into_proto(&self) -> crate::objects::ReplicaLogging {
671        crate::objects::ReplicaLogging {
672            log_logging: self.log_logging,
673            interval: self.interval.into_proto(),
674        }
675    }
676
677    fn from_proto(proto: crate::objects::ReplicaLogging) -> Result<Self, TryFromProtoError> {
678        Ok(ComputeReplicaLogging {
679            log_logging: proto.log_logging,
680            interval: proto.interval.into_rust()?,
681        })
682    }
683}
684
685impl RustType<crate::objects::Version> for RelationVersion {
686    fn into_proto(&self) -> crate::objects::Version {
687        crate::objects::Version {
688            value: self.into_raw(),
689        }
690    }
691
692    fn from_proto(proto: crate::objects::Version) -> Result<Self, TryFromProtoError> {
693        Ok(RelationVersion::from_raw(proto.value))
694    }
695}
696
697impl RustType<crate::objects::NetworkPolicyRule> for NetworkPolicyRule {
698    fn into_proto(&self) -> crate::objects::NetworkPolicyRule {
699        crate::objects::NetworkPolicyRule {
700            name: self.name.clone(),
701            action: match self.action {
702                NetworkPolicyRuleAction::Allow => crate::objects::NetworkPolicyRuleAction::Allow,
703            },
704            direction: match self.direction {
705                NetworkPolicyRuleDirection::Ingress => {
706                    crate::objects::NetworkPolicyRuleDirection::Ingress
707                }
708            },
709            address: self.address.clone().to_string(),
710        }
711    }
712
713    fn from_proto(proto: crate::objects::NetworkPolicyRule) -> Result<Self, TryFromProtoError> {
714        Ok(NetworkPolicyRule {
715            name: proto.name,
716            action: match proto.action {
717                crate::objects::NetworkPolicyRuleAction::Allow => NetworkPolicyRuleAction::Allow,
718            },
719            address: PolicyAddress::from(proto.address),
720            direction: match proto.direction {
721                crate::objects::NetworkPolicyRuleDirection::Ingress => {
722                    NetworkPolicyRuleDirection::Ingress
723                }
724            },
725        })
726    }
727}
mz_catalog_protos/serialization.rs

mz_catalog_protos/
serialization.rs
