1use crate::catalog::*;
2impl serde::Serialize for ColIndexMapping {
3 #[allow(deprecated)]
4 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5 where
6 S: serde::Serializer,
7 {
8 use serde::ser::SerializeStruct;
9 let mut len = 0;
10 if self.target_size != 0 {
11 len += 1;
12 }
13 if !self.map.is_empty() {
14 len += 1;
15 }
16 let mut struct_ser = serializer.serialize_struct("catalog.ColIndexMapping", len)?;
17 if self.target_size != 0 {
18 #[allow(clippy::needless_borrow)]
19 #[allow(clippy::needless_borrows_for_generic_args)]
20 struct_ser.serialize_field("targetSize", ToString::to_string(&self.target_size).as_str())?;
21 }
22 if !self.map.is_empty() {
23 struct_ser.serialize_field("map", &self.map.iter().map(ToString::to_string).collect::<Vec<_>>())?;
24 }
25 struct_ser.end()
26 }
27}
28impl<'de> serde::Deserialize<'de> for ColIndexMapping {
29 #[allow(deprecated)]
30 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
31 where
32 D: serde::Deserializer<'de>,
33 {
34 const FIELDS: &[&str] = &[
35 "target_size",
36 "targetSize",
37 "map",
38 ];
39
40 #[allow(clippy::enum_variant_names)]
41 enum GeneratedField {
42 TargetSize,
43 Map,
44 }
45 impl<'de> serde::Deserialize<'de> for GeneratedField {
46 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
47 where
48 D: serde::Deserializer<'de>,
49 {
50 struct GeneratedVisitor;
51
52 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
53 type Value = GeneratedField;
54
55 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
56 write!(formatter, "expected one of: {:?}", &FIELDS)
57 }
58
59 #[allow(unused_variables)]
60 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
61 where
62 E: serde::de::Error,
63 {
64 match value {
65 "targetSize" | "target_size" => Ok(GeneratedField::TargetSize),
66 "map" => Ok(GeneratedField::Map),
67 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
68 }
69 }
70 }
71 deserializer.deserialize_identifier(GeneratedVisitor)
72 }
73 }
74 struct GeneratedVisitor;
75 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
76 type Value = ColIndexMapping;
77
78 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
79 formatter.write_str("struct catalog.ColIndexMapping")
80 }
81
82 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ColIndexMapping, V::Error>
83 where
84 V: serde::de::MapAccess<'de>,
85 {
86 let mut target_size__ = None;
87 let mut map__ = None;
88 while let Some(k) = map_.next_key()? {
89 match k {
90 GeneratedField::TargetSize => {
91 if target_size__.is_some() {
92 return Err(serde::de::Error::duplicate_field("targetSize"));
93 }
94 target_size__ =
95 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
96 ;
97 }
98 GeneratedField::Map => {
99 if map__.is_some() {
100 return Err(serde::de::Error::duplicate_field("map"));
101 }
102 map__ =
103 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
104 .into_iter().map(|x| x.0).collect())
105 ;
106 }
107 }
108 }
109 Ok(ColIndexMapping {
110 target_size: target_size__.unwrap_or_default(),
111 map: map__.unwrap_or_default(),
112 })
113 }
114 }
115 deserializer.deserialize_struct("catalog.ColIndexMapping", FIELDS, GeneratedVisitor)
116 }
117}
118impl serde::Serialize for Comment {
119 #[allow(deprecated)]
120 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
121 where
122 S: serde::Serializer,
123 {
124 use serde::ser::SerializeStruct;
125 let mut len = 0;
126 if self.table_id != 0 {
127 len += 1;
128 }
129 if self.schema_id != 0 {
130 len += 1;
131 }
132 if self.database_id != 0 {
133 len += 1;
134 }
135 if self.column_index.is_some() {
136 len += 1;
137 }
138 if self.description.is_some() {
139 len += 1;
140 }
141 let mut struct_ser = serializer.serialize_struct("catalog.Comment", len)?;
142 if self.table_id != 0 {
143 struct_ser.serialize_field("tableId", &self.table_id)?;
144 }
145 if self.schema_id != 0 {
146 struct_ser.serialize_field("schemaId", &self.schema_id)?;
147 }
148 if self.database_id != 0 {
149 struct_ser.serialize_field("databaseId", &self.database_id)?;
150 }
151 if let Some(v) = self.column_index.as_ref() {
152 struct_ser.serialize_field("columnIndex", v)?;
153 }
154 if let Some(v) = self.description.as_ref() {
155 struct_ser.serialize_field("description", v)?;
156 }
157 struct_ser.end()
158 }
159}
160impl<'de> serde::Deserialize<'de> for Comment {
161 #[allow(deprecated)]
162 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
163 where
164 D: serde::Deserializer<'de>,
165 {
166 const FIELDS: &[&str] = &[
167 "table_id",
168 "tableId",
169 "schema_id",
170 "schemaId",
171 "database_id",
172 "databaseId",
173 "column_index",
174 "columnIndex",
175 "description",
176 ];
177
178 #[allow(clippy::enum_variant_names)]
179 enum GeneratedField {
180 TableId,
181 SchemaId,
182 DatabaseId,
183 ColumnIndex,
184 Description,
185 }
186 impl<'de> serde::Deserialize<'de> for GeneratedField {
187 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
188 where
189 D: serde::Deserializer<'de>,
190 {
191 struct GeneratedVisitor;
192
193 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
194 type Value = GeneratedField;
195
196 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
197 write!(formatter, "expected one of: {:?}", &FIELDS)
198 }
199
200 #[allow(unused_variables)]
201 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
202 where
203 E: serde::de::Error,
204 {
205 match value {
206 "tableId" | "table_id" => Ok(GeneratedField::TableId),
207 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
208 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
209 "columnIndex" | "column_index" => Ok(GeneratedField::ColumnIndex),
210 "description" => Ok(GeneratedField::Description),
211 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
212 }
213 }
214 }
215 deserializer.deserialize_identifier(GeneratedVisitor)
216 }
217 }
218 struct GeneratedVisitor;
219 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
220 type Value = Comment;
221
222 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
223 formatter.write_str("struct catalog.Comment")
224 }
225
226 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Comment, V::Error>
227 where
228 V: serde::de::MapAccess<'de>,
229 {
230 let mut table_id__ = None;
231 let mut schema_id__ = None;
232 let mut database_id__ = None;
233 let mut column_index__ = None;
234 let mut description__ = None;
235 while let Some(k) = map_.next_key()? {
236 match k {
237 GeneratedField::TableId => {
238 if table_id__.is_some() {
239 return Err(serde::de::Error::duplicate_field("tableId"));
240 }
241 table_id__ =
242 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
243 ;
244 }
245 GeneratedField::SchemaId => {
246 if schema_id__.is_some() {
247 return Err(serde::de::Error::duplicate_field("schemaId"));
248 }
249 schema_id__ =
250 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
251 ;
252 }
253 GeneratedField::DatabaseId => {
254 if database_id__.is_some() {
255 return Err(serde::de::Error::duplicate_field("databaseId"));
256 }
257 database_id__ =
258 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
259 ;
260 }
261 GeneratedField::ColumnIndex => {
262 if column_index__.is_some() {
263 return Err(serde::de::Error::duplicate_field("columnIndex"));
264 }
265 column_index__ =
266 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
267 ;
268 }
269 GeneratedField::Description => {
270 if description__.is_some() {
271 return Err(serde::de::Error::duplicate_field("description"));
272 }
273 description__ = map_.next_value()?;
274 }
275 }
276 }
277 Ok(Comment {
278 table_id: table_id__.unwrap_or_default(),
279 schema_id: schema_id__.unwrap_or_default(),
280 database_id: database_id__.unwrap_or_default(),
281 column_index: column_index__,
282 description: description__,
283 })
284 }
285 }
286 deserializer.deserialize_struct("catalog.Comment", FIELDS, GeneratedVisitor)
287 }
288}
289impl serde::Serialize for Connection {
290 #[allow(deprecated)]
291 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
292 where
293 S: serde::Serializer,
294 {
295 use serde::ser::SerializeStruct;
296 let mut len = 0;
297 if self.id != 0 {
298 len += 1;
299 }
300 if self.schema_id != 0 {
301 len += 1;
302 }
303 if self.database_id != 0 {
304 len += 1;
305 }
306 if !self.name.is_empty() {
307 len += 1;
308 }
309 if self.owner != 0 {
310 len += 1;
311 }
312 if self.info.is_some() {
313 len += 1;
314 }
315 let mut struct_ser = serializer.serialize_struct("catalog.Connection", len)?;
316 if self.id != 0 {
317 struct_ser.serialize_field("id", &self.id)?;
318 }
319 if self.schema_id != 0 {
320 struct_ser.serialize_field("schemaId", &self.schema_id)?;
321 }
322 if self.database_id != 0 {
323 struct_ser.serialize_field("databaseId", &self.database_id)?;
324 }
325 if !self.name.is_empty() {
326 struct_ser.serialize_field("name", &self.name)?;
327 }
328 if self.owner != 0 {
329 struct_ser.serialize_field("owner", &self.owner)?;
330 }
331 if let Some(v) = self.info.as_ref() {
332 match v {
333 connection::Info::PrivateLinkService(v) => {
334 struct_ser.serialize_field("privateLinkService", v)?;
335 }
336 connection::Info::ConnectionParams(v) => {
337 struct_ser.serialize_field("connectionParams", v)?;
338 }
339 }
340 }
341 struct_ser.end()
342 }
343}
344impl<'de> serde::Deserialize<'de> for Connection {
345 #[allow(deprecated)]
346 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
347 where
348 D: serde::Deserializer<'de>,
349 {
350 const FIELDS: &[&str] = &[
351 "id",
352 "schema_id",
353 "schemaId",
354 "database_id",
355 "databaseId",
356 "name",
357 "owner",
358 "private_link_service",
359 "privateLinkService",
360 "connection_params",
361 "connectionParams",
362 ];
363
364 #[allow(clippy::enum_variant_names)]
365 enum GeneratedField {
366 Id,
367 SchemaId,
368 DatabaseId,
369 Name,
370 Owner,
371 PrivateLinkService,
372 ConnectionParams,
373 }
374 impl<'de> serde::Deserialize<'de> for GeneratedField {
375 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
376 where
377 D: serde::Deserializer<'de>,
378 {
379 struct GeneratedVisitor;
380
381 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
382 type Value = GeneratedField;
383
384 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
385 write!(formatter, "expected one of: {:?}", &FIELDS)
386 }
387
388 #[allow(unused_variables)]
389 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
390 where
391 E: serde::de::Error,
392 {
393 match value {
394 "id" => Ok(GeneratedField::Id),
395 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
396 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
397 "name" => Ok(GeneratedField::Name),
398 "owner" => Ok(GeneratedField::Owner),
399 "privateLinkService" | "private_link_service" => Ok(GeneratedField::PrivateLinkService),
400 "connectionParams" | "connection_params" => Ok(GeneratedField::ConnectionParams),
401 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
402 }
403 }
404 }
405 deserializer.deserialize_identifier(GeneratedVisitor)
406 }
407 }
408 struct GeneratedVisitor;
409 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
410 type Value = Connection;
411
412 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
413 formatter.write_str("struct catalog.Connection")
414 }
415
416 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Connection, V::Error>
417 where
418 V: serde::de::MapAccess<'de>,
419 {
420 let mut id__ = None;
421 let mut schema_id__ = None;
422 let mut database_id__ = None;
423 let mut name__ = None;
424 let mut owner__ = None;
425 let mut info__ = None;
426 while let Some(k) = map_.next_key()? {
427 match k {
428 GeneratedField::Id => {
429 if id__.is_some() {
430 return Err(serde::de::Error::duplicate_field("id"));
431 }
432 id__ =
433 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
434 ;
435 }
436 GeneratedField::SchemaId => {
437 if schema_id__.is_some() {
438 return Err(serde::de::Error::duplicate_field("schemaId"));
439 }
440 schema_id__ =
441 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
442 ;
443 }
444 GeneratedField::DatabaseId => {
445 if database_id__.is_some() {
446 return Err(serde::de::Error::duplicate_field("databaseId"));
447 }
448 database_id__ =
449 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
450 ;
451 }
452 GeneratedField::Name => {
453 if name__.is_some() {
454 return Err(serde::de::Error::duplicate_field("name"));
455 }
456 name__ = Some(map_.next_value()?);
457 }
458 GeneratedField::Owner => {
459 if owner__.is_some() {
460 return Err(serde::de::Error::duplicate_field("owner"));
461 }
462 owner__ =
463 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
464 ;
465 }
466 GeneratedField::PrivateLinkService => {
467 if info__.is_some() {
468 return Err(serde::de::Error::duplicate_field("privateLinkService"));
469 }
470 info__ = map_.next_value::<::std::option::Option<_>>()?.map(connection::Info::PrivateLinkService)
471;
472 }
473 GeneratedField::ConnectionParams => {
474 if info__.is_some() {
475 return Err(serde::de::Error::duplicate_field("connectionParams"));
476 }
477 info__ = map_.next_value::<::std::option::Option<_>>()?.map(connection::Info::ConnectionParams)
478;
479 }
480 }
481 }
482 Ok(Connection {
483 id: id__.unwrap_or_default(),
484 schema_id: schema_id__.unwrap_or_default(),
485 database_id: database_id__.unwrap_or_default(),
486 name: name__.unwrap_or_default(),
487 owner: owner__.unwrap_or_default(),
488 info: info__,
489 })
490 }
491 }
492 deserializer.deserialize_struct("catalog.Connection", FIELDS, GeneratedVisitor)
493 }
494}
495impl serde::Serialize for connection::PrivateLinkService {
496 #[allow(deprecated)]
497 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
498 where
499 S: serde::Serializer,
500 {
501 use serde::ser::SerializeStruct;
502 let mut len = 0;
503 if self.provider != 0 {
504 len += 1;
505 }
506 if !self.service_name.is_empty() {
507 len += 1;
508 }
509 if !self.endpoint_id.is_empty() {
510 len += 1;
511 }
512 if !self.dns_entries.is_empty() {
513 len += 1;
514 }
515 if !self.endpoint_dns_name.is_empty() {
516 len += 1;
517 }
518 let mut struct_ser = serializer.serialize_struct("catalog.Connection.PrivateLinkService", len)?;
519 if self.provider != 0 {
520 let v = connection::private_link_service::PrivateLinkProvider::try_from(self.provider)
521 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.provider)))?;
522 struct_ser.serialize_field("provider", &v)?;
523 }
524 if !self.service_name.is_empty() {
525 struct_ser.serialize_field("serviceName", &self.service_name)?;
526 }
527 if !self.endpoint_id.is_empty() {
528 struct_ser.serialize_field("endpointId", &self.endpoint_id)?;
529 }
530 if !self.dns_entries.is_empty() {
531 struct_ser.serialize_field("dnsEntries", &self.dns_entries)?;
532 }
533 if !self.endpoint_dns_name.is_empty() {
534 struct_ser.serialize_field("endpointDnsName", &self.endpoint_dns_name)?;
535 }
536 struct_ser.end()
537 }
538}
539impl<'de> serde::Deserialize<'de> for connection::PrivateLinkService {
540 #[allow(deprecated)]
541 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
542 where
543 D: serde::Deserializer<'de>,
544 {
545 const FIELDS: &[&str] = &[
546 "provider",
547 "service_name",
548 "serviceName",
549 "endpoint_id",
550 "endpointId",
551 "dns_entries",
552 "dnsEntries",
553 "endpoint_dns_name",
554 "endpointDnsName",
555 ];
556
557 #[allow(clippy::enum_variant_names)]
558 enum GeneratedField {
559 Provider,
560 ServiceName,
561 EndpointId,
562 DnsEntries,
563 EndpointDnsName,
564 }
565 impl<'de> serde::Deserialize<'de> for GeneratedField {
566 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
567 where
568 D: serde::Deserializer<'de>,
569 {
570 struct GeneratedVisitor;
571
572 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
573 type Value = GeneratedField;
574
575 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
576 write!(formatter, "expected one of: {:?}", &FIELDS)
577 }
578
579 #[allow(unused_variables)]
580 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
581 where
582 E: serde::de::Error,
583 {
584 match value {
585 "provider" => Ok(GeneratedField::Provider),
586 "serviceName" | "service_name" => Ok(GeneratedField::ServiceName),
587 "endpointId" | "endpoint_id" => Ok(GeneratedField::EndpointId),
588 "dnsEntries" | "dns_entries" => Ok(GeneratedField::DnsEntries),
589 "endpointDnsName" | "endpoint_dns_name" => Ok(GeneratedField::EndpointDnsName),
590 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
591 }
592 }
593 }
594 deserializer.deserialize_identifier(GeneratedVisitor)
595 }
596 }
597 struct GeneratedVisitor;
598 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
599 type Value = connection::PrivateLinkService;
600
601 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
602 formatter.write_str("struct catalog.Connection.PrivateLinkService")
603 }
604
605 fn visit_map<V>(self, mut map_: V) -> std::result::Result<connection::PrivateLinkService, V::Error>
606 where
607 V: serde::de::MapAccess<'de>,
608 {
609 let mut provider__ = None;
610 let mut service_name__ = None;
611 let mut endpoint_id__ = None;
612 let mut dns_entries__ = None;
613 let mut endpoint_dns_name__ = None;
614 while let Some(k) = map_.next_key()? {
615 match k {
616 GeneratedField::Provider => {
617 if provider__.is_some() {
618 return Err(serde::de::Error::duplicate_field("provider"));
619 }
620 provider__ = Some(map_.next_value::<connection::private_link_service::PrivateLinkProvider>()? as i32);
621 }
622 GeneratedField::ServiceName => {
623 if service_name__.is_some() {
624 return Err(serde::de::Error::duplicate_field("serviceName"));
625 }
626 service_name__ = Some(map_.next_value()?);
627 }
628 GeneratedField::EndpointId => {
629 if endpoint_id__.is_some() {
630 return Err(serde::de::Error::duplicate_field("endpointId"));
631 }
632 endpoint_id__ = Some(map_.next_value()?);
633 }
634 GeneratedField::DnsEntries => {
635 if dns_entries__.is_some() {
636 return Err(serde::de::Error::duplicate_field("dnsEntries"));
637 }
638 dns_entries__ = Some(
639 map_.next_value::<std::collections::HashMap<_, _>>()?
640 );
641 }
642 GeneratedField::EndpointDnsName => {
643 if endpoint_dns_name__.is_some() {
644 return Err(serde::de::Error::duplicate_field("endpointDnsName"));
645 }
646 endpoint_dns_name__ = Some(map_.next_value()?);
647 }
648 }
649 }
650 Ok(connection::PrivateLinkService {
651 provider: provider__.unwrap_or_default(),
652 service_name: service_name__.unwrap_or_default(),
653 endpoint_id: endpoint_id__.unwrap_or_default(),
654 dns_entries: dns_entries__.unwrap_or_default(),
655 endpoint_dns_name: endpoint_dns_name__.unwrap_or_default(),
656 })
657 }
658 }
659 deserializer.deserialize_struct("catalog.Connection.PrivateLinkService", FIELDS, GeneratedVisitor)
660 }
661}
662impl serde::Serialize for connection::private_link_service::PrivateLinkProvider {
663 #[allow(deprecated)]
664 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
665 where
666 S: serde::Serializer,
667 {
668 let variant = match self {
669 Self::Unspecified => "UNSPECIFIED",
670 Self::Mock => "MOCK",
671 Self::Aws => "AWS",
672 };
673 serializer.serialize_str(variant)
674 }
675}
676impl<'de> serde::Deserialize<'de> for connection::private_link_service::PrivateLinkProvider {
677 #[allow(deprecated)]
678 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
679 where
680 D: serde::Deserializer<'de>,
681 {
682 const FIELDS: &[&str] = &[
683 "UNSPECIFIED",
684 "MOCK",
685 "AWS",
686 ];
687
688 struct GeneratedVisitor;
689
690 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
691 type Value = connection::private_link_service::PrivateLinkProvider;
692
693 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
694 write!(formatter, "expected one of: {:?}", &FIELDS)
695 }
696
697 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
698 where
699 E: serde::de::Error,
700 {
701 i32::try_from(v)
702 .ok()
703 .and_then(|x| x.try_into().ok())
704 .ok_or_else(|| {
705 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
706 })
707 }
708
709 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
710 where
711 E: serde::de::Error,
712 {
713 i32::try_from(v)
714 .ok()
715 .and_then(|x| x.try_into().ok())
716 .ok_or_else(|| {
717 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
718 })
719 }
720
721 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
722 where
723 E: serde::de::Error,
724 {
725 match value {
726 "UNSPECIFIED" => Ok(connection::private_link_service::PrivateLinkProvider::Unspecified),
727 "MOCK" => Ok(connection::private_link_service::PrivateLinkProvider::Mock),
728 "AWS" => Ok(connection::private_link_service::PrivateLinkProvider::Aws),
729 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
730 }
731 }
732 }
733 deserializer.deserialize_any(GeneratedVisitor)
734 }
735}
736impl serde::Serialize for ConnectionParams {
737 #[allow(deprecated)]
738 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
739 where
740 S: serde::Serializer,
741 {
742 use serde::ser::SerializeStruct;
743 let mut len = 0;
744 if self.connection_type != 0 {
745 len += 1;
746 }
747 if !self.properties.is_empty() {
748 len += 1;
749 }
750 if !self.secret_refs.is_empty() {
751 len += 1;
752 }
753 let mut struct_ser = serializer.serialize_struct("catalog.ConnectionParams", len)?;
754 if self.connection_type != 0 {
755 let v = connection_params::ConnectionType::try_from(self.connection_type)
756 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.connection_type)))?;
757 struct_ser.serialize_field("connectionType", &v)?;
758 }
759 if !self.properties.is_empty() {
760 struct_ser.serialize_field("properties", &self.properties)?;
761 }
762 if !self.secret_refs.is_empty() {
763 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
764 }
765 struct_ser.end()
766 }
767}
768impl<'de> serde::Deserialize<'de> for ConnectionParams {
769 #[allow(deprecated)]
770 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
771 where
772 D: serde::Deserializer<'de>,
773 {
774 const FIELDS: &[&str] = &[
775 "connection_type",
776 "connectionType",
777 "properties",
778 "secret_refs",
779 "secretRefs",
780 ];
781
782 #[allow(clippy::enum_variant_names)]
783 enum GeneratedField {
784 ConnectionType,
785 Properties,
786 SecretRefs,
787 }
788 impl<'de> serde::Deserialize<'de> for GeneratedField {
789 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
790 where
791 D: serde::Deserializer<'de>,
792 {
793 struct GeneratedVisitor;
794
795 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
796 type Value = GeneratedField;
797
798 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
799 write!(formatter, "expected one of: {:?}", &FIELDS)
800 }
801
802 #[allow(unused_variables)]
803 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
804 where
805 E: serde::de::Error,
806 {
807 match value {
808 "connectionType" | "connection_type" => Ok(GeneratedField::ConnectionType),
809 "properties" => Ok(GeneratedField::Properties),
810 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
811 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
812 }
813 }
814 }
815 deserializer.deserialize_identifier(GeneratedVisitor)
816 }
817 }
818 struct GeneratedVisitor;
819 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
820 type Value = ConnectionParams;
821
822 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
823 formatter.write_str("struct catalog.ConnectionParams")
824 }
825
826 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectionParams, V::Error>
827 where
828 V: serde::de::MapAccess<'de>,
829 {
830 let mut connection_type__ = None;
831 let mut properties__ = None;
832 let mut secret_refs__ = None;
833 while let Some(k) = map_.next_key()? {
834 match k {
835 GeneratedField::ConnectionType => {
836 if connection_type__.is_some() {
837 return Err(serde::de::Error::duplicate_field("connectionType"));
838 }
839 connection_type__ = Some(map_.next_value::<connection_params::ConnectionType>()? as i32);
840 }
841 GeneratedField::Properties => {
842 if properties__.is_some() {
843 return Err(serde::de::Error::duplicate_field("properties"));
844 }
845 properties__ = Some(
846 map_.next_value::<std::collections::HashMap<_, _>>()?
847 );
848 }
849 GeneratedField::SecretRefs => {
850 if secret_refs__.is_some() {
851 return Err(serde::de::Error::duplicate_field("secretRefs"));
852 }
853 secret_refs__ = Some(
854 map_.next_value::<std::collections::HashMap<_, _>>()?
855 );
856 }
857 }
858 }
859 Ok(ConnectionParams {
860 connection_type: connection_type__.unwrap_or_default(),
861 properties: properties__.unwrap_or_default(),
862 secret_refs: secret_refs__.unwrap_or_default(),
863 })
864 }
865 }
866 deserializer.deserialize_struct("catalog.ConnectionParams", FIELDS, GeneratedVisitor)
867 }
868}
869impl serde::Serialize for connection_params::ConnectionType {
870 #[allow(deprecated)]
871 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
872 where
873 S: serde::Serializer,
874 {
875 let variant = match self {
876 Self::Unspecified => "CONNECTION_TYPE_UNSPECIFIED",
877 Self::Kafka => "CONNECTION_TYPE_KAFKA",
878 Self::Iceberg => "CONNECTION_TYPE_ICEBERG",
879 Self::SchemaRegistry => "CONNECTION_TYPE_SCHEMA_REGISTRY",
880 Self::Elasticsearch => "CONNECTION_TYPE_ELASTICSEARCH",
881 };
882 serializer.serialize_str(variant)
883 }
884}
885impl<'de> serde::Deserialize<'de> for connection_params::ConnectionType {
886 #[allow(deprecated)]
887 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
888 where
889 D: serde::Deserializer<'de>,
890 {
891 const FIELDS: &[&str] = &[
892 "CONNECTION_TYPE_UNSPECIFIED",
893 "CONNECTION_TYPE_KAFKA",
894 "CONNECTION_TYPE_ICEBERG",
895 "CONNECTION_TYPE_SCHEMA_REGISTRY",
896 "CONNECTION_TYPE_ELASTICSEARCH",
897 ];
898
899 struct GeneratedVisitor;
900
901 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
902 type Value = connection_params::ConnectionType;
903
904 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
905 write!(formatter, "expected one of: {:?}", &FIELDS)
906 }
907
908 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
909 where
910 E: serde::de::Error,
911 {
912 i32::try_from(v)
913 .ok()
914 .and_then(|x| x.try_into().ok())
915 .ok_or_else(|| {
916 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
917 })
918 }
919
920 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
921 where
922 E: serde::de::Error,
923 {
924 i32::try_from(v)
925 .ok()
926 .and_then(|x| x.try_into().ok())
927 .ok_or_else(|| {
928 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
929 })
930 }
931
932 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
933 where
934 E: serde::de::Error,
935 {
936 match value {
937 "CONNECTION_TYPE_UNSPECIFIED" => Ok(connection_params::ConnectionType::Unspecified),
938 "CONNECTION_TYPE_KAFKA" => Ok(connection_params::ConnectionType::Kafka),
939 "CONNECTION_TYPE_ICEBERG" => Ok(connection_params::ConnectionType::Iceberg),
940 "CONNECTION_TYPE_SCHEMA_REGISTRY" => Ok(connection_params::ConnectionType::SchemaRegistry),
941 "CONNECTION_TYPE_ELASTICSEARCH" => Ok(connection_params::ConnectionType::Elasticsearch),
942 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
943 }
944 }
945 }
946 deserializer.deserialize_any(GeneratedVisitor)
947 }
948}
949impl serde::Serialize for CreateType {
950 #[allow(deprecated)]
951 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
952 where
953 S: serde::Serializer,
954 {
955 let variant = match self {
956 Self::Unspecified => "CREATE_TYPE_UNSPECIFIED",
957 Self::Background => "CREATE_TYPE_BACKGROUND",
958 Self::Foreground => "CREATE_TYPE_FOREGROUND",
959 };
960 serializer.serialize_str(variant)
961 }
962}
963impl<'de> serde::Deserialize<'de> for CreateType {
964 #[allow(deprecated)]
965 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
966 where
967 D: serde::Deserializer<'de>,
968 {
969 const FIELDS: &[&str] = &[
970 "CREATE_TYPE_UNSPECIFIED",
971 "CREATE_TYPE_BACKGROUND",
972 "CREATE_TYPE_FOREGROUND",
973 ];
974
975 struct GeneratedVisitor;
976
977 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
978 type Value = CreateType;
979
980 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
981 write!(formatter, "expected one of: {:?}", &FIELDS)
982 }
983
984 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
985 where
986 E: serde::de::Error,
987 {
988 i32::try_from(v)
989 .ok()
990 .and_then(|x| x.try_into().ok())
991 .ok_or_else(|| {
992 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
993 })
994 }
995
996 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
997 where
998 E: serde::de::Error,
999 {
1000 i32::try_from(v)
1001 .ok()
1002 .and_then(|x| x.try_into().ok())
1003 .ok_or_else(|| {
1004 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1005 })
1006 }
1007
1008 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1009 where
1010 E: serde::de::Error,
1011 {
1012 match value {
1013 "CREATE_TYPE_UNSPECIFIED" => Ok(CreateType::Unspecified),
1014 "CREATE_TYPE_BACKGROUND" => Ok(CreateType::Background),
1015 "CREATE_TYPE_FOREGROUND" => Ok(CreateType::Foreground),
1016 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1017 }
1018 }
1019 }
1020 deserializer.deserialize_any(GeneratedVisitor)
1021 }
1022}
1023impl serde::Serialize for Database {
1024 #[allow(deprecated)]
1025 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1026 where
1027 S: serde::Serializer,
1028 {
1029 use serde::ser::SerializeStruct;
1030 let mut len = 0;
1031 if self.id != 0 {
1032 len += 1;
1033 }
1034 if !self.name.is_empty() {
1035 len += 1;
1036 }
1037 if self.owner != 0 {
1038 len += 1;
1039 }
1040 if !self.resource_group.is_empty() {
1041 len += 1;
1042 }
1043 if self.barrier_interval_ms.is_some() {
1044 len += 1;
1045 }
1046 if self.checkpoint_frequency.is_some() {
1047 len += 1;
1048 }
1049 let mut struct_ser = serializer.serialize_struct("catalog.Database", len)?;
1050 if self.id != 0 {
1051 struct_ser.serialize_field("id", &self.id)?;
1052 }
1053 if !self.name.is_empty() {
1054 struct_ser.serialize_field("name", &self.name)?;
1055 }
1056 if self.owner != 0 {
1057 struct_ser.serialize_field("owner", &self.owner)?;
1058 }
1059 if !self.resource_group.is_empty() {
1060 struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
1061 }
1062 if let Some(v) = self.barrier_interval_ms.as_ref() {
1063 struct_ser.serialize_field("barrierIntervalMs", v)?;
1064 }
1065 if let Some(v) = self.checkpoint_frequency.as_ref() {
1066 #[allow(clippy::needless_borrow)]
1067 #[allow(clippy::needless_borrows_for_generic_args)]
1068 struct_ser.serialize_field("checkpointFrequency", ToString::to_string(&v).as_str())?;
1069 }
1070 struct_ser.end()
1071 }
1072}
1073impl<'de> serde::Deserialize<'de> for Database {
1074 #[allow(deprecated)]
1075 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1076 where
1077 D: serde::Deserializer<'de>,
1078 {
1079 const FIELDS: &[&str] = &[
1080 "id",
1081 "name",
1082 "owner",
1083 "resource_group",
1084 "resourceGroup",
1085 "barrier_interval_ms",
1086 "barrierIntervalMs",
1087 "checkpoint_frequency",
1088 "checkpointFrequency",
1089 ];
1090
1091 #[allow(clippy::enum_variant_names)]
1092 enum GeneratedField {
1093 Id,
1094 Name,
1095 Owner,
1096 ResourceGroup,
1097 BarrierIntervalMs,
1098 CheckpointFrequency,
1099 }
1100 impl<'de> serde::Deserialize<'de> for GeneratedField {
1101 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1102 where
1103 D: serde::Deserializer<'de>,
1104 {
1105 struct GeneratedVisitor;
1106
1107 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1108 type Value = GeneratedField;
1109
1110 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1111 write!(formatter, "expected one of: {:?}", &FIELDS)
1112 }
1113
1114 #[allow(unused_variables)]
1115 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1116 where
1117 E: serde::de::Error,
1118 {
1119 match value {
1120 "id" => Ok(GeneratedField::Id),
1121 "name" => Ok(GeneratedField::Name),
1122 "owner" => Ok(GeneratedField::Owner),
1123 "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
1124 "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
1125 "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
1126 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1127 }
1128 }
1129 }
1130 deserializer.deserialize_identifier(GeneratedVisitor)
1131 }
1132 }
1133 struct GeneratedVisitor;
1134 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1135 type Value = Database;
1136
1137 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1138 formatter.write_str("struct catalog.Database")
1139 }
1140
1141 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Database, V::Error>
1142 where
1143 V: serde::de::MapAccess<'de>,
1144 {
1145 let mut id__ = None;
1146 let mut name__ = None;
1147 let mut owner__ = None;
1148 let mut resource_group__ = None;
1149 let mut barrier_interval_ms__ = None;
1150 let mut checkpoint_frequency__ = None;
1151 while let Some(k) = map_.next_key()? {
1152 match k {
1153 GeneratedField::Id => {
1154 if id__.is_some() {
1155 return Err(serde::de::Error::duplicate_field("id"));
1156 }
1157 id__ =
1158 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1159 ;
1160 }
1161 GeneratedField::Name => {
1162 if name__.is_some() {
1163 return Err(serde::de::Error::duplicate_field("name"));
1164 }
1165 name__ = Some(map_.next_value()?);
1166 }
1167 GeneratedField::Owner => {
1168 if owner__.is_some() {
1169 return Err(serde::de::Error::duplicate_field("owner"));
1170 }
1171 owner__ =
1172 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1173 ;
1174 }
1175 GeneratedField::ResourceGroup => {
1176 if resource_group__.is_some() {
1177 return Err(serde::de::Error::duplicate_field("resourceGroup"));
1178 }
1179 resource_group__ = Some(map_.next_value()?);
1180 }
1181 GeneratedField::BarrierIntervalMs => {
1182 if barrier_interval_ms__.is_some() {
1183 return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
1184 }
1185 barrier_interval_ms__ =
1186 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1187 ;
1188 }
1189 GeneratedField::CheckpointFrequency => {
1190 if checkpoint_frequency__.is_some() {
1191 return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
1192 }
1193 checkpoint_frequency__ =
1194 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1195 ;
1196 }
1197 }
1198 }
1199 Ok(Database {
1200 id: id__.unwrap_or_default(),
1201 name: name__.unwrap_or_default(),
1202 owner: owner__.unwrap_or_default(),
1203 resource_group: resource_group__.unwrap_or_default(),
1204 barrier_interval_ms: barrier_interval_ms__,
1205 checkpoint_frequency: checkpoint_frequency__,
1206 })
1207 }
1208 }
1209 deserializer.deserialize_struct("catalog.Database", FIELDS, GeneratedVisitor)
1210 }
1211}
1212impl serde::Serialize for Function {
1213 #[allow(deprecated)]
1214 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1215 where
1216 S: serde::Serializer,
1217 {
1218 use serde::ser::SerializeStruct;
1219 let mut len = 0;
1220 if self.id != 0 {
1221 len += 1;
1222 }
1223 if self.schema_id != 0 {
1224 len += 1;
1225 }
1226 if self.database_id != 0 {
1227 len += 1;
1228 }
1229 if !self.name.is_empty() {
1230 len += 1;
1231 }
1232 if self.owner != 0 {
1233 len += 1;
1234 }
1235 if !self.arg_names.is_empty() {
1236 len += 1;
1237 }
1238 if !self.arg_types.is_empty() {
1239 len += 1;
1240 }
1241 if self.return_type.is_some() {
1242 len += 1;
1243 }
1244 if !self.language.is_empty() {
1245 len += 1;
1246 }
1247 if self.link.is_some() {
1248 len += 1;
1249 }
1250 if self.name_in_runtime.is_some() {
1251 len += 1;
1252 }
1253 if self.body.is_some() {
1254 len += 1;
1255 }
1256 if self.compressed_binary.is_some() {
1257 len += 1;
1258 }
1259 if self.always_retry_on_network_error {
1260 len += 1;
1261 }
1262 if self.runtime.is_some() {
1263 len += 1;
1264 }
1265 if self.is_async.is_some() {
1266 len += 1;
1267 }
1268 if self.is_batched.is_some() {
1269 len += 1;
1270 }
1271 if self.kind.is_some() {
1272 len += 1;
1273 }
1274 let mut struct_ser = serializer.serialize_struct("catalog.Function", len)?;
1275 if self.id != 0 {
1276 struct_ser.serialize_field("id", &self.id)?;
1277 }
1278 if self.schema_id != 0 {
1279 struct_ser.serialize_field("schemaId", &self.schema_id)?;
1280 }
1281 if self.database_id != 0 {
1282 struct_ser.serialize_field("databaseId", &self.database_id)?;
1283 }
1284 if !self.name.is_empty() {
1285 struct_ser.serialize_field("name", &self.name)?;
1286 }
1287 if self.owner != 0 {
1288 struct_ser.serialize_field("owner", &self.owner)?;
1289 }
1290 if !self.arg_names.is_empty() {
1291 struct_ser.serialize_field("argNames", &self.arg_names)?;
1292 }
1293 if !self.arg_types.is_empty() {
1294 struct_ser.serialize_field("argTypes", &self.arg_types)?;
1295 }
1296 if let Some(v) = self.return_type.as_ref() {
1297 struct_ser.serialize_field("returnType", v)?;
1298 }
1299 if !self.language.is_empty() {
1300 struct_ser.serialize_field("language", &self.language)?;
1301 }
1302 if let Some(v) = self.link.as_ref() {
1303 struct_ser.serialize_field("link", v)?;
1304 }
1305 if let Some(v) = self.name_in_runtime.as_ref() {
1306 struct_ser.serialize_field("nameInRuntime", v)?;
1307 }
1308 if let Some(v) = self.body.as_ref() {
1309 struct_ser.serialize_field("body", v)?;
1310 }
1311 if let Some(v) = self.compressed_binary.as_ref() {
1312 #[allow(clippy::needless_borrow)]
1313 #[allow(clippy::needless_borrows_for_generic_args)]
1314 struct_ser.serialize_field("compressedBinary", pbjson::private::base64::encode(&v).as_str())?;
1315 }
1316 if self.always_retry_on_network_error {
1317 struct_ser.serialize_field("alwaysRetryOnNetworkError", &self.always_retry_on_network_error)?;
1318 }
1319 if let Some(v) = self.runtime.as_ref() {
1320 struct_ser.serialize_field("runtime", v)?;
1321 }
1322 if let Some(v) = self.is_async.as_ref() {
1323 struct_ser.serialize_field("isAsync", v)?;
1324 }
1325 if let Some(v) = self.is_batched.as_ref() {
1326 struct_ser.serialize_field("isBatched", v)?;
1327 }
1328 if let Some(v) = self.kind.as_ref() {
1329 match v {
1330 function::Kind::Scalar(v) => {
1331 struct_ser.serialize_field("scalar", v)?;
1332 }
1333 function::Kind::Table(v) => {
1334 struct_ser.serialize_field("table", v)?;
1335 }
1336 function::Kind::Aggregate(v) => {
1337 struct_ser.serialize_field("aggregate", v)?;
1338 }
1339 }
1340 }
1341 struct_ser.end()
1342 }
1343}
1344impl<'de> serde::Deserialize<'de> for Function {
1345 #[allow(deprecated)]
1346 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1347 where
1348 D: serde::Deserializer<'de>,
1349 {
1350 const FIELDS: &[&str] = &[
1351 "id",
1352 "schema_id",
1353 "schemaId",
1354 "database_id",
1355 "databaseId",
1356 "name",
1357 "owner",
1358 "arg_names",
1359 "argNames",
1360 "arg_types",
1361 "argTypes",
1362 "return_type",
1363 "returnType",
1364 "language",
1365 "link",
1366 "name_in_runtime",
1367 "nameInRuntime",
1368 "body",
1369 "compressed_binary",
1370 "compressedBinary",
1371 "always_retry_on_network_error",
1372 "alwaysRetryOnNetworkError",
1373 "runtime",
1374 "is_async",
1375 "isAsync",
1376 "is_batched",
1377 "isBatched",
1378 "scalar",
1379 "table",
1380 "aggregate",
1381 ];
1382
1383 #[allow(clippy::enum_variant_names)]
1384 enum GeneratedField {
1385 Id,
1386 SchemaId,
1387 DatabaseId,
1388 Name,
1389 Owner,
1390 ArgNames,
1391 ArgTypes,
1392 ReturnType,
1393 Language,
1394 Link,
1395 NameInRuntime,
1396 Body,
1397 CompressedBinary,
1398 AlwaysRetryOnNetworkError,
1399 Runtime,
1400 IsAsync,
1401 IsBatched,
1402 Scalar,
1403 Table,
1404 Aggregate,
1405 }
1406 impl<'de> serde::Deserialize<'de> for GeneratedField {
1407 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1408 where
1409 D: serde::Deserializer<'de>,
1410 {
1411 struct GeneratedVisitor;
1412
1413 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1414 type Value = GeneratedField;
1415
1416 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1417 write!(formatter, "expected one of: {:?}", &FIELDS)
1418 }
1419
1420 #[allow(unused_variables)]
1421 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1422 where
1423 E: serde::de::Error,
1424 {
1425 match value {
1426 "id" => Ok(GeneratedField::Id),
1427 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1428 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1429 "name" => Ok(GeneratedField::Name),
1430 "owner" => Ok(GeneratedField::Owner),
1431 "argNames" | "arg_names" => Ok(GeneratedField::ArgNames),
1432 "argTypes" | "arg_types" => Ok(GeneratedField::ArgTypes),
1433 "returnType" | "return_type" => Ok(GeneratedField::ReturnType),
1434 "language" => Ok(GeneratedField::Language),
1435 "link" => Ok(GeneratedField::Link),
1436 "nameInRuntime" | "name_in_runtime" => Ok(GeneratedField::NameInRuntime),
1437 "body" => Ok(GeneratedField::Body),
1438 "compressedBinary" | "compressed_binary" => Ok(GeneratedField::CompressedBinary),
1439 "alwaysRetryOnNetworkError" | "always_retry_on_network_error" => Ok(GeneratedField::AlwaysRetryOnNetworkError),
1440 "runtime" => Ok(GeneratedField::Runtime),
1441 "isAsync" | "is_async" => Ok(GeneratedField::IsAsync),
1442 "isBatched" | "is_batched" => Ok(GeneratedField::IsBatched),
1443 "scalar" => Ok(GeneratedField::Scalar),
1444 "table" => Ok(GeneratedField::Table),
1445 "aggregate" => Ok(GeneratedField::Aggregate),
1446 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1447 }
1448 }
1449 }
1450 deserializer.deserialize_identifier(GeneratedVisitor)
1451 }
1452 }
1453 struct GeneratedVisitor;
1454 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1455 type Value = Function;
1456
1457 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1458 formatter.write_str("struct catalog.Function")
1459 }
1460
1461 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Function, V::Error>
1462 where
1463 V: serde::de::MapAccess<'de>,
1464 {
1465 let mut id__ = None;
1466 let mut schema_id__ = None;
1467 let mut database_id__ = None;
1468 let mut name__ = None;
1469 let mut owner__ = None;
1470 let mut arg_names__ = None;
1471 let mut arg_types__ = None;
1472 let mut return_type__ = None;
1473 let mut language__ = None;
1474 let mut link__ = None;
1475 let mut name_in_runtime__ = None;
1476 let mut body__ = None;
1477 let mut compressed_binary__ = None;
1478 let mut always_retry_on_network_error__ = None;
1479 let mut runtime__ = None;
1480 let mut is_async__ = None;
1481 let mut is_batched__ = None;
1482 let mut kind__ = None;
1483 while let Some(k) = map_.next_key()? {
1484 match k {
1485 GeneratedField::Id => {
1486 if id__.is_some() {
1487 return Err(serde::de::Error::duplicate_field("id"));
1488 }
1489 id__ =
1490 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1491 ;
1492 }
1493 GeneratedField::SchemaId => {
1494 if schema_id__.is_some() {
1495 return Err(serde::de::Error::duplicate_field("schemaId"));
1496 }
1497 schema_id__ =
1498 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1499 ;
1500 }
1501 GeneratedField::DatabaseId => {
1502 if database_id__.is_some() {
1503 return Err(serde::de::Error::duplicate_field("databaseId"));
1504 }
1505 database_id__ =
1506 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1507 ;
1508 }
1509 GeneratedField::Name => {
1510 if name__.is_some() {
1511 return Err(serde::de::Error::duplicate_field("name"));
1512 }
1513 name__ = Some(map_.next_value()?);
1514 }
1515 GeneratedField::Owner => {
1516 if owner__.is_some() {
1517 return Err(serde::de::Error::duplicate_field("owner"));
1518 }
1519 owner__ =
1520 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1521 ;
1522 }
1523 GeneratedField::ArgNames => {
1524 if arg_names__.is_some() {
1525 return Err(serde::de::Error::duplicate_field("argNames"));
1526 }
1527 arg_names__ = Some(map_.next_value()?);
1528 }
1529 GeneratedField::ArgTypes => {
1530 if arg_types__.is_some() {
1531 return Err(serde::de::Error::duplicate_field("argTypes"));
1532 }
1533 arg_types__ = Some(map_.next_value()?);
1534 }
1535 GeneratedField::ReturnType => {
1536 if return_type__.is_some() {
1537 return Err(serde::de::Error::duplicate_field("returnType"));
1538 }
1539 return_type__ = map_.next_value()?;
1540 }
1541 GeneratedField::Language => {
1542 if language__.is_some() {
1543 return Err(serde::de::Error::duplicate_field("language"));
1544 }
1545 language__ = Some(map_.next_value()?);
1546 }
1547 GeneratedField::Link => {
1548 if link__.is_some() {
1549 return Err(serde::de::Error::duplicate_field("link"));
1550 }
1551 link__ = map_.next_value()?;
1552 }
1553 GeneratedField::NameInRuntime => {
1554 if name_in_runtime__.is_some() {
1555 return Err(serde::de::Error::duplicate_field("nameInRuntime"));
1556 }
1557 name_in_runtime__ = map_.next_value()?;
1558 }
1559 GeneratedField::Body => {
1560 if body__.is_some() {
1561 return Err(serde::de::Error::duplicate_field("body"));
1562 }
1563 body__ = map_.next_value()?;
1564 }
1565 GeneratedField::CompressedBinary => {
1566 if compressed_binary__.is_some() {
1567 return Err(serde::de::Error::duplicate_field("compressedBinary"));
1568 }
1569 compressed_binary__ =
1570 map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| x.0)
1571 ;
1572 }
1573 GeneratedField::AlwaysRetryOnNetworkError => {
1574 if always_retry_on_network_error__.is_some() {
1575 return Err(serde::de::Error::duplicate_field("alwaysRetryOnNetworkError"));
1576 }
1577 always_retry_on_network_error__ = Some(map_.next_value()?);
1578 }
1579 GeneratedField::Runtime => {
1580 if runtime__.is_some() {
1581 return Err(serde::de::Error::duplicate_field("runtime"));
1582 }
1583 runtime__ = map_.next_value()?;
1584 }
1585 GeneratedField::IsAsync => {
1586 if is_async__.is_some() {
1587 return Err(serde::de::Error::duplicate_field("isAsync"));
1588 }
1589 is_async__ = map_.next_value()?;
1590 }
1591 GeneratedField::IsBatched => {
1592 if is_batched__.is_some() {
1593 return Err(serde::de::Error::duplicate_field("isBatched"));
1594 }
1595 is_batched__ = map_.next_value()?;
1596 }
1597 GeneratedField::Scalar => {
1598 if kind__.is_some() {
1599 return Err(serde::de::Error::duplicate_field("scalar"));
1600 }
1601 kind__ = map_.next_value::<::std::option::Option<_>>()?.map(function::Kind::Scalar)
1602;
1603 }
1604 GeneratedField::Table => {
1605 if kind__.is_some() {
1606 return Err(serde::de::Error::duplicate_field("table"));
1607 }
1608 kind__ = map_.next_value::<::std::option::Option<_>>()?.map(function::Kind::Table)
1609;
1610 }
1611 GeneratedField::Aggregate => {
1612 if kind__.is_some() {
1613 return Err(serde::de::Error::duplicate_field("aggregate"));
1614 }
1615 kind__ = map_.next_value::<::std::option::Option<_>>()?.map(function::Kind::Aggregate)
1616;
1617 }
1618 }
1619 }
1620 Ok(Function {
1621 id: id__.unwrap_or_default(),
1622 schema_id: schema_id__.unwrap_or_default(),
1623 database_id: database_id__.unwrap_or_default(),
1624 name: name__.unwrap_or_default(),
1625 owner: owner__.unwrap_or_default(),
1626 arg_names: arg_names__.unwrap_or_default(),
1627 arg_types: arg_types__.unwrap_or_default(),
1628 return_type: return_type__,
1629 language: language__.unwrap_or_default(),
1630 link: link__,
1631 name_in_runtime: name_in_runtime__,
1632 body: body__,
1633 compressed_binary: compressed_binary__,
1634 always_retry_on_network_error: always_retry_on_network_error__.unwrap_or_default(),
1635 runtime: runtime__,
1636 is_async: is_async__,
1637 is_batched: is_batched__,
1638 kind: kind__,
1639 })
1640 }
1641 }
1642 deserializer.deserialize_struct("catalog.Function", FIELDS, GeneratedVisitor)
1643 }
1644}
1645impl serde::Serialize for function::AggregateFunction {
1646 #[allow(deprecated)]
1647 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1648 where
1649 S: serde::Serializer,
1650 {
1651 use serde::ser::SerializeStruct;
1652 let len = 0;
1653 let struct_ser = serializer.serialize_struct("catalog.Function.AggregateFunction", len)?;
1654 struct_ser.end()
1655 }
1656}
1657impl<'de> serde::Deserialize<'de> for function::AggregateFunction {
1658 #[allow(deprecated)]
1659 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1660 where
1661 D: serde::Deserializer<'de>,
1662 {
1663 const FIELDS: &[&str] = &[
1664 ];
1665
1666 #[allow(clippy::enum_variant_names)]
1667 enum GeneratedField {
1668 }
1669 impl<'de> serde::Deserialize<'de> for GeneratedField {
1670 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1671 where
1672 D: serde::Deserializer<'de>,
1673 {
1674 struct GeneratedVisitor;
1675
1676 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1677 type Value = GeneratedField;
1678
1679 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1680 write!(formatter, "expected one of: {:?}", &FIELDS)
1681 }
1682
1683 #[allow(unused_variables)]
1684 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1685 where
1686 E: serde::de::Error,
1687 {
1688 Err(serde::de::Error::unknown_field(value, FIELDS))
1689 }
1690 }
1691 deserializer.deserialize_identifier(GeneratedVisitor)
1692 }
1693 }
1694 struct GeneratedVisitor;
1695 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1696 type Value = function::AggregateFunction;
1697
1698 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1699 formatter.write_str("struct catalog.Function.AggregateFunction")
1700 }
1701
1702 fn visit_map<V>(self, mut map_: V) -> std::result::Result<function::AggregateFunction, V::Error>
1703 where
1704 V: serde::de::MapAccess<'de>,
1705 {
1706 while map_.next_key::<GeneratedField>()?.is_some() {
1707 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1708 }
1709 Ok(function::AggregateFunction {
1710 })
1711 }
1712 }
1713 deserializer.deserialize_struct("catalog.Function.AggregateFunction", FIELDS, GeneratedVisitor)
1714 }
1715}
1716impl serde::Serialize for function::ScalarFunction {
1717 #[allow(deprecated)]
1718 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1719 where
1720 S: serde::Serializer,
1721 {
1722 use serde::ser::SerializeStruct;
1723 let len = 0;
1724 let struct_ser = serializer.serialize_struct("catalog.Function.ScalarFunction", len)?;
1725 struct_ser.end()
1726 }
1727}
1728impl<'de> serde::Deserialize<'de> for function::ScalarFunction {
1729 #[allow(deprecated)]
1730 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1731 where
1732 D: serde::Deserializer<'de>,
1733 {
1734 const FIELDS: &[&str] = &[
1735 ];
1736
1737 #[allow(clippy::enum_variant_names)]
1738 enum GeneratedField {
1739 }
1740 impl<'de> serde::Deserialize<'de> for GeneratedField {
1741 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1742 where
1743 D: serde::Deserializer<'de>,
1744 {
1745 struct GeneratedVisitor;
1746
1747 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1748 type Value = GeneratedField;
1749
1750 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1751 write!(formatter, "expected one of: {:?}", &FIELDS)
1752 }
1753
1754 #[allow(unused_variables)]
1755 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1756 where
1757 E: serde::de::Error,
1758 {
1759 Err(serde::de::Error::unknown_field(value, FIELDS))
1760 }
1761 }
1762 deserializer.deserialize_identifier(GeneratedVisitor)
1763 }
1764 }
1765 struct GeneratedVisitor;
1766 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1767 type Value = function::ScalarFunction;
1768
1769 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1770 formatter.write_str("struct catalog.Function.ScalarFunction")
1771 }
1772
1773 fn visit_map<V>(self, mut map_: V) -> std::result::Result<function::ScalarFunction, V::Error>
1774 where
1775 V: serde::de::MapAccess<'de>,
1776 {
1777 while map_.next_key::<GeneratedField>()?.is_some() {
1778 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1779 }
1780 Ok(function::ScalarFunction {
1781 })
1782 }
1783 }
1784 deserializer.deserialize_struct("catalog.Function.ScalarFunction", FIELDS, GeneratedVisitor)
1785 }
1786}
1787impl serde::Serialize for function::TableFunction {
1788 #[allow(deprecated)]
1789 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1790 where
1791 S: serde::Serializer,
1792 {
1793 use serde::ser::SerializeStruct;
1794 let len = 0;
1795 let struct_ser = serializer.serialize_struct("catalog.Function.TableFunction", len)?;
1796 struct_ser.end()
1797 }
1798}
1799impl<'de> serde::Deserialize<'de> for function::TableFunction {
1800 #[allow(deprecated)]
1801 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1802 where
1803 D: serde::Deserializer<'de>,
1804 {
1805 const FIELDS: &[&str] = &[
1806 ];
1807
1808 #[allow(clippy::enum_variant_names)]
1809 enum GeneratedField {
1810 }
1811 impl<'de> serde::Deserialize<'de> for GeneratedField {
1812 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1813 where
1814 D: serde::Deserializer<'de>,
1815 {
1816 struct GeneratedVisitor;
1817
1818 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1819 type Value = GeneratedField;
1820
1821 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1822 write!(formatter, "expected one of: {:?}", &FIELDS)
1823 }
1824
1825 #[allow(unused_variables)]
1826 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1827 where
1828 E: serde::de::Error,
1829 {
1830 Err(serde::de::Error::unknown_field(value, FIELDS))
1831 }
1832 }
1833 deserializer.deserialize_identifier(GeneratedVisitor)
1834 }
1835 }
1836 struct GeneratedVisitor;
1837 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1838 type Value = function::TableFunction;
1839
1840 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1841 formatter.write_str("struct catalog.Function.TableFunction")
1842 }
1843
1844 fn visit_map<V>(self, mut map_: V) -> std::result::Result<function::TableFunction, V::Error>
1845 where
1846 V: serde::de::MapAccess<'de>,
1847 {
1848 while map_.next_key::<GeneratedField>()?.is_some() {
1849 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1850 }
1851 Ok(function::TableFunction {
1852 })
1853 }
1854 }
1855 deserializer.deserialize_struct("catalog.Function.TableFunction", FIELDS, GeneratedVisitor)
1856 }
1857}
1858impl serde::Serialize for HandleConflictBehavior {
1859 #[allow(deprecated)]
1860 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1861 where
1862 S: serde::Serializer,
1863 {
1864 let variant = match self {
1865 Self::Unspecified => "HANDLE_CONFLICT_BEHAVIOR_UNSPECIFIED",
1866 Self::Overwrite => "HANDLE_CONFLICT_BEHAVIOR_OVERWRITE",
1867 Self::Ignore => "HANDLE_CONFLICT_BEHAVIOR_IGNORE",
1868 Self::NoCheck => "HANDLE_CONFLICT_BEHAVIOR_NO_CHECK",
1869 Self::DoUpdateIfNotNull => "HANDLE_CONFLICT_BEHAVIOR_DO_UPDATE_IF_NOT_NULL",
1870 };
1871 serializer.serialize_str(variant)
1872 }
1873}
1874impl<'de> serde::Deserialize<'de> for HandleConflictBehavior {
1875 #[allow(deprecated)]
1876 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1877 where
1878 D: serde::Deserializer<'de>,
1879 {
1880 const FIELDS: &[&str] = &[
1881 "HANDLE_CONFLICT_BEHAVIOR_UNSPECIFIED",
1882 "HANDLE_CONFLICT_BEHAVIOR_OVERWRITE",
1883 "HANDLE_CONFLICT_BEHAVIOR_IGNORE",
1884 "HANDLE_CONFLICT_BEHAVIOR_NO_CHECK",
1885 "HANDLE_CONFLICT_BEHAVIOR_DO_UPDATE_IF_NOT_NULL",
1886 ];
1887
1888 struct GeneratedVisitor;
1889
1890 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1891 type Value = HandleConflictBehavior;
1892
1893 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1894 write!(formatter, "expected one of: {:?}", &FIELDS)
1895 }
1896
1897 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1898 where
1899 E: serde::de::Error,
1900 {
1901 i32::try_from(v)
1902 .ok()
1903 .and_then(|x| x.try_into().ok())
1904 .ok_or_else(|| {
1905 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1906 })
1907 }
1908
1909 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1910 where
1911 E: serde::de::Error,
1912 {
1913 i32::try_from(v)
1914 .ok()
1915 .and_then(|x| x.try_into().ok())
1916 .ok_or_else(|| {
1917 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1918 })
1919 }
1920
1921 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1922 where
1923 E: serde::de::Error,
1924 {
1925 match value {
1926 "HANDLE_CONFLICT_BEHAVIOR_UNSPECIFIED" => Ok(HandleConflictBehavior::Unspecified),
1927 "HANDLE_CONFLICT_BEHAVIOR_OVERWRITE" => Ok(HandleConflictBehavior::Overwrite),
1928 "HANDLE_CONFLICT_BEHAVIOR_IGNORE" => Ok(HandleConflictBehavior::Ignore),
1929 "HANDLE_CONFLICT_BEHAVIOR_NO_CHECK" => Ok(HandleConflictBehavior::NoCheck),
1930 "HANDLE_CONFLICT_BEHAVIOR_DO_UPDATE_IF_NOT_NULL" => Ok(HandleConflictBehavior::DoUpdateIfNotNull),
1931 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1932 }
1933 }
1934 }
1935 deserializer.deserialize_any(GeneratedVisitor)
1936 }
1937}
1938impl serde::Serialize for Index {
1939 #[allow(deprecated)]
1940 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1941 where
1942 S: serde::Serializer,
1943 {
1944 use serde::ser::SerializeStruct;
1945 let mut len = 0;
1946 if self.id != 0 {
1947 len += 1;
1948 }
1949 if self.schema_id != 0 {
1950 len += 1;
1951 }
1952 if self.database_id != 0 {
1953 len += 1;
1954 }
1955 if !self.name.is_empty() {
1956 len += 1;
1957 }
1958 if self.owner != 0 {
1959 len += 1;
1960 }
1961 if self.index_table_id != 0 {
1962 len += 1;
1963 }
1964 if self.primary_table_id != 0 {
1965 len += 1;
1966 }
1967 if !self.index_item.is_empty() {
1968 len += 1;
1969 }
1970 if !self.index_column_properties.is_empty() {
1971 len += 1;
1972 }
1973 if self.initialized_at_epoch.is_some() {
1974 len += 1;
1975 }
1976 if self.created_at_epoch.is_some() {
1977 len += 1;
1978 }
1979 if self.stream_job_status != 0 {
1980 len += 1;
1981 }
1982 if self.index_columns_len != 0 {
1983 len += 1;
1984 }
1985 if self.initialized_at_cluster_version.is_some() {
1986 len += 1;
1987 }
1988 if self.created_at_cluster_version.is_some() {
1989 len += 1;
1990 }
1991 let mut struct_ser = serializer.serialize_struct("catalog.Index", len)?;
1992 if self.id != 0 {
1993 struct_ser.serialize_field("id", &self.id)?;
1994 }
1995 if self.schema_id != 0 {
1996 struct_ser.serialize_field("schemaId", &self.schema_id)?;
1997 }
1998 if self.database_id != 0 {
1999 struct_ser.serialize_field("databaseId", &self.database_id)?;
2000 }
2001 if !self.name.is_empty() {
2002 struct_ser.serialize_field("name", &self.name)?;
2003 }
2004 if self.owner != 0 {
2005 struct_ser.serialize_field("owner", &self.owner)?;
2006 }
2007 if self.index_table_id != 0 {
2008 struct_ser.serialize_field("indexTableId", &self.index_table_id)?;
2009 }
2010 if self.primary_table_id != 0 {
2011 struct_ser.serialize_field("primaryTableId", &self.primary_table_id)?;
2012 }
2013 if !self.index_item.is_empty() {
2014 struct_ser.serialize_field("indexItem", &self.index_item)?;
2015 }
2016 if !self.index_column_properties.is_empty() {
2017 struct_ser.serialize_field("indexColumnProperties", &self.index_column_properties)?;
2018 }
2019 if let Some(v) = self.initialized_at_epoch.as_ref() {
2020 #[allow(clippy::needless_borrow)]
2021 #[allow(clippy::needless_borrows_for_generic_args)]
2022 struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
2023 }
2024 if let Some(v) = self.created_at_epoch.as_ref() {
2025 #[allow(clippy::needless_borrow)]
2026 #[allow(clippy::needless_borrows_for_generic_args)]
2027 struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
2028 }
2029 if self.stream_job_status != 0 {
2030 let v = StreamJobStatus::try_from(self.stream_job_status)
2031 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_job_status)))?;
2032 struct_ser.serialize_field("streamJobStatus", &v)?;
2033 }
2034 if self.index_columns_len != 0 {
2035 struct_ser.serialize_field("indexColumnsLen", &self.index_columns_len)?;
2036 }
2037 if let Some(v) = self.initialized_at_cluster_version.as_ref() {
2038 struct_ser.serialize_field("initializedAtClusterVersion", v)?;
2039 }
2040 if let Some(v) = self.created_at_cluster_version.as_ref() {
2041 struct_ser.serialize_field("createdAtClusterVersion", v)?;
2042 }
2043 struct_ser.end()
2044 }
2045}
2046impl<'de> serde::Deserialize<'de> for Index {
2047 #[allow(deprecated)]
2048 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2049 where
2050 D: serde::Deserializer<'de>,
2051 {
2052 const FIELDS: &[&str] = &[
2053 "id",
2054 "schema_id",
2055 "schemaId",
2056 "database_id",
2057 "databaseId",
2058 "name",
2059 "owner",
2060 "index_table_id",
2061 "indexTableId",
2062 "primary_table_id",
2063 "primaryTableId",
2064 "index_item",
2065 "indexItem",
2066 "index_column_properties",
2067 "indexColumnProperties",
2068 "initialized_at_epoch",
2069 "initializedAtEpoch",
2070 "created_at_epoch",
2071 "createdAtEpoch",
2072 "stream_job_status",
2073 "streamJobStatus",
2074 "index_columns_len",
2075 "indexColumnsLen",
2076 "initialized_at_cluster_version",
2077 "initializedAtClusterVersion",
2078 "created_at_cluster_version",
2079 "createdAtClusterVersion",
2080 ];
2081
2082 #[allow(clippy::enum_variant_names)]
2083 enum GeneratedField {
2084 Id,
2085 SchemaId,
2086 DatabaseId,
2087 Name,
2088 Owner,
2089 IndexTableId,
2090 PrimaryTableId,
2091 IndexItem,
2092 IndexColumnProperties,
2093 InitializedAtEpoch,
2094 CreatedAtEpoch,
2095 StreamJobStatus,
2096 IndexColumnsLen,
2097 InitializedAtClusterVersion,
2098 CreatedAtClusterVersion,
2099 }
2100 impl<'de> serde::Deserialize<'de> for GeneratedField {
2101 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2102 where
2103 D: serde::Deserializer<'de>,
2104 {
2105 struct GeneratedVisitor;
2106
2107 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2108 type Value = GeneratedField;
2109
2110 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2111 write!(formatter, "expected one of: {:?}", &FIELDS)
2112 }
2113
2114 #[allow(unused_variables)]
2115 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2116 where
2117 E: serde::de::Error,
2118 {
2119 match value {
2120 "id" => Ok(GeneratedField::Id),
2121 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
2122 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
2123 "name" => Ok(GeneratedField::Name),
2124 "owner" => Ok(GeneratedField::Owner),
2125 "indexTableId" | "index_table_id" => Ok(GeneratedField::IndexTableId),
2126 "primaryTableId" | "primary_table_id" => Ok(GeneratedField::PrimaryTableId),
2127 "indexItem" | "index_item" => Ok(GeneratedField::IndexItem),
2128 "indexColumnProperties" | "index_column_properties" => Ok(GeneratedField::IndexColumnProperties),
2129 "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
2130 "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
2131 "streamJobStatus" | "stream_job_status" => Ok(GeneratedField::StreamJobStatus),
2132 "indexColumnsLen" | "index_columns_len" => Ok(GeneratedField::IndexColumnsLen),
2133 "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
2134 "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
2135 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2136 }
2137 }
2138 }
2139 deserializer.deserialize_identifier(GeneratedVisitor)
2140 }
2141 }
2142 struct GeneratedVisitor;
2143 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2144 type Value = Index;
2145
2146 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2147 formatter.write_str("struct catalog.Index")
2148 }
2149
2150 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Index, V::Error>
2151 where
2152 V: serde::de::MapAccess<'de>,
2153 {
2154 let mut id__ = None;
2155 let mut schema_id__ = None;
2156 let mut database_id__ = None;
2157 let mut name__ = None;
2158 let mut owner__ = None;
2159 let mut index_table_id__ = None;
2160 let mut primary_table_id__ = None;
2161 let mut index_item__ = None;
2162 let mut index_column_properties__ = None;
2163 let mut initialized_at_epoch__ = None;
2164 let mut created_at_epoch__ = None;
2165 let mut stream_job_status__ = None;
2166 let mut index_columns_len__ = None;
2167 let mut initialized_at_cluster_version__ = None;
2168 let mut created_at_cluster_version__ = None;
2169 while let Some(k) = map_.next_key()? {
2170 match k {
2171 GeneratedField::Id => {
2172 if id__.is_some() {
2173 return Err(serde::de::Error::duplicate_field("id"));
2174 }
2175 id__ =
2176 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2177 ;
2178 }
2179 GeneratedField::SchemaId => {
2180 if schema_id__.is_some() {
2181 return Err(serde::de::Error::duplicate_field("schemaId"));
2182 }
2183 schema_id__ =
2184 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2185 ;
2186 }
2187 GeneratedField::DatabaseId => {
2188 if database_id__.is_some() {
2189 return Err(serde::de::Error::duplicate_field("databaseId"));
2190 }
2191 database_id__ =
2192 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2193 ;
2194 }
2195 GeneratedField::Name => {
2196 if name__.is_some() {
2197 return Err(serde::de::Error::duplicate_field("name"));
2198 }
2199 name__ = Some(map_.next_value()?);
2200 }
2201 GeneratedField::Owner => {
2202 if owner__.is_some() {
2203 return Err(serde::de::Error::duplicate_field("owner"));
2204 }
2205 owner__ =
2206 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2207 ;
2208 }
2209 GeneratedField::IndexTableId => {
2210 if index_table_id__.is_some() {
2211 return Err(serde::de::Error::duplicate_field("indexTableId"));
2212 }
2213 index_table_id__ =
2214 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2215 ;
2216 }
2217 GeneratedField::PrimaryTableId => {
2218 if primary_table_id__.is_some() {
2219 return Err(serde::de::Error::duplicate_field("primaryTableId"));
2220 }
2221 primary_table_id__ =
2222 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2223 ;
2224 }
2225 GeneratedField::IndexItem => {
2226 if index_item__.is_some() {
2227 return Err(serde::de::Error::duplicate_field("indexItem"));
2228 }
2229 index_item__ = Some(map_.next_value()?);
2230 }
2231 GeneratedField::IndexColumnProperties => {
2232 if index_column_properties__.is_some() {
2233 return Err(serde::de::Error::duplicate_field("indexColumnProperties"));
2234 }
2235 index_column_properties__ = Some(map_.next_value()?);
2236 }
2237 GeneratedField::InitializedAtEpoch => {
2238 if initialized_at_epoch__.is_some() {
2239 return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
2240 }
2241 initialized_at_epoch__ =
2242 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2243 ;
2244 }
2245 GeneratedField::CreatedAtEpoch => {
2246 if created_at_epoch__.is_some() {
2247 return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
2248 }
2249 created_at_epoch__ =
2250 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2251 ;
2252 }
2253 GeneratedField::StreamJobStatus => {
2254 if stream_job_status__.is_some() {
2255 return Err(serde::de::Error::duplicate_field("streamJobStatus"));
2256 }
2257 stream_job_status__ = Some(map_.next_value::<StreamJobStatus>()? as i32);
2258 }
2259 GeneratedField::IndexColumnsLen => {
2260 if index_columns_len__.is_some() {
2261 return Err(serde::de::Error::duplicate_field("indexColumnsLen"));
2262 }
2263 index_columns_len__ =
2264 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2265 ;
2266 }
2267 GeneratedField::InitializedAtClusterVersion => {
2268 if initialized_at_cluster_version__.is_some() {
2269 return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
2270 }
2271 initialized_at_cluster_version__ = map_.next_value()?;
2272 }
2273 GeneratedField::CreatedAtClusterVersion => {
2274 if created_at_cluster_version__.is_some() {
2275 return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
2276 }
2277 created_at_cluster_version__ = map_.next_value()?;
2278 }
2279 }
2280 }
2281 Ok(Index {
2282 id: id__.unwrap_or_default(),
2283 schema_id: schema_id__.unwrap_or_default(),
2284 database_id: database_id__.unwrap_or_default(),
2285 name: name__.unwrap_or_default(),
2286 owner: owner__.unwrap_or_default(),
2287 index_table_id: index_table_id__.unwrap_or_default(),
2288 primary_table_id: primary_table_id__.unwrap_or_default(),
2289 index_item: index_item__.unwrap_or_default(),
2290 index_column_properties: index_column_properties__.unwrap_or_default(),
2291 initialized_at_epoch: initialized_at_epoch__,
2292 created_at_epoch: created_at_epoch__,
2293 stream_job_status: stream_job_status__.unwrap_or_default(),
2294 index_columns_len: index_columns_len__.unwrap_or_default(),
2295 initialized_at_cluster_version: initialized_at_cluster_version__,
2296 created_at_cluster_version: created_at_cluster_version__,
2297 })
2298 }
2299 }
2300 deserializer.deserialize_struct("catalog.Index", FIELDS, GeneratedVisitor)
2301 }
2302}
2303impl serde::Serialize for IndexColumnProperties {
2304 #[allow(deprecated)]
2305 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2306 where
2307 S: serde::Serializer,
2308 {
2309 use serde::ser::SerializeStruct;
2310 let mut len = 0;
2311 if self.is_desc {
2312 len += 1;
2313 }
2314 if self.nulls_first {
2315 len += 1;
2316 }
2317 let mut struct_ser = serializer.serialize_struct("catalog.IndexColumnProperties", len)?;
2318 if self.is_desc {
2319 struct_ser.serialize_field("isDesc", &self.is_desc)?;
2320 }
2321 if self.nulls_first {
2322 struct_ser.serialize_field("nullsFirst", &self.nulls_first)?;
2323 }
2324 struct_ser.end()
2325 }
2326}
2327impl<'de> serde::Deserialize<'de> for IndexColumnProperties {
2328 #[allow(deprecated)]
2329 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2330 where
2331 D: serde::Deserializer<'de>,
2332 {
2333 const FIELDS: &[&str] = &[
2334 "is_desc",
2335 "isDesc",
2336 "nulls_first",
2337 "nullsFirst",
2338 ];
2339
2340 #[allow(clippy::enum_variant_names)]
2341 enum GeneratedField {
2342 IsDesc,
2343 NullsFirst,
2344 }
2345 impl<'de> serde::Deserialize<'de> for GeneratedField {
2346 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2347 where
2348 D: serde::Deserializer<'de>,
2349 {
2350 struct GeneratedVisitor;
2351
2352 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2353 type Value = GeneratedField;
2354
2355 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2356 write!(formatter, "expected one of: {:?}", &FIELDS)
2357 }
2358
2359 #[allow(unused_variables)]
2360 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2361 where
2362 E: serde::de::Error,
2363 {
2364 match value {
2365 "isDesc" | "is_desc" => Ok(GeneratedField::IsDesc),
2366 "nullsFirst" | "nulls_first" => Ok(GeneratedField::NullsFirst),
2367 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2368 }
2369 }
2370 }
2371 deserializer.deserialize_identifier(GeneratedVisitor)
2372 }
2373 }
2374 struct GeneratedVisitor;
2375 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2376 type Value = IndexColumnProperties;
2377
2378 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2379 formatter.write_str("struct catalog.IndexColumnProperties")
2380 }
2381
2382 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IndexColumnProperties, V::Error>
2383 where
2384 V: serde::de::MapAccess<'de>,
2385 {
2386 let mut is_desc__ = None;
2387 let mut nulls_first__ = None;
2388 while let Some(k) = map_.next_key()? {
2389 match k {
2390 GeneratedField::IsDesc => {
2391 if is_desc__.is_some() {
2392 return Err(serde::de::Error::duplicate_field("isDesc"));
2393 }
2394 is_desc__ = Some(map_.next_value()?);
2395 }
2396 GeneratedField::NullsFirst => {
2397 if nulls_first__.is_some() {
2398 return Err(serde::de::Error::duplicate_field("nullsFirst"));
2399 }
2400 nulls_first__ = Some(map_.next_value()?);
2401 }
2402 }
2403 }
2404 Ok(IndexColumnProperties {
2405 is_desc: is_desc__.unwrap_or_default(),
2406 nulls_first: nulls_first__.unwrap_or_default(),
2407 })
2408 }
2409 }
2410 deserializer.deserialize_struct("catalog.IndexColumnProperties", FIELDS, GeneratedVisitor)
2411 }
2412}
2413impl serde::Serialize for OptionsWithSecret {
2414 #[allow(deprecated)]
2415 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2416 where
2417 S: serde::Serializer,
2418 {
2419 use serde::ser::SerializeStruct;
2420 let mut len = 0;
2421 if !self.options.is_empty() {
2422 len += 1;
2423 }
2424 if !self.secret_refs.is_empty() {
2425 len += 1;
2426 }
2427 let mut struct_ser = serializer.serialize_struct("catalog.OptionsWithSecret", len)?;
2428 if !self.options.is_empty() {
2429 struct_ser.serialize_field("options", &self.options)?;
2430 }
2431 if !self.secret_refs.is_empty() {
2432 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
2433 }
2434 struct_ser.end()
2435 }
2436}
2437impl<'de> serde::Deserialize<'de> for OptionsWithSecret {
2438 #[allow(deprecated)]
2439 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2440 where
2441 D: serde::Deserializer<'de>,
2442 {
2443 const FIELDS: &[&str] = &[
2444 "options",
2445 "secret_refs",
2446 "secretRefs",
2447 ];
2448
2449 #[allow(clippy::enum_variant_names)]
2450 enum GeneratedField {
2451 Options,
2452 SecretRefs,
2453 }
2454 impl<'de> serde::Deserialize<'de> for GeneratedField {
2455 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2456 where
2457 D: serde::Deserializer<'de>,
2458 {
2459 struct GeneratedVisitor;
2460
2461 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2462 type Value = GeneratedField;
2463
2464 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2465 write!(formatter, "expected one of: {:?}", &FIELDS)
2466 }
2467
2468 #[allow(unused_variables)]
2469 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2470 where
2471 E: serde::de::Error,
2472 {
2473 match value {
2474 "options" => Ok(GeneratedField::Options),
2475 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
2476 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2477 }
2478 }
2479 }
2480 deserializer.deserialize_identifier(GeneratedVisitor)
2481 }
2482 }
2483 struct GeneratedVisitor;
2484 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2485 type Value = OptionsWithSecret;
2486
2487 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2488 formatter.write_str("struct catalog.OptionsWithSecret")
2489 }
2490
2491 fn visit_map<V>(self, mut map_: V) -> std::result::Result<OptionsWithSecret, V::Error>
2492 where
2493 V: serde::de::MapAccess<'de>,
2494 {
2495 let mut options__ = None;
2496 let mut secret_refs__ = None;
2497 while let Some(k) = map_.next_key()? {
2498 match k {
2499 GeneratedField::Options => {
2500 if options__.is_some() {
2501 return Err(serde::de::Error::duplicate_field("options"));
2502 }
2503 options__ = Some(
2504 map_.next_value::<std::collections::HashMap<_, _>>()?
2505 );
2506 }
2507 GeneratedField::SecretRefs => {
2508 if secret_refs__.is_some() {
2509 return Err(serde::de::Error::duplicate_field("secretRefs"));
2510 }
2511 secret_refs__ = Some(
2512 map_.next_value::<std::collections::HashMap<_, _>>()?
2513 );
2514 }
2515 }
2516 }
2517 Ok(OptionsWithSecret {
2518 options: options__.unwrap_or_default(),
2519 secret_refs: secret_refs__.unwrap_or_default(),
2520 })
2521 }
2522 }
2523 deserializer.deserialize_struct("catalog.OptionsWithSecret", FIELDS, GeneratedVisitor)
2524 }
2525}
2526impl serde::Serialize for Schema {
2527 #[allow(deprecated)]
2528 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2529 where
2530 S: serde::Serializer,
2531 {
2532 use serde::ser::SerializeStruct;
2533 let mut len = 0;
2534 if self.id != 0 {
2535 len += 1;
2536 }
2537 if self.database_id != 0 {
2538 len += 1;
2539 }
2540 if !self.name.is_empty() {
2541 len += 1;
2542 }
2543 if self.owner != 0 {
2544 len += 1;
2545 }
2546 let mut struct_ser = serializer.serialize_struct("catalog.Schema", len)?;
2547 if self.id != 0 {
2548 struct_ser.serialize_field("id", &self.id)?;
2549 }
2550 if self.database_id != 0 {
2551 struct_ser.serialize_field("databaseId", &self.database_id)?;
2552 }
2553 if !self.name.is_empty() {
2554 struct_ser.serialize_field("name", &self.name)?;
2555 }
2556 if self.owner != 0 {
2557 struct_ser.serialize_field("owner", &self.owner)?;
2558 }
2559 struct_ser.end()
2560 }
2561}
2562impl<'de> serde::Deserialize<'de> for Schema {
2563 #[allow(deprecated)]
2564 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2565 where
2566 D: serde::Deserializer<'de>,
2567 {
2568 const FIELDS: &[&str] = &[
2569 "id",
2570 "database_id",
2571 "databaseId",
2572 "name",
2573 "owner",
2574 ];
2575
2576 #[allow(clippy::enum_variant_names)]
2577 enum GeneratedField {
2578 Id,
2579 DatabaseId,
2580 Name,
2581 Owner,
2582 }
2583 impl<'de> serde::Deserialize<'de> for GeneratedField {
2584 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2585 where
2586 D: serde::Deserializer<'de>,
2587 {
2588 struct GeneratedVisitor;
2589
2590 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2591 type Value = GeneratedField;
2592
2593 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2594 write!(formatter, "expected one of: {:?}", &FIELDS)
2595 }
2596
2597 #[allow(unused_variables)]
2598 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2599 where
2600 E: serde::de::Error,
2601 {
2602 match value {
2603 "id" => Ok(GeneratedField::Id),
2604 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
2605 "name" => Ok(GeneratedField::Name),
2606 "owner" => Ok(GeneratedField::Owner),
2607 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2608 }
2609 }
2610 }
2611 deserializer.deserialize_identifier(GeneratedVisitor)
2612 }
2613 }
2614 struct GeneratedVisitor;
2615 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2616 type Value = Schema;
2617
2618 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2619 formatter.write_str("struct catalog.Schema")
2620 }
2621
2622 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Schema, V::Error>
2623 where
2624 V: serde::de::MapAccess<'de>,
2625 {
2626 let mut id__ = None;
2627 let mut database_id__ = None;
2628 let mut name__ = None;
2629 let mut owner__ = None;
2630 while let Some(k) = map_.next_key()? {
2631 match k {
2632 GeneratedField::Id => {
2633 if id__.is_some() {
2634 return Err(serde::de::Error::duplicate_field("id"));
2635 }
2636 id__ =
2637 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2638 ;
2639 }
2640 GeneratedField::DatabaseId => {
2641 if database_id__.is_some() {
2642 return Err(serde::de::Error::duplicate_field("databaseId"));
2643 }
2644 database_id__ =
2645 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2646 ;
2647 }
2648 GeneratedField::Name => {
2649 if name__.is_some() {
2650 return Err(serde::de::Error::duplicate_field("name"));
2651 }
2652 name__ = Some(map_.next_value()?);
2653 }
2654 GeneratedField::Owner => {
2655 if owner__.is_some() {
2656 return Err(serde::de::Error::duplicate_field("owner"));
2657 }
2658 owner__ =
2659 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2660 ;
2661 }
2662 }
2663 }
2664 Ok(Schema {
2665 id: id__.unwrap_or_default(),
2666 database_id: database_id__.unwrap_or_default(),
2667 name: name__.unwrap_or_default(),
2668 owner: owner__.unwrap_or_default(),
2669 })
2670 }
2671 }
2672 deserializer.deserialize_struct("catalog.Schema", FIELDS, GeneratedVisitor)
2673 }
2674}
2675impl serde::Serialize for SchemaRegistryNameStrategy {
2676 #[allow(deprecated)]
2677 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2678 where
2679 S: serde::Serializer,
2680 {
2681 let variant = match self {
2682 Self::Unspecified => "SCHEMA_REGISTRY_NAME_STRATEGY_UNSPECIFIED",
2683 Self::RecordNameStrategy => "SCHEMA_REGISTRY_NAME_STRATEGY_RECORD_NAME_STRATEGY",
2684 Self::TopicRecordNameStrategy => "SCHEMA_REGISTRY_NAME_STRATEGY_TOPIC_RECORD_NAME_STRATEGY",
2685 };
2686 serializer.serialize_str(variant)
2687 }
2688}
2689impl<'de> serde::Deserialize<'de> for SchemaRegistryNameStrategy {
2690 #[allow(deprecated)]
2691 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2692 where
2693 D: serde::Deserializer<'de>,
2694 {
2695 const FIELDS: &[&str] = &[
2696 "SCHEMA_REGISTRY_NAME_STRATEGY_UNSPECIFIED",
2697 "SCHEMA_REGISTRY_NAME_STRATEGY_RECORD_NAME_STRATEGY",
2698 "SCHEMA_REGISTRY_NAME_STRATEGY_TOPIC_RECORD_NAME_STRATEGY",
2699 ];
2700
2701 struct GeneratedVisitor;
2702
2703 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2704 type Value = SchemaRegistryNameStrategy;
2705
2706 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2707 write!(formatter, "expected one of: {:?}", &FIELDS)
2708 }
2709
2710 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2711 where
2712 E: serde::de::Error,
2713 {
2714 i32::try_from(v)
2715 .ok()
2716 .and_then(|x| x.try_into().ok())
2717 .ok_or_else(|| {
2718 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2719 })
2720 }
2721
2722 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2723 where
2724 E: serde::de::Error,
2725 {
2726 i32::try_from(v)
2727 .ok()
2728 .and_then(|x| x.try_into().ok())
2729 .ok_or_else(|| {
2730 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2731 })
2732 }
2733
2734 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2735 where
2736 E: serde::de::Error,
2737 {
2738 match value {
2739 "SCHEMA_REGISTRY_NAME_STRATEGY_UNSPECIFIED" => Ok(SchemaRegistryNameStrategy::Unspecified),
2740 "SCHEMA_REGISTRY_NAME_STRATEGY_RECORD_NAME_STRATEGY" => Ok(SchemaRegistryNameStrategy::RecordNameStrategy),
2741 "SCHEMA_REGISTRY_NAME_STRATEGY_TOPIC_RECORD_NAME_STRATEGY" => Ok(SchemaRegistryNameStrategy::TopicRecordNameStrategy),
2742 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2743 }
2744 }
2745 }
2746 deserializer.deserialize_any(GeneratedVisitor)
2747 }
2748}
2749impl serde::Serialize for Secret {
2750 #[allow(deprecated)]
2751 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2752 where
2753 S: serde::Serializer,
2754 {
2755 use serde::ser::SerializeStruct;
2756 let mut len = 0;
2757 if self.id != 0 {
2758 len += 1;
2759 }
2760 if !self.name.is_empty() {
2761 len += 1;
2762 }
2763 if self.database_id != 0 {
2764 len += 1;
2765 }
2766 if !self.value.is_empty() {
2767 len += 1;
2768 }
2769 if self.owner != 0 {
2770 len += 1;
2771 }
2772 if self.schema_id != 0 {
2773 len += 1;
2774 }
2775 let mut struct_ser = serializer.serialize_struct("catalog.Secret", len)?;
2776 if self.id != 0 {
2777 struct_ser.serialize_field("id", &self.id)?;
2778 }
2779 if !self.name.is_empty() {
2780 struct_ser.serialize_field("name", &self.name)?;
2781 }
2782 if self.database_id != 0 {
2783 struct_ser.serialize_field("databaseId", &self.database_id)?;
2784 }
2785 if !self.value.is_empty() {
2786 #[allow(clippy::needless_borrow)]
2787 #[allow(clippy::needless_borrows_for_generic_args)]
2788 struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
2789 }
2790 if self.owner != 0 {
2791 struct_ser.serialize_field("owner", &self.owner)?;
2792 }
2793 if self.schema_id != 0 {
2794 struct_ser.serialize_field("schemaId", &self.schema_id)?;
2795 }
2796 struct_ser.end()
2797 }
2798}
2799impl<'de> serde::Deserialize<'de> for Secret {
2800 #[allow(deprecated)]
2801 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2802 where
2803 D: serde::Deserializer<'de>,
2804 {
2805 const FIELDS: &[&str] = &[
2806 "id",
2807 "name",
2808 "database_id",
2809 "databaseId",
2810 "value",
2811 "owner",
2812 "schema_id",
2813 "schemaId",
2814 ];
2815
2816 #[allow(clippy::enum_variant_names)]
2817 enum GeneratedField {
2818 Id,
2819 Name,
2820 DatabaseId,
2821 Value,
2822 Owner,
2823 SchemaId,
2824 }
2825 impl<'de> serde::Deserialize<'de> for GeneratedField {
2826 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2827 where
2828 D: serde::Deserializer<'de>,
2829 {
2830 struct GeneratedVisitor;
2831
2832 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2833 type Value = GeneratedField;
2834
2835 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2836 write!(formatter, "expected one of: {:?}", &FIELDS)
2837 }
2838
2839 #[allow(unused_variables)]
2840 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2841 where
2842 E: serde::de::Error,
2843 {
2844 match value {
2845 "id" => Ok(GeneratedField::Id),
2846 "name" => Ok(GeneratedField::Name),
2847 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
2848 "value" => Ok(GeneratedField::Value),
2849 "owner" => Ok(GeneratedField::Owner),
2850 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
2851 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2852 }
2853 }
2854 }
2855 deserializer.deserialize_identifier(GeneratedVisitor)
2856 }
2857 }
2858 struct GeneratedVisitor;
2859 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2860 type Value = Secret;
2861
2862 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2863 formatter.write_str("struct catalog.Secret")
2864 }
2865
2866 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Secret, V::Error>
2867 where
2868 V: serde::de::MapAccess<'de>,
2869 {
2870 let mut id__ = None;
2871 let mut name__ = None;
2872 let mut database_id__ = None;
2873 let mut value__ = None;
2874 let mut owner__ = None;
2875 let mut schema_id__ = None;
2876 while let Some(k) = map_.next_key()? {
2877 match k {
2878 GeneratedField::Id => {
2879 if id__.is_some() {
2880 return Err(serde::de::Error::duplicate_field("id"));
2881 }
2882 id__ =
2883 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2884 ;
2885 }
2886 GeneratedField::Name => {
2887 if name__.is_some() {
2888 return Err(serde::de::Error::duplicate_field("name"));
2889 }
2890 name__ = Some(map_.next_value()?);
2891 }
2892 GeneratedField::DatabaseId => {
2893 if database_id__.is_some() {
2894 return Err(serde::de::Error::duplicate_field("databaseId"));
2895 }
2896 database_id__ =
2897 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2898 ;
2899 }
2900 GeneratedField::Value => {
2901 if value__.is_some() {
2902 return Err(serde::de::Error::duplicate_field("value"));
2903 }
2904 value__ =
2905 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
2906 ;
2907 }
2908 GeneratedField::Owner => {
2909 if owner__.is_some() {
2910 return Err(serde::de::Error::duplicate_field("owner"));
2911 }
2912 owner__ =
2913 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2914 ;
2915 }
2916 GeneratedField::SchemaId => {
2917 if schema_id__.is_some() {
2918 return Err(serde::de::Error::duplicate_field("schemaId"));
2919 }
2920 schema_id__ =
2921 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2922 ;
2923 }
2924 }
2925 }
2926 Ok(Secret {
2927 id: id__.unwrap_or_default(),
2928 name: name__.unwrap_or_default(),
2929 database_id: database_id__.unwrap_or_default(),
2930 value: value__.unwrap_or_default(),
2931 owner: owner__.unwrap_or_default(),
2932 schema_id: schema_id__.unwrap_or_default(),
2933 })
2934 }
2935 }
2936 deserializer.deserialize_struct("catalog.Secret", FIELDS, GeneratedVisitor)
2937 }
2938}
2939impl serde::Serialize for Sink {
2940 #[allow(deprecated)]
2941 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2942 where
2943 S: serde::Serializer,
2944 {
2945 use serde::ser::SerializeStruct;
2946 let mut len = 0;
2947 if self.id != 0 {
2948 len += 1;
2949 }
2950 if self.schema_id != 0 {
2951 len += 1;
2952 }
2953 if self.database_id != 0 {
2954 len += 1;
2955 }
2956 if !self.name.is_empty() {
2957 len += 1;
2958 }
2959 if !self.columns.is_empty() {
2960 len += 1;
2961 }
2962 if !self.plan_pk.is_empty() {
2963 len += 1;
2964 }
2965 if !self.dependent_relations.is_empty() {
2966 len += 1;
2967 }
2968 if !self.distribution_key.is_empty() {
2969 len += 1;
2970 }
2971 if !self.downstream_pk.is_empty() {
2972 len += 1;
2973 }
2974 if self.sink_type != 0 {
2975 len += 1;
2976 }
2977 if self.owner != 0 {
2978 len += 1;
2979 }
2980 if !self.properties.is_empty() {
2981 len += 1;
2982 }
2983 if !self.definition.is_empty() {
2984 len += 1;
2985 }
2986 if self.connection_id.is_some() {
2987 len += 1;
2988 }
2989 if self.initialized_at_epoch.is_some() {
2990 len += 1;
2991 }
2992 if self.created_at_epoch.is_some() {
2993 len += 1;
2994 }
2995 if !self.db_name.is_empty() {
2996 len += 1;
2997 }
2998 if !self.sink_from_name.is_empty() {
2999 len += 1;
3000 }
3001 if self.stream_job_status != 0 {
3002 len += 1;
3003 }
3004 if self.format_desc.is_some() {
3005 len += 1;
3006 }
3007 if self.target_table.is_some() {
3008 len += 1;
3009 }
3010 if self.initialized_at_cluster_version.is_some() {
3011 len += 1;
3012 }
3013 if self.created_at_cluster_version.is_some() {
3014 len += 1;
3015 }
3016 if self.create_type != 0 {
3017 len += 1;
3018 }
3019 if !self.secret_refs.is_empty() {
3020 len += 1;
3021 }
3022 if !self.original_target_columns.is_empty() {
3023 len += 1;
3024 }
3025 let mut struct_ser = serializer.serialize_struct("catalog.Sink", len)?;
3026 if self.id != 0 {
3027 struct_ser.serialize_field("id", &self.id)?;
3028 }
3029 if self.schema_id != 0 {
3030 struct_ser.serialize_field("schemaId", &self.schema_id)?;
3031 }
3032 if self.database_id != 0 {
3033 struct_ser.serialize_field("databaseId", &self.database_id)?;
3034 }
3035 if !self.name.is_empty() {
3036 struct_ser.serialize_field("name", &self.name)?;
3037 }
3038 if !self.columns.is_empty() {
3039 struct_ser.serialize_field("columns", &self.columns)?;
3040 }
3041 if !self.plan_pk.is_empty() {
3042 struct_ser.serialize_field("planPk", &self.plan_pk)?;
3043 }
3044 if !self.dependent_relations.is_empty() {
3045 struct_ser.serialize_field("dependentRelations", &self.dependent_relations)?;
3046 }
3047 if !self.distribution_key.is_empty() {
3048 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
3049 }
3050 if !self.downstream_pk.is_empty() {
3051 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
3052 }
3053 if self.sink_type != 0 {
3054 let v = SinkType::try_from(self.sink_type)
3055 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
3056 struct_ser.serialize_field("sinkType", &v)?;
3057 }
3058 if self.owner != 0 {
3059 struct_ser.serialize_field("owner", &self.owner)?;
3060 }
3061 if !self.properties.is_empty() {
3062 struct_ser.serialize_field("properties", &self.properties)?;
3063 }
3064 if !self.definition.is_empty() {
3065 struct_ser.serialize_field("definition", &self.definition)?;
3066 }
3067 if let Some(v) = self.connection_id.as_ref() {
3068 struct_ser.serialize_field("connectionId", v)?;
3069 }
3070 if let Some(v) = self.initialized_at_epoch.as_ref() {
3071 #[allow(clippy::needless_borrow)]
3072 #[allow(clippy::needless_borrows_for_generic_args)]
3073 struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
3074 }
3075 if let Some(v) = self.created_at_epoch.as_ref() {
3076 #[allow(clippy::needless_borrow)]
3077 #[allow(clippy::needless_borrows_for_generic_args)]
3078 struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
3079 }
3080 if !self.db_name.is_empty() {
3081 struct_ser.serialize_field("dbName", &self.db_name)?;
3082 }
3083 if !self.sink_from_name.is_empty() {
3084 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
3085 }
3086 if self.stream_job_status != 0 {
3087 let v = StreamJobStatus::try_from(self.stream_job_status)
3088 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_job_status)))?;
3089 struct_ser.serialize_field("streamJobStatus", &v)?;
3090 }
3091 if let Some(v) = self.format_desc.as_ref() {
3092 struct_ser.serialize_field("formatDesc", v)?;
3093 }
3094 if let Some(v) = self.target_table.as_ref() {
3095 struct_ser.serialize_field("targetTable", v)?;
3096 }
3097 if let Some(v) = self.initialized_at_cluster_version.as_ref() {
3098 struct_ser.serialize_field("initializedAtClusterVersion", v)?;
3099 }
3100 if let Some(v) = self.created_at_cluster_version.as_ref() {
3101 struct_ser.serialize_field("createdAtClusterVersion", v)?;
3102 }
3103 if self.create_type != 0 {
3104 let v = CreateType::try_from(self.create_type)
3105 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.create_type)))?;
3106 struct_ser.serialize_field("createType", &v)?;
3107 }
3108 if !self.secret_refs.is_empty() {
3109 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
3110 }
3111 if !self.original_target_columns.is_empty() {
3112 struct_ser.serialize_field("originalTargetColumns", &self.original_target_columns)?;
3113 }
3114 struct_ser.end()
3115 }
3116}
3117impl<'de> serde::Deserialize<'de> for Sink {
3118 #[allow(deprecated)]
3119 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3120 where
3121 D: serde::Deserializer<'de>,
3122 {
3123 const FIELDS: &[&str] = &[
3124 "id",
3125 "schema_id",
3126 "schemaId",
3127 "database_id",
3128 "databaseId",
3129 "name",
3130 "columns",
3131 "plan_pk",
3132 "planPk",
3133 "dependent_relations",
3134 "dependentRelations",
3135 "distribution_key",
3136 "distributionKey",
3137 "downstream_pk",
3138 "downstreamPk",
3139 "sink_type",
3140 "sinkType",
3141 "owner",
3142 "properties",
3143 "definition",
3144 "connection_id",
3145 "connectionId",
3146 "initialized_at_epoch",
3147 "initializedAtEpoch",
3148 "created_at_epoch",
3149 "createdAtEpoch",
3150 "db_name",
3151 "dbName",
3152 "sink_from_name",
3153 "sinkFromName",
3154 "stream_job_status",
3155 "streamJobStatus",
3156 "format_desc",
3157 "formatDesc",
3158 "target_table",
3159 "targetTable",
3160 "initialized_at_cluster_version",
3161 "initializedAtClusterVersion",
3162 "created_at_cluster_version",
3163 "createdAtClusterVersion",
3164 "create_type",
3165 "createType",
3166 "secret_refs",
3167 "secretRefs",
3168 "original_target_columns",
3169 "originalTargetColumns",
3170 ];
3171
3172 #[allow(clippy::enum_variant_names)]
3173 enum GeneratedField {
3174 Id,
3175 SchemaId,
3176 DatabaseId,
3177 Name,
3178 Columns,
3179 PlanPk,
3180 DependentRelations,
3181 DistributionKey,
3182 DownstreamPk,
3183 SinkType,
3184 Owner,
3185 Properties,
3186 Definition,
3187 ConnectionId,
3188 InitializedAtEpoch,
3189 CreatedAtEpoch,
3190 DbName,
3191 SinkFromName,
3192 StreamJobStatus,
3193 FormatDesc,
3194 TargetTable,
3195 InitializedAtClusterVersion,
3196 CreatedAtClusterVersion,
3197 CreateType,
3198 SecretRefs,
3199 OriginalTargetColumns,
3200 }
3201 impl<'de> serde::Deserialize<'de> for GeneratedField {
3202 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3203 where
3204 D: serde::Deserializer<'de>,
3205 {
3206 struct GeneratedVisitor;
3207
3208 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3209 type Value = GeneratedField;
3210
3211 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3212 write!(formatter, "expected one of: {:?}", &FIELDS)
3213 }
3214
3215 #[allow(unused_variables)]
3216 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3217 where
3218 E: serde::de::Error,
3219 {
3220 match value {
3221 "id" => Ok(GeneratedField::Id),
3222 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
3223 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
3224 "name" => Ok(GeneratedField::Name),
3225 "columns" => Ok(GeneratedField::Columns),
3226 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
3227 "dependentRelations" | "dependent_relations" => Ok(GeneratedField::DependentRelations),
3228 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
3229 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
3230 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
3231 "owner" => Ok(GeneratedField::Owner),
3232 "properties" => Ok(GeneratedField::Properties),
3233 "definition" => Ok(GeneratedField::Definition),
3234 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
3235 "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
3236 "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
3237 "dbName" | "db_name" => Ok(GeneratedField::DbName),
3238 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
3239 "streamJobStatus" | "stream_job_status" => Ok(GeneratedField::StreamJobStatus),
3240 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
3241 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
3242 "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
3243 "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
3244 "createType" | "create_type" => Ok(GeneratedField::CreateType),
3245 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
3246 "originalTargetColumns" | "original_target_columns" => Ok(GeneratedField::OriginalTargetColumns),
3247 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3248 }
3249 }
3250 }
3251 deserializer.deserialize_identifier(GeneratedVisitor)
3252 }
3253 }
3254 struct GeneratedVisitor;
3255 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3256 type Value = Sink;
3257
3258 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3259 formatter.write_str("struct catalog.Sink")
3260 }
3261
3262 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Sink, V::Error>
3263 where
3264 V: serde::de::MapAccess<'de>,
3265 {
3266 let mut id__ = None;
3267 let mut schema_id__ = None;
3268 let mut database_id__ = None;
3269 let mut name__ = None;
3270 let mut columns__ = None;
3271 let mut plan_pk__ = None;
3272 let mut dependent_relations__ = None;
3273 let mut distribution_key__ = None;
3274 let mut downstream_pk__ = None;
3275 let mut sink_type__ = None;
3276 let mut owner__ = None;
3277 let mut properties__ = None;
3278 let mut definition__ = None;
3279 let mut connection_id__ = None;
3280 let mut initialized_at_epoch__ = None;
3281 let mut created_at_epoch__ = None;
3282 let mut db_name__ = None;
3283 let mut sink_from_name__ = None;
3284 let mut stream_job_status__ = None;
3285 let mut format_desc__ = None;
3286 let mut target_table__ = None;
3287 let mut initialized_at_cluster_version__ = None;
3288 let mut created_at_cluster_version__ = None;
3289 let mut create_type__ = None;
3290 let mut secret_refs__ = None;
3291 let mut original_target_columns__ = None;
3292 while let Some(k) = map_.next_key()? {
3293 match k {
3294 GeneratedField::Id => {
3295 if id__.is_some() {
3296 return Err(serde::de::Error::duplicate_field("id"));
3297 }
3298 id__ =
3299 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3300 ;
3301 }
3302 GeneratedField::SchemaId => {
3303 if schema_id__.is_some() {
3304 return Err(serde::de::Error::duplicate_field("schemaId"));
3305 }
3306 schema_id__ =
3307 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3308 ;
3309 }
3310 GeneratedField::DatabaseId => {
3311 if database_id__.is_some() {
3312 return Err(serde::de::Error::duplicate_field("databaseId"));
3313 }
3314 database_id__ =
3315 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3316 ;
3317 }
3318 GeneratedField::Name => {
3319 if name__.is_some() {
3320 return Err(serde::de::Error::duplicate_field("name"));
3321 }
3322 name__ = Some(map_.next_value()?);
3323 }
3324 GeneratedField::Columns => {
3325 if columns__.is_some() {
3326 return Err(serde::de::Error::duplicate_field("columns"));
3327 }
3328 columns__ = Some(map_.next_value()?);
3329 }
3330 GeneratedField::PlanPk => {
3331 if plan_pk__.is_some() {
3332 return Err(serde::de::Error::duplicate_field("planPk"));
3333 }
3334 plan_pk__ = Some(map_.next_value()?);
3335 }
3336 GeneratedField::DependentRelations => {
3337 if dependent_relations__.is_some() {
3338 return Err(serde::de::Error::duplicate_field("dependentRelations"));
3339 }
3340 dependent_relations__ =
3341 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3342 .into_iter().map(|x| x.0).collect())
3343 ;
3344 }
3345 GeneratedField::DistributionKey => {
3346 if distribution_key__.is_some() {
3347 return Err(serde::de::Error::duplicate_field("distributionKey"));
3348 }
3349 distribution_key__ =
3350 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3351 .into_iter().map(|x| x.0).collect())
3352 ;
3353 }
3354 GeneratedField::DownstreamPk => {
3355 if downstream_pk__.is_some() {
3356 return Err(serde::de::Error::duplicate_field("downstreamPk"));
3357 }
3358 downstream_pk__ =
3359 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3360 .into_iter().map(|x| x.0).collect())
3361 ;
3362 }
3363 GeneratedField::SinkType => {
3364 if sink_type__.is_some() {
3365 return Err(serde::de::Error::duplicate_field("sinkType"));
3366 }
3367 sink_type__ = Some(map_.next_value::<SinkType>()? as i32);
3368 }
3369 GeneratedField::Owner => {
3370 if owner__.is_some() {
3371 return Err(serde::de::Error::duplicate_field("owner"));
3372 }
3373 owner__ =
3374 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3375 ;
3376 }
3377 GeneratedField::Properties => {
3378 if properties__.is_some() {
3379 return Err(serde::de::Error::duplicate_field("properties"));
3380 }
3381 properties__ = Some(
3382 map_.next_value::<std::collections::BTreeMap<_, _>>()?
3383 );
3384 }
3385 GeneratedField::Definition => {
3386 if definition__.is_some() {
3387 return Err(serde::de::Error::duplicate_field("definition"));
3388 }
3389 definition__ = Some(map_.next_value()?);
3390 }
3391 GeneratedField::ConnectionId => {
3392 if connection_id__.is_some() {
3393 return Err(serde::de::Error::duplicate_field("connectionId"));
3394 }
3395 connection_id__ =
3396 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3397 ;
3398 }
3399 GeneratedField::InitializedAtEpoch => {
3400 if initialized_at_epoch__.is_some() {
3401 return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
3402 }
3403 initialized_at_epoch__ =
3404 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3405 ;
3406 }
3407 GeneratedField::CreatedAtEpoch => {
3408 if created_at_epoch__.is_some() {
3409 return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
3410 }
3411 created_at_epoch__ =
3412 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3413 ;
3414 }
3415 GeneratedField::DbName => {
3416 if db_name__.is_some() {
3417 return Err(serde::de::Error::duplicate_field("dbName"));
3418 }
3419 db_name__ = Some(map_.next_value()?);
3420 }
3421 GeneratedField::SinkFromName => {
3422 if sink_from_name__.is_some() {
3423 return Err(serde::de::Error::duplicate_field("sinkFromName"));
3424 }
3425 sink_from_name__ = Some(map_.next_value()?);
3426 }
3427 GeneratedField::StreamJobStatus => {
3428 if stream_job_status__.is_some() {
3429 return Err(serde::de::Error::duplicate_field("streamJobStatus"));
3430 }
3431 stream_job_status__ = Some(map_.next_value::<StreamJobStatus>()? as i32);
3432 }
3433 GeneratedField::FormatDesc => {
3434 if format_desc__.is_some() {
3435 return Err(serde::de::Error::duplicate_field("formatDesc"));
3436 }
3437 format_desc__ = map_.next_value()?;
3438 }
3439 GeneratedField::TargetTable => {
3440 if target_table__.is_some() {
3441 return Err(serde::de::Error::duplicate_field("targetTable"));
3442 }
3443 target_table__ =
3444 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3445 ;
3446 }
3447 GeneratedField::InitializedAtClusterVersion => {
3448 if initialized_at_cluster_version__.is_some() {
3449 return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
3450 }
3451 initialized_at_cluster_version__ = map_.next_value()?;
3452 }
3453 GeneratedField::CreatedAtClusterVersion => {
3454 if created_at_cluster_version__.is_some() {
3455 return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
3456 }
3457 created_at_cluster_version__ = map_.next_value()?;
3458 }
3459 GeneratedField::CreateType => {
3460 if create_type__.is_some() {
3461 return Err(serde::de::Error::duplicate_field("createType"));
3462 }
3463 create_type__ = Some(map_.next_value::<CreateType>()? as i32);
3464 }
3465 GeneratedField::SecretRefs => {
3466 if secret_refs__.is_some() {
3467 return Err(serde::de::Error::duplicate_field("secretRefs"));
3468 }
3469 secret_refs__ = Some(
3470 map_.next_value::<std::collections::BTreeMap<_, _>>()?
3471 );
3472 }
3473 GeneratedField::OriginalTargetColumns => {
3474 if original_target_columns__.is_some() {
3475 return Err(serde::de::Error::duplicate_field("originalTargetColumns"));
3476 }
3477 original_target_columns__ = Some(map_.next_value()?);
3478 }
3479 }
3480 }
3481 Ok(Sink {
3482 id: id__.unwrap_or_default(),
3483 schema_id: schema_id__.unwrap_or_default(),
3484 database_id: database_id__.unwrap_or_default(),
3485 name: name__.unwrap_or_default(),
3486 columns: columns__.unwrap_or_default(),
3487 plan_pk: plan_pk__.unwrap_or_default(),
3488 dependent_relations: dependent_relations__.unwrap_or_default(),
3489 distribution_key: distribution_key__.unwrap_or_default(),
3490 downstream_pk: downstream_pk__.unwrap_or_default(),
3491 sink_type: sink_type__.unwrap_or_default(),
3492 owner: owner__.unwrap_or_default(),
3493 properties: properties__.unwrap_or_default(),
3494 definition: definition__.unwrap_or_default(),
3495 connection_id: connection_id__,
3496 initialized_at_epoch: initialized_at_epoch__,
3497 created_at_epoch: created_at_epoch__,
3498 db_name: db_name__.unwrap_or_default(),
3499 sink_from_name: sink_from_name__.unwrap_or_default(),
3500 stream_job_status: stream_job_status__.unwrap_or_default(),
3501 format_desc: format_desc__,
3502 target_table: target_table__,
3503 initialized_at_cluster_version: initialized_at_cluster_version__,
3504 created_at_cluster_version: created_at_cluster_version__,
3505 create_type: create_type__.unwrap_or_default(),
3506 secret_refs: secret_refs__.unwrap_or_default(),
3507 original_target_columns: original_target_columns__.unwrap_or_default(),
3508 })
3509 }
3510 }
3511 deserializer.deserialize_struct("catalog.Sink", FIELDS, GeneratedVisitor)
3512 }
3513}
3514impl serde::Serialize for SinkFormatDesc {
3515 #[allow(deprecated)]
3516 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3517 where
3518 S: serde::Serializer,
3519 {
3520 use serde::ser::SerializeStruct;
3521 let mut len = 0;
3522 if self.format != 0 {
3523 len += 1;
3524 }
3525 if self.encode != 0 {
3526 len += 1;
3527 }
3528 if !self.options.is_empty() {
3529 len += 1;
3530 }
3531 if self.key_encode.is_some() {
3532 len += 1;
3533 }
3534 if !self.secret_refs.is_empty() {
3535 len += 1;
3536 }
3537 if self.connection_id.is_some() {
3538 len += 1;
3539 }
3540 let mut struct_ser = serializer.serialize_struct("catalog.SinkFormatDesc", len)?;
3541 if self.format != 0 {
3542 let v = super::plan_common::FormatType::try_from(self.format)
3543 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?;
3544 struct_ser.serialize_field("format", &v)?;
3545 }
3546 if self.encode != 0 {
3547 let v = super::plan_common::EncodeType::try_from(self.encode)
3548 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.encode)))?;
3549 struct_ser.serialize_field("encode", &v)?;
3550 }
3551 if !self.options.is_empty() {
3552 struct_ser.serialize_field("options", &self.options)?;
3553 }
3554 if let Some(v) = self.key_encode.as_ref() {
3555 let v = super::plan_common::EncodeType::try_from(*v)
3556 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
3557 struct_ser.serialize_field("keyEncode", &v)?;
3558 }
3559 if !self.secret_refs.is_empty() {
3560 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
3561 }
3562 if let Some(v) = self.connection_id.as_ref() {
3563 struct_ser.serialize_field("connectionId", v)?;
3564 }
3565 struct_ser.end()
3566 }
3567}
3568impl<'de> serde::Deserialize<'de> for SinkFormatDesc {
3569 #[allow(deprecated)]
3570 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3571 where
3572 D: serde::Deserializer<'de>,
3573 {
3574 const FIELDS: &[&str] = &[
3575 "format",
3576 "encode",
3577 "options",
3578 "key_encode",
3579 "keyEncode",
3580 "secret_refs",
3581 "secretRefs",
3582 "connection_id",
3583 "connectionId",
3584 ];
3585
3586 #[allow(clippy::enum_variant_names)]
3587 enum GeneratedField {
3588 Format,
3589 Encode,
3590 Options,
3591 KeyEncode,
3592 SecretRefs,
3593 ConnectionId,
3594 }
3595 impl<'de> serde::Deserialize<'de> for GeneratedField {
3596 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3597 where
3598 D: serde::Deserializer<'de>,
3599 {
3600 struct GeneratedVisitor;
3601
3602 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3603 type Value = GeneratedField;
3604
3605 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3606 write!(formatter, "expected one of: {:?}", &FIELDS)
3607 }
3608
3609 #[allow(unused_variables)]
3610 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3611 where
3612 E: serde::de::Error,
3613 {
3614 match value {
3615 "format" => Ok(GeneratedField::Format),
3616 "encode" => Ok(GeneratedField::Encode),
3617 "options" => Ok(GeneratedField::Options),
3618 "keyEncode" | "key_encode" => Ok(GeneratedField::KeyEncode),
3619 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
3620 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
3621 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3622 }
3623 }
3624 }
3625 deserializer.deserialize_identifier(GeneratedVisitor)
3626 }
3627 }
3628 struct GeneratedVisitor;
3629 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3630 type Value = SinkFormatDesc;
3631
3632 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3633 formatter.write_str("struct catalog.SinkFormatDesc")
3634 }
3635
3636 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkFormatDesc, V::Error>
3637 where
3638 V: serde::de::MapAccess<'de>,
3639 {
3640 let mut format__ = None;
3641 let mut encode__ = None;
3642 let mut options__ = None;
3643 let mut key_encode__ = None;
3644 let mut secret_refs__ = None;
3645 let mut connection_id__ = None;
3646 while let Some(k) = map_.next_key()? {
3647 match k {
3648 GeneratedField::Format => {
3649 if format__.is_some() {
3650 return Err(serde::de::Error::duplicate_field("format"));
3651 }
3652 format__ = Some(map_.next_value::<super::plan_common::FormatType>()? as i32);
3653 }
3654 GeneratedField::Encode => {
3655 if encode__.is_some() {
3656 return Err(serde::de::Error::duplicate_field("encode"));
3657 }
3658 encode__ = Some(map_.next_value::<super::plan_common::EncodeType>()? as i32);
3659 }
3660 GeneratedField::Options => {
3661 if options__.is_some() {
3662 return Err(serde::de::Error::duplicate_field("options"));
3663 }
3664 options__ = Some(
3665 map_.next_value::<std::collections::BTreeMap<_, _>>()?
3666 );
3667 }
3668 GeneratedField::KeyEncode => {
3669 if key_encode__.is_some() {
3670 return Err(serde::de::Error::duplicate_field("keyEncode"));
3671 }
3672 key_encode__ = map_.next_value::<::std::option::Option<super::plan_common::EncodeType>>()?.map(|x| x as i32);
3673 }
3674 GeneratedField::SecretRefs => {
3675 if secret_refs__.is_some() {
3676 return Err(serde::de::Error::duplicate_field("secretRefs"));
3677 }
3678 secret_refs__ = Some(
3679 map_.next_value::<std::collections::BTreeMap<_, _>>()?
3680 );
3681 }
3682 GeneratedField::ConnectionId => {
3683 if connection_id__.is_some() {
3684 return Err(serde::de::Error::duplicate_field("connectionId"));
3685 }
3686 connection_id__ =
3687 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3688 ;
3689 }
3690 }
3691 }
3692 Ok(SinkFormatDesc {
3693 format: format__.unwrap_or_default(),
3694 encode: encode__.unwrap_or_default(),
3695 options: options__.unwrap_or_default(),
3696 key_encode: key_encode__,
3697 secret_refs: secret_refs__.unwrap_or_default(),
3698 connection_id: connection_id__,
3699 })
3700 }
3701 }
3702 deserializer.deserialize_struct("catalog.SinkFormatDesc", FIELDS, GeneratedVisitor)
3703 }
3704}
3705impl serde::Serialize for SinkType {
3706 #[allow(deprecated)]
3707 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3708 where
3709 S: serde::Serializer,
3710 {
3711 let variant = match self {
3712 Self::Unspecified => "SINK_TYPE_UNSPECIFIED",
3713 Self::AppendOnly => "SINK_TYPE_APPEND_ONLY",
3714 Self::ForceAppendOnly => "SINK_TYPE_FORCE_APPEND_ONLY",
3715 Self::Upsert => "SINK_TYPE_UPSERT",
3716 };
3717 serializer.serialize_str(variant)
3718 }
3719}
3720impl<'de> serde::Deserialize<'de> for SinkType {
3721 #[allow(deprecated)]
3722 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3723 where
3724 D: serde::Deserializer<'de>,
3725 {
3726 const FIELDS: &[&str] = &[
3727 "SINK_TYPE_UNSPECIFIED",
3728 "SINK_TYPE_APPEND_ONLY",
3729 "SINK_TYPE_FORCE_APPEND_ONLY",
3730 "SINK_TYPE_UPSERT",
3731 ];
3732
3733 struct GeneratedVisitor;
3734
3735 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3736 type Value = SinkType;
3737
3738 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3739 write!(formatter, "expected one of: {:?}", &FIELDS)
3740 }
3741
3742 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3743 where
3744 E: serde::de::Error,
3745 {
3746 i32::try_from(v)
3747 .ok()
3748 .and_then(|x| x.try_into().ok())
3749 .ok_or_else(|| {
3750 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3751 })
3752 }
3753
3754 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3755 where
3756 E: serde::de::Error,
3757 {
3758 i32::try_from(v)
3759 .ok()
3760 .and_then(|x| x.try_into().ok())
3761 .ok_or_else(|| {
3762 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3763 })
3764 }
3765
3766 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3767 where
3768 E: serde::de::Error,
3769 {
3770 match value {
3771 "SINK_TYPE_UNSPECIFIED" => Ok(SinkType::Unspecified),
3772 "SINK_TYPE_APPEND_ONLY" => Ok(SinkType::AppendOnly),
3773 "SINK_TYPE_FORCE_APPEND_ONLY" => Ok(SinkType::ForceAppendOnly),
3774 "SINK_TYPE_UPSERT" => Ok(SinkType::Upsert),
3775 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3776 }
3777 }
3778 }
3779 deserializer.deserialize_any(GeneratedVisitor)
3780 }
3781}
3782impl serde::Serialize for Source {
3783 #[allow(deprecated)]
3784 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3785 where
3786 S: serde::Serializer,
3787 {
3788 use serde::ser::SerializeStruct;
3789 let mut len = 0;
3790 if self.id != 0 {
3791 len += 1;
3792 }
3793 if self.schema_id != 0 {
3794 len += 1;
3795 }
3796 if self.database_id != 0 {
3797 len += 1;
3798 }
3799 if !self.name.is_empty() {
3800 len += 1;
3801 }
3802 if self.row_id_index.is_some() {
3803 len += 1;
3804 }
3805 if !self.columns.is_empty() {
3806 len += 1;
3807 }
3808 if !self.pk_column_ids.is_empty() {
3809 len += 1;
3810 }
3811 if !self.with_properties.is_empty() {
3812 len += 1;
3813 }
3814 if self.owner != 0 {
3815 len += 1;
3816 }
3817 if self.info.is_some() {
3818 len += 1;
3819 }
3820 if !self.watermark_descs.is_empty() {
3821 len += 1;
3822 }
3823 if !self.definition.is_empty() {
3824 len += 1;
3825 }
3826 if self.connection_id.is_some() {
3827 len += 1;
3828 }
3829 if self.initialized_at_epoch.is_some() {
3830 len += 1;
3831 }
3832 if self.created_at_epoch.is_some() {
3833 len += 1;
3834 }
3835 if self.initialized_at_cluster_version.is_some() {
3836 len += 1;
3837 }
3838 if self.created_at_cluster_version.is_some() {
3839 len += 1;
3840 }
3841 if !self.secret_refs.is_empty() {
3842 len += 1;
3843 }
3844 if self.version != 0 {
3845 len += 1;
3846 }
3847 if self.rate_limit.is_some() {
3848 len += 1;
3849 }
3850 if self.optional_associated_table_id.is_some() {
3851 len += 1;
3852 }
3853 let mut struct_ser = serializer.serialize_struct("catalog.Source", len)?;
3854 if self.id != 0 {
3855 struct_ser.serialize_field("id", &self.id)?;
3856 }
3857 if self.schema_id != 0 {
3858 struct_ser.serialize_field("schemaId", &self.schema_id)?;
3859 }
3860 if self.database_id != 0 {
3861 struct_ser.serialize_field("databaseId", &self.database_id)?;
3862 }
3863 if !self.name.is_empty() {
3864 struct_ser.serialize_field("name", &self.name)?;
3865 }
3866 if let Some(v) = self.row_id_index.as_ref() {
3867 struct_ser.serialize_field("rowIdIndex", v)?;
3868 }
3869 if !self.columns.is_empty() {
3870 struct_ser.serialize_field("columns", &self.columns)?;
3871 }
3872 if !self.pk_column_ids.is_empty() {
3873 struct_ser.serialize_field("pkColumnIds", &self.pk_column_ids)?;
3874 }
3875 if !self.with_properties.is_empty() {
3876 struct_ser.serialize_field("withProperties", &self.with_properties)?;
3877 }
3878 if self.owner != 0 {
3879 struct_ser.serialize_field("owner", &self.owner)?;
3880 }
3881 if let Some(v) = self.info.as_ref() {
3882 struct_ser.serialize_field("info", v)?;
3883 }
3884 if !self.watermark_descs.is_empty() {
3885 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
3886 }
3887 if !self.definition.is_empty() {
3888 struct_ser.serialize_field("definition", &self.definition)?;
3889 }
3890 if let Some(v) = self.connection_id.as_ref() {
3891 struct_ser.serialize_field("connectionId", v)?;
3892 }
3893 if let Some(v) = self.initialized_at_epoch.as_ref() {
3894 #[allow(clippy::needless_borrow)]
3895 #[allow(clippy::needless_borrows_for_generic_args)]
3896 struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
3897 }
3898 if let Some(v) = self.created_at_epoch.as_ref() {
3899 #[allow(clippy::needless_borrow)]
3900 #[allow(clippy::needless_borrows_for_generic_args)]
3901 struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
3902 }
3903 if let Some(v) = self.initialized_at_cluster_version.as_ref() {
3904 struct_ser.serialize_field("initializedAtClusterVersion", v)?;
3905 }
3906 if let Some(v) = self.created_at_cluster_version.as_ref() {
3907 struct_ser.serialize_field("createdAtClusterVersion", v)?;
3908 }
3909 if !self.secret_refs.is_empty() {
3910 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
3911 }
3912 if self.version != 0 {
3913 #[allow(clippy::needless_borrow)]
3914 #[allow(clippy::needless_borrows_for_generic_args)]
3915 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
3916 }
3917 if let Some(v) = self.rate_limit.as_ref() {
3918 struct_ser.serialize_field("rateLimit", v)?;
3919 }
3920 if let Some(v) = self.optional_associated_table_id.as_ref() {
3921 match v {
3922 source::OptionalAssociatedTableId::AssociatedTableId(v) => {
3923 struct_ser.serialize_field("associatedTableId", v)?;
3924 }
3925 }
3926 }
3927 struct_ser.end()
3928 }
3929}
3930impl<'de> serde::Deserialize<'de> for Source {
3931 #[allow(deprecated)]
3932 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3933 where
3934 D: serde::Deserializer<'de>,
3935 {
3936 const FIELDS: &[&str] = &[
3937 "id",
3938 "schema_id",
3939 "schemaId",
3940 "database_id",
3941 "databaseId",
3942 "name",
3943 "row_id_index",
3944 "rowIdIndex",
3945 "columns",
3946 "pk_column_ids",
3947 "pkColumnIds",
3948 "with_properties",
3949 "withProperties",
3950 "owner",
3951 "info",
3952 "watermark_descs",
3953 "watermarkDescs",
3954 "definition",
3955 "connection_id",
3956 "connectionId",
3957 "initialized_at_epoch",
3958 "initializedAtEpoch",
3959 "created_at_epoch",
3960 "createdAtEpoch",
3961 "initialized_at_cluster_version",
3962 "initializedAtClusterVersion",
3963 "created_at_cluster_version",
3964 "createdAtClusterVersion",
3965 "secret_refs",
3966 "secretRefs",
3967 "version",
3968 "rate_limit",
3969 "rateLimit",
3970 "associated_table_id",
3971 "associatedTableId",
3972 ];
3973
3974 #[allow(clippy::enum_variant_names)]
3975 enum GeneratedField {
3976 Id,
3977 SchemaId,
3978 DatabaseId,
3979 Name,
3980 RowIdIndex,
3981 Columns,
3982 PkColumnIds,
3983 WithProperties,
3984 Owner,
3985 Info,
3986 WatermarkDescs,
3987 Definition,
3988 ConnectionId,
3989 InitializedAtEpoch,
3990 CreatedAtEpoch,
3991 InitializedAtClusterVersion,
3992 CreatedAtClusterVersion,
3993 SecretRefs,
3994 Version,
3995 RateLimit,
3996 AssociatedTableId,
3997 }
3998 impl<'de> serde::Deserialize<'de> for GeneratedField {
3999 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4000 where
4001 D: serde::Deserializer<'de>,
4002 {
4003 struct GeneratedVisitor;
4004
4005 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4006 type Value = GeneratedField;
4007
4008 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4009 write!(formatter, "expected one of: {:?}", &FIELDS)
4010 }
4011
4012 #[allow(unused_variables)]
4013 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4014 where
4015 E: serde::de::Error,
4016 {
4017 match value {
4018 "id" => Ok(GeneratedField::Id),
4019 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
4020 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4021 "name" => Ok(GeneratedField::Name),
4022 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
4023 "columns" => Ok(GeneratedField::Columns),
4024 "pkColumnIds" | "pk_column_ids" => Ok(GeneratedField::PkColumnIds),
4025 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
4026 "owner" => Ok(GeneratedField::Owner),
4027 "info" => Ok(GeneratedField::Info),
4028 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
4029 "definition" => Ok(GeneratedField::Definition),
4030 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
4031 "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
4032 "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
4033 "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
4034 "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
4035 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
4036 "version" => Ok(GeneratedField::Version),
4037 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
4038 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
4039 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4040 }
4041 }
4042 }
4043 deserializer.deserialize_identifier(GeneratedVisitor)
4044 }
4045 }
4046 struct GeneratedVisitor;
4047 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4048 type Value = Source;
4049
4050 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4051 formatter.write_str("struct catalog.Source")
4052 }
4053
4054 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Source, V::Error>
4055 where
4056 V: serde::de::MapAccess<'de>,
4057 {
4058 let mut id__ = None;
4059 let mut schema_id__ = None;
4060 let mut database_id__ = None;
4061 let mut name__ = None;
4062 let mut row_id_index__ = None;
4063 let mut columns__ = None;
4064 let mut pk_column_ids__ = None;
4065 let mut with_properties__ = None;
4066 let mut owner__ = None;
4067 let mut info__ = None;
4068 let mut watermark_descs__ = None;
4069 let mut definition__ = None;
4070 let mut connection_id__ = None;
4071 let mut initialized_at_epoch__ = None;
4072 let mut created_at_epoch__ = None;
4073 let mut initialized_at_cluster_version__ = None;
4074 let mut created_at_cluster_version__ = None;
4075 let mut secret_refs__ = None;
4076 let mut version__ = None;
4077 let mut rate_limit__ = None;
4078 let mut optional_associated_table_id__ = None;
4079 while let Some(k) = map_.next_key()? {
4080 match k {
4081 GeneratedField::Id => {
4082 if id__.is_some() {
4083 return Err(serde::de::Error::duplicate_field("id"));
4084 }
4085 id__ =
4086 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4087 ;
4088 }
4089 GeneratedField::SchemaId => {
4090 if schema_id__.is_some() {
4091 return Err(serde::de::Error::duplicate_field("schemaId"));
4092 }
4093 schema_id__ =
4094 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4095 ;
4096 }
4097 GeneratedField::DatabaseId => {
4098 if database_id__.is_some() {
4099 return Err(serde::de::Error::duplicate_field("databaseId"));
4100 }
4101 database_id__ =
4102 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4103 ;
4104 }
4105 GeneratedField::Name => {
4106 if name__.is_some() {
4107 return Err(serde::de::Error::duplicate_field("name"));
4108 }
4109 name__ = Some(map_.next_value()?);
4110 }
4111 GeneratedField::RowIdIndex => {
4112 if row_id_index__.is_some() {
4113 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
4114 }
4115 row_id_index__ =
4116 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4117 ;
4118 }
4119 GeneratedField::Columns => {
4120 if columns__.is_some() {
4121 return Err(serde::de::Error::duplicate_field("columns"));
4122 }
4123 columns__ = Some(map_.next_value()?);
4124 }
4125 GeneratedField::PkColumnIds => {
4126 if pk_column_ids__.is_some() {
4127 return Err(serde::de::Error::duplicate_field("pkColumnIds"));
4128 }
4129 pk_column_ids__ =
4130 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4131 .into_iter().map(|x| x.0).collect())
4132 ;
4133 }
4134 GeneratedField::WithProperties => {
4135 if with_properties__.is_some() {
4136 return Err(serde::de::Error::duplicate_field("withProperties"));
4137 }
4138 with_properties__ = Some(
4139 map_.next_value::<std::collections::BTreeMap<_, _>>()?
4140 );
4141 }
4142 GeneratedField::Owner => {
4143 if owner__.is_some() {
4144 return Err(serde::de::Error::duplicate_field("owner"));
4145 }
4146 owner__ =
4147 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4148 ;
4149 }
4150 GeneratedField::Info => {
4151 if info__.is_some() {
4152 return Err(serde::de::Error::duplicate_field("info"));
4153 }
4154 info__ = map_.next_value()?;
4155 }
4156 GeneratedField::WatermarkDescs => {
4157 if watermark_descs__.is_some() {
4158 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
4159 }
4160 watermark_descs__ = Some(map_.next_value()?);
4161 }
4162 GeneratedField::Definition => {
4163 if definition__.is_some() {
4164 return Err(serde::de::Error::duplicate_field("definition"));
4165 }
4166 definition__ = Some(map_.next_value()?);
4167 }
4168 GeneratedField::ConnectionId => {
4169 if connection_id__.is_some() {
4170 return Err(serde::de::Error::duplicate_field("connectionId"));
4171 }
4172 connection_id__ =
4173 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4174 ;
4175 }
4176 GeneratedField::InitializedAtEpoch => {
4177 if initialized_at_epoch__.is_some() {
4178 return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
4179 }
4180 initialized_at_epoch__ =
4181 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4182 ;
4183 }
4184 GeneratedField::CreatedAtEpoch => {
4185 if created_at_epoch__.is_some() {
4186 return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
4187 }
4188 created_at_epoch__ =
4189 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4190 ;
4191 }
4192 GeneratedField::InitializedAtClusterVersion => {
4193 if initialized_at_cluster_version__.is_some() {
4194 return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
4195 }
4196 initialized_at_cluster_version__ = map_.next_value()?;
4197 }
4198 GeneratedField::CreatedAtClusterVersion => {
4199 if created_at_cluster_version__.is_some() {
4200 return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
4201 }
4202 created_at_cluster_version__ = map_.next_value()?;
4203 }
4204 GeneratedField::SecretRefs => {
4205 if secret_refs__.is_some() {
4206 return Err(serde::de::Error::duplicate_field("secretRefs"));
4207 }
4208 secret_refs__ = Some(
4209 map_.next_value::<std::collections::BTreeMap<_, _>>()?
4210 );
4211 }
4212 GeneratedField::Version => {
4213 if version__.is_some() {
4214 return Err(serde::de::Error::duplicate_field("version"));
4215 }
4216 version__ =
4217 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4218 ;
4219 }
4220 GeneratedField::RateLimit => {
4221 if rate_limit__.is_some() {
4222 return Err(serde::de::Error::duplicate_field("rateLimit"));
4223 }
4224 rate_limit__ =
4225 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4226 ;
4227 }
4228 GeneratedField::AssociatedTableId => {
4229 if optional_associated_table_id__.is_some() {
4230 return Err(serde::de::Error::duplicate_field("associatedTableId"));
4231 }
4232 optional_associated_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| source::OptionalAssociatedTableId::AssociatedTableId(x.0));
4233 }
4234 }
4235 }
4236 Ok(Source {
4237 id: id__.unwrap_or_default(),
4238 schema_id: schema_id__.unwrap_or_default(),
4239 database_id: database_id__.unwrap_or_default(),
4240 name: name__.unwrap_or_default(),
4241 row_id_index: row_id_index__,
4242 columns: columns__.unwrap_or_default(),
4243 pk_column_ids: pk_column_ids__.unwrap_or_default(),
4244 with_properties: with_properties__.unwrap_or_default(),
4245 owner: owner__.unwrap_or_default(),
4246 info: info__,
4247 watermark_descs: watermark_descs__.unwrap_or_default(),
4248 definition: definition__.unwrap_or_default(),
4249 connection_id: connection_id__,
4250 initialized_at_epoch: initialized_at_epoch__,
4251 created_at_epoch: created_at_epoch__,
4252 initialized_at_cluster_version: initialized_at_cluster_version__,
4253 created_at_cluster_version: created_at_cluster_version__,
4254 secret_refs: secret_refs__.unwrap_or_default(),
4255 version: version__.unwrap_or_default(),
4256 rate_limit: rate_limit__,
4257 optional_associated_table_id: optional_associated_table_id__,
4258 })
4259 }
4260 }
4261 deserializer.deserialize_struct("catalog.Source", FIELDS, GeneratedVisitor)
4262 }
4263}
4264impl serde::Serialize for StreamJobStatus {
4265 #[allow(deprecated)]
4266 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4267 where
4268 S: serde::Serializer,
4269 {
4270 let variant = match self {
4271 Self::Unspecified => "STREAM_JOB_STATUS_UNSPECIFIED",
4272 Self::Creating => "STREAM_JOB_STATUS_CREATING",
4273 Self::Created => "STREAM_JOB_STATUS_CREATED",
4274 };
4275 serializer.serialize_str(variant)
4276 }
4277}
4278impl<'de> serde::Deserialize<'de> for StreamJobStatus {
4279 #[allow(deprecated)]
4280 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4281 where
4282 D: serde::Deserializer<'de>,
4283 {
4284 const FIELDS: &[&str] = &[
4285 "STREAM_JOB_STATUS_UNSPECIFIED",
4286 "STREAM_JOB_STATUS_CREATING",
4287 "STREAM_JOB_STATUS_CREATED",
4288 ];
4289
4290 struct GeneratedVisitor;
4291
4292 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4293 type Value = StreamJobStatus;
4294
4295 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4296 write!(formatter, "expected one of: {:?}", &FIELDS)
4297 }
4298
4299 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
4300 where
4301 E: serde::de::Error,
4302 {
4303 i32::try_from(v)
4304 .ok()
4305 .and_then(|x| x.try_into().ok())
4306 .ok_or_else(|| {
4307 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
4308 })
4309 }
4310
4311 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
4312 where
4313 E: serde::de::Error,
4314 {
4315 i32::try_from(v)
4316 .ok()
4317 .and_then(|x| x.try_into().ok())
4318 .ok_or_else(|| {
4319 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
4320 })
4321 }
4322
4323 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
4324 where
4325 E: serde::de::Error,
4326 {
4327 match value {
4328 "STREAM_JOB_STATUS_UNSPECIFIED" => Ok(StreamJobStatus::Unspecified),
4329 "STREAM_JOB_STATUS_CREATING" => Ok(StreamJobStatus::Creating),
4330 "STREAM_JOB_STATUS_CREATED" => Ok(StreamJobStatus::Created),
4331 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
4332 }
4333 }
4334 }
4335 deserializer.deserialize_any(GeneratedVisitor)
4336 }
4337}
4338impl serde::Serialize for StreamSourceInfo {
4339 #[allow(deprecated)]
4340 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4341 where
4342 S: serde::Serializer,
4343 {
4344 use serde::ser::SerializeStruct;
4345 let mut len = 0;
4346 if self.row_format != 0 {
4347 len += 1;
4348 }
4349 if !self.row_schema_location.is_empty() {
4350 len += 1;
4351 }
4352 if self.use_schema_registry {
4353 len += 1;
4354 }
4355 if !self.proto_message_name.is_empty() {
4356 len += 1;
4357 }
4358 if self.csv_delimiter != 0 {
4359 len += 1;
4360 }
4361 if self.csv_has_header {
4362 len += 1;
4363 }
4364 if self.format != 0 {
4365 len += 1;
4366 }
4367 if self.row_encode != 0 {
4368 len += 1;
4369 }
4370 if self.name_strategy != 0 {
4371 len += 1;
4372 }
4373 if self.key_message_name.is_some() {
4374 len += 1;
4375 }
4376 if self.external_table.is_some() {
4377 len += 1;
4378 }
4379 if self.cdc_source_job {
4380 len += 1;
4381 }
4382 if self.is_distributed {
4383 len += 1;
4384 }
4385 if !self.format_encode_options.is_empty() {
4386 len += 1;
4387 }
4388 if !self.format_encode_secret_refs.is_empty() {
4389 len += 1;
4390 }
4391 if self.connection_id.is_some() {
4392 len += 1;
4393 }
4394 let mut struct_ser = serializer.serialize_struct("catalog.StreamSourceInfo", len)?;
4395 if self.row_format != 0 {
4396 let v = super::plan_common::RowFormatType::try_from(self.row_format)
4397 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.row_format)))?;
4398 struct_ser.serialize_field("rowFormat", &v)?;
4399 }
4400 if !self.row_schema_location.is_empty() {
4401 struct_ser.serialize_field("rowSchemaLocation", &self.row_schema_location)?;
4402 }
4403 if self.use_schema_registry {
4404 struct_ser.serialize_field("useSchemaRegistry", &self.use_schema_registry)?;
4405 }
4406 if !self.proto_message_name.is_empty() {
4407 struct_ser.serialize_field("protoMessageName", &self.proto_message_name)?;
4408 }
4409 if self.csv_delimiter != 0 {
4410 struct_ser.serialize_field("csvDelimiter", &self.csv_delimiter)?;
4411 }
4412 if self.csv_has_header {
4413 struct_ser.serialize_field("csvHasHeader", &self.csv_has_header)?;
4414 }
4415 if self.format != 0 {
4416 let v = super::plan_common::FormatType::try_from(self.format)
4417 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?;
4418 struct_ser.serialize_field("format", &v)?;
4419 }
4420 if self.row_encode != 0 {
4421 let v = super::plan_common::EncodeType::try_from(self.row_encode)
4422 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.row_encode)))?;
4423 struct_ser.serialize_field("rowEncode", &v)?;
4424 }
4425 if self.name_strategy != 0 {
4426 let v = SchemaRegistryNameStrategy::try_from(self.name_strategy)
4427 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.name_strategy)))?;
4428 struct_ser.serialize_field("nameStrategy", &v)?;
4429 }
4430 if let Some(v) = self.key_message_name.as_ref() {
4431 struct_ser.serialize_field("keyMessageName", v)?;
4432 }
4433 if let Some(v) = self.external_table.as_ref() {
4434 struct_ser.serialize_field("externalTable", v)?;
4435 }
4436 if self.cdc_source_job {
4437 struct_ser.serialize_field("cdcSourceJob", &self.cdc_source_job)?;
4438 }
4439 if self.is_distributed {
4440 struct_ser.serialize_field("isDistributed", &self.is_distributed)?;
4441 }
4442 if !self.format_encode_options.is_empty() {
4443 struct_ser.serialize_field("formatEncodeOptions", &self.format_encode_options)?;
4444 }
4445 if !self.format_encode_secret_refs.is_empty() {
4446 struct_ser.serialize_field("formatEncodeSecretRefs", &self.format_encode_secret_refs)?;
4447 }
4448 if let Some(v) = self.connection_id.as_ref() {
4449 struct_ser.serialize_field("connectionId", v)?;
4450 }
4451 struct_ser.end()
4452 }
4453}
4454impl<'de> serde::Deserialize<'de> for StreamSourceInfo {
4455 #[allow(deprecated)]
4456 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4457 where
4458 D: serde::Deserializer<'de>,
4459 {
4460 const FIELDS: &[&str] = &[
4461 "row_format",
4462 "rowFormat",
4463 "row_schema_location",
4464 "rowSchemaLocation",
4465 "use_schema_registry",
4466 "useSchemaRegistry",
4467 "proto_message_name",
4468 "protoMessageName",
4469 "csv_delimiter",
4470 "csvDelimiter",
4471 "csv_has_header",
4472 "csvHasHeader",
4473 "format",
4474 "row_encode",
4475 "rowEncode",
4476 "name_strategy",
4477 "nameStrategy",
4478 "key_message_name",
4479 "keyMessageName",
4480 "external_table",
4481 "externalTable",
4482 "cdc_source_job",
4483 "cdcSourceJob",
4484 "is_distributed",
4485 "isDistributed",
4486 "format_encode_options",
4487 "formatEncodeOptions",
4488 "format_encode_secret_refs",
4489 "formatEncodeSecretRefs",
4490 "connection_id",
4491 "connectionId",
4492 ];
4493
4494 #[allow(clippy::enum_variant_names)]
4495 enum GeneratedField {
4496 RowFormat,
4497 RowSchemaLocation,
4498 UseSchemaRegistry,
4499 ProtoMessageName,
4500 CsvDelimiter,
4501 CsvHasHeader,
4502 Format,
4503 RowEncode,
4504 NameStrategy,
4505 KeyMessageName,
4506 ExternalTable,
4507 CdcSourceJob,
4508 IsDistributed,
4509 FormatEncodeOptions,
4510 FormatEncodeSecretRefs,
4511 ConnectionId,
4512 }
4513 impl<'de> serde::Deserialize<'de> for GeneratedField {
4514 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4515 where
4516 D: serde::Deserializer<'de>,
4517 {
4518 struct GeneratedVisitor;
4519
4520 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4521 type Value = GeneratedField;
4522
4523 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4524 write!(formatter, "expected one of: {:?}", &FIELDS)
4525 }
4526
4527 #[allow(unused_variables)]
4528 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4529 where
4530 E: serde::de::Error,
4531 {
4532 match value {
4533 "rowFormat" | "row_format" => Ok(GeneratedField::RowFormat),
4534 "rowSchemaLocation" | "row_schema_location" => Ok(GeneratedField::RowSchemaLocation),
4535 "useSchemaRegistry" | "use_schema_registry" => Ok(GeneratedField::UseSchemaRegistry),
4536 "protoMessageName" | "proto_message_name" => Ok(GeneratedField::ProtoMessageName),
4537 "csvDelimiter" | "csv_delimiter" => Ok(GeneratedField::CsvDelimiter),
4538 "csvHasHeader" | "csv_has_header" => Ok(GeneratedField::CsvHasHeader),
4539 "format" => Ok(GeneratedField::Format),
4540 "rowEncode" | "row_encode" => Ok(GeneratedField::RowEncode),
4541 "nameStrategy" | "name_strategy" => Ok(GeneratedField::NameStrategy),
4542 "keyMessageName" | "key_message_name" => Ok(GeneratedField::KeyMessageName),
4543 "externalTable" | "external_table" => Ok(GeneratedField::ExternalTable),
4544 "cdcSourceJob" | "cdc_source_job" => Ok(GeneratedField::CdcSourceJob),
4545 "isDistributed" | "is_distributed" => Ok(GeneratedField::IsDistributed),
4546 "formatEncodeOptions" | "format_encode_options" => Ok(GeneratedField::FormatEncodeOptions),
4547 "formatEncodeSecretRefs" | "format_encode_secret_refs" => Ok(GeneratedField::FormatEncodeSecretRefs),
4548 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
4549 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4550 }
4551 }
4552 }
4553 deserializer.deserialize_identifier(GeneratedVisitor)
4554 }
4555 }
4556 struct GeneratedVisitor;
4557 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4558 type Value = StreamSourceInfo;
4559
4560 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4561 formatter.write_str("struct catalog.StreamSourceInfo")
4562 }
4563
4564 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSourceInfo, V::Error>
4565 where
4566 V: serde::de::MapAccess<'de>,
4567 {
4568 let mut row_format__ = None;
4569 let mut row_schema_location__ = None;
4570 let mut use_schema_registry__ = None;
4571 let mut proto_message_name__ = None;
4572 let mut csv_delimiter__ = None;
4573 let mut csv_has_header__ = None;
4574 let mut format__ = None;
4575 let mut row_encode__ = None;
4576 let mut name_strategy__ = None;
4577 let mut key_message_name__ = None;
4578 let mut external_table__ = None;
4579 let mut cdc_source_job__ = None;
4580 let mut is_distributed__ = None;
4581 let mut format_encode_options__ = None;
4582 let mut format_encode_secret_refs__ = None;
4583 let mut connection_id__ = None;
4584 while let Some(k) = map_.next_key()? {
4585 match k {
4586 GeneratedField::RowFormat => {
4587 if row_format__.is_some() {
4588 return Err(serde::de::Error::duplicate_field("rowFormat"));
4589 }
4590 row_format__ = Some(map_.next_value::<super::plan_common::RowFormatType>()? as i32);
4591 }
4592 GeneratedField::RowSchemaLocation => {
4593 if row_schema_location__.is_some() {
4594 return Err(serde::de::Error::duplicate_field("rowSchemaLocation"));
4595 }
4596 row_schema_location__ = Some(map_.next_value()?);
4597 }
4598 GeneratedField::UseSchemaRegistry => {
4599 if use_schema_registry__.is_some() {
4600 return Err(serde::de::Error::duplicate_field("useSchemaRegistry"));
4601 }
4602 use_schema_registry__ = Some(map_.next_value()?);
4603 }
4604 GeneratedField::ProtoMessageName => {
4605 if proto_message_name__.is_some() {
4606 return Err(serde::de::Error::duplicate_field("protoMessageName"));
4607 }
4608 proto_message_name__ = Some(map_.next_value()?);
4609 }
4610 GeneratedField::CsvDelimiter => {
4611 if csv_delimiter__.is_some() {
4612 return Err(serde::de::Error::duplicate_field("csvDelimiter"));
4613 }
4614 csv_delimiter__ =
4615 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4616 ;
4617 }
4618 GeneratedField::CsvHasHeader => {
4619 if csv_has_header__.is_some() {
4620 return Err(serde::de::Error::duplicate_field("csvHasHeader"));
4621 }
4622 csv_has_header__ = Some(map_.next_value()?);
4623 }
4624 GeneratedField::Format => {
4625 if format__.is_some() {
4626 return Err(serde::de::Error::duplicate_field("format"));
4627 }
4628 format__ = Some(map_.next_value::<super::plan_common::FormatType>()? as i32);
4629 }
4630 GeneratedField::RowEncode => {
4631 if row_encode__.is_some() {
4632 return Err(serde::de::Error::duplicate_field("rowEncode"));
4633 }
4634 row_encode__ = Some(map_.next_value::<super::plan_common::EncodeType>()? as i32);
4635 }
4636 GeneratedField::NameStrategy => {
4637 if name_strategy__.is_some() {
4638 return Err(serde::de::Error::duplicate_field("nameStrategy"));
4639 }
4640 name_strategy__ = Some(map_.next_value::<SchemaRegistryNameStrategy>()? as i32);
4641 }
4642 GeneratedField::KeyMessageName => {
4643 if key_message_name__.is_some() {
4644 return Err(serde::de::Error::duplicate_field("keyMessageName"));
4645 }
4646 key_message_name__ = map_.next_value()?;
4647 }
4648 GeneratedField::ExternalTable => {
4649 if external_table__.is_some() {
4650 return Err(serde::de::Error::duplicate_field("externalTable"));
4651 }
4652 external_table__ = map_.next_value()?;
4653 }
4654 GeneratedField::CdcSourceJob => {
4655 if cdc_source_job__.is_some() {
4656 return Err(serde::de::Error::duplicate_field("cdcSourceJob"));
4657 }
4658 cdc_source_job__ = Some(map_.next_value()?);
4659 }
4660 GeneratedField::IsDistributed => {
4661 if is_distributed__.is_some() {
4662 return Err(serde::de::Error::duplicate_field("isDistributed"));
4663 }
4664 is_distributed__ = Some(map_.next_value()?);
4665 }
4666 GeneratedField::FormatEncodeOptions => {
4667 if format_encode_options__.is_some() {
4668 return Err(serde::de::Error::duplicate_field("formatEncodeOptions"));
4669 }
4670 format_encode_options__ = Some(
4671 map_.next_value::<std::collections::BTreeMap<_, _>>()?
4672 );
4673 }
4674 GeneratedField::FormatEncodeSecretRefs => {
4675 if format_encode_secret_refs__.is_some() {
4676 return Err(serde::de::Error::duplicate_field("formatEncodeSecretRefs"));
4677 }
4678 format_encode_secret_refs__ = Some(
4679 map_.next_value::<std::collections::BTreeMap<_, _>>()?
4680 );
4681 }
4682 GeneratedField::ConnectionId => {
4683 if connection_id__.is_some() {
4684 return Err(serde::de::Error::duplicate_field("connectionId"));
4685 }
4686 connection_id__ =
4687 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4688 ;
4689 }
4690 }
4691 }
4692 Ok(StreamSourceInfo {
4693 row_format: row_format__.unwrap_or_default(),
4694 row_schema_location: row_schema_location__.unwrap_or_default(),
4695 use_schema_registry: use_schema_registry__.unwrap_or_default(),
4696 proto_message_name: proto_message_name__.unwrap_or_default(),
4697 csv_delimiter: csv_delimiter__.unwrap_or_default(),
4698 csv_has_header: csv_has_header__.unwrap_or_default(),
4699 format: format__.unwrap_or_default(),
4700 row_encode: row_encode__.unwrap_or_default(),
4701 name_strategy: name_strategy__.unwrap_or_default(),
4702 key_message_name: key_message_name__,
4703 external_table: external_table__,
4704 cdc_source_job: cdc_source_job__.unwrap_or_default(),
4705 is_distributed: is_distributed__.unwrap_or_default(),
4706 format_encode_options: format_encode_options__.unwrap_or_default(),
4707 format_encode_secret_refs: format_encode_secret_refs__.unwrap_or_default(),
4708 connection_id: connection_id__,
4709 })
4710 }
4711 }
4712 deserializer.deserialize_struct("catalog.StreamSourceInfo", FIELDS, GeneratedVisitor)
4713 }
4714}
4715impl serde::Serialize for Subscription {
4716 #[allow(deprecated)]
4717 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4718 where
4719 S: serde::Serializer,
4720 {
4721 use serde::ser::SerializeStruct;
4722 let mut len = 0;
4723 if self.id != 0 {
4724 len += 1;
4725 }
4726 if !self.name.is_empty() {
4727 len += 1;
4728 }
4729 if !self.definition.is_empty() {
4730 len += 1;
4731 }
4732 if self.retention_seconds != 0 {
4733 len += 1;
4734 }
4735 if self.database_id != 0 {
4736 len += 1;
4737 }
4738 if self.schema_id != 0 {
4739 len += 1;
4740 }
4741 if self.dependent_table_id != 0 {
4742 len += 1;
4743 }
4744 if self.initialized_at_epoch.is_some() {
4745 len += 1;
4746 }
4747 if self.created_at_epoch.is_some() {
4748 len += 1;
4749 }
4750 if self.owner != 0 {
4751 len += 1;
4752 }
4753 if self.initialized_at_cluster_version.is_some() {
4754 len += 1;
4755 }
4756 if self.created_at_cluster_version.is_some() {
4757 len += 1;
4758 }
4759 if self.subscription_state != 0 {
4760 len += 1;
4761 }
4762 let mut struct_ser = serializer.serialize_struct("catalog.Subscription", len)?;
4763 if self.id != 0 {
4764 struct_ser.serialize_field("id", &self.id)?;
4765 }
4766 if !self.name.is_empty() {
4767 struct_ser.serialize_field("name", &self.name)?;
4768 }
4769 if !self.definition.is_empty() {
4770 struct_ser.serialize_field("definition", &self.definition)?;
4771 }
4772 if self.retention_seconds != 0 {
4773 #[allow(clippy::needless_borrow)]
4774 #[allow(clippy::needless_borrows_for_generic_args)]
4775 struct_ser.serialize_field("retentionSeconds", ToString::to_string(&self.retention_seconds).as_str())?;
4776 }
4777 if self.database_id != 0 {
4778 struct_ser.serialize_field("databaseId", &self.database_id)?;
4779 }
4780 if self.schema_id != 0 {
4781 struct_ser.serialize_field("schemaId", &self.schema_id)?;
4782 }
4783 if self.dependent_table_id != 0 {
4784 struct_ser.serialize_field("dependentTableId", &self.dependent_table_id)?;
4785 }
4786 if let Some(v) = self.initialized_at_epoch.as_ref() {
4787 #[allow(clippy::needless_borrow)]
4788 #[allow(clippy::needless_borrows_for_generic_args)]
4789 struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
4790 }
4791 if let Some(v) = self.created_at_epoch.as_ref() {
4792 #[allow(clippy::needless_borrow)]
4793 #[allow(clippy::needless_borrows_for_generic_args)]
4794 struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
4795 }
4796 if self.owner != 0 {
4797 struct_ser.serialize_field("owner", &self.owner)?;
4798 }
4799 if let Some(v) = self.initialized_at_cluster_version.as_ref() {
4800 struct_ser.serialize_field("initializedAtClusterVersion", v)?;
4801 }
4802 if let Some(v) = self.created_at_cluster_version.as_ref() {
4803 struct_ser.serialize_field("createdAtClusterVersion", v)?;
4804 }
4805 if self.subscription_state != 0 {
4806 let v = subscription::SubscriptionState::try_from(self.subscription_state)
4807 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscription_state)))?;
4808 struct_ser.serialize_field("subscriptionState", &v)?;
4809 }
4810 struct_ser.end()
4811 }
4812}
4813impl<'de> serde::Deserialize<'de> for Subscription {
4814 #[allow(deprecated)]
4815 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4816 where
4817 D: serde::Deserializer<'de>,
4818 {
4819 const FIELDS: &[&str] = &[
4820 "id",
4821 "name",
4822 "definition",
4823 "retention_seconds",
4824 "retentionSeconds",
4825 "database_id",
4826 "databaseId",
4827 "schema_id",
4828 "schemaId",
4829 "dependent_table_id",
4830 "dependentTableId",
4831 "initialized_at_epoch",
4832 "initializedAtEpoch",
4833 "created_at_epoch",
4834 "createdAtEpoch",
4835 "owner",
4836 "initialized_at_cluster_version",
4837 "initializedAtClusterVersion",
4838 "created_at_cluster_version",
4839 "createdAtClusterVersion",
4840 "subscription_state",
4841 "subscriptionState",
4842 ];
4843
4844 #[allow(clippy::enum_variant_names)]
4845 enum GeneratedField {
4846 Id,
4847 Name,
4848 Definition,
4849 RetentionSeconds,
4850 DatabaseId,
4851 SchemaId,
4852 DependentTableId,
4853 InitializedAtEpoch,
4854 CreatedAtEpoch,
4855 Owner,
4856 InitializedAtClusterVersion,
4857 CreatedAtClusterVersion,
4858 SubscriptionState,
4859 }
4860 impl<'de> serde::Deserialize<'de> for GeneratedField {
4861 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4862 where
4863 D: serde::Deserializer<'de>,
4864 {
4865 struct GeneratedVisitor;
4866
4867 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4868 type Value = GeneratedField;
4869
4870 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4871 write!(formatter, "expected one of: {:?}", &FIELDS)
4872 }
4873
4874 #[allow(unused_variables)]
4875 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4876 where
4877 E: serde::de::Error,
4878 {
4879 match value {
4880 "id" => Ok(GeneratedField::Id),
4881 "name" => Ok(GeneratedField::Name),
4882 "definition" => Ok(GeneratedField::Definition),
4883 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
4884 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4885 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
4886 "dependentTableId" | "dependent_table_id" => Ok(GeneratedField::DependentTableId),
4887 "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
4888 "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
4889 "owner" => Ok(GeneratedField::Owner),
4890 "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
4891 "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
4892 "subscriptionState" | "subscription_state" => Ok(GeneratedField::SubscriptionState),
4893 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4894 }
4895 }
4896 }
4897 deserializer.deserialize_identifier(GeneratedVisitor)
4898 }
4899 }
4900 struct GeneratedVisitor;
4901 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4902 type Value = Subscription;
4903
4904 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4905 formatter.write_str("struct catalog.Subscription")
4906 }
4907
4908 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Subscription, V::Error>
4909 where
4910 V: serde::de::MapAccess<'de>,
4911 {
4912 let mut id__ = None;
4913 let mut name__ = None;
4914 let mut definition__ = None;
4915 let mut retention_seconds__ = None;
4916 let mut database_id__ = None;
4917 let mut schema_id__ = None;
4918 let mut dependent_table_id__ = None;
4919 let mut initialized_at_epoch__ = None;
4920 let mut created_at_epoch__ = None;
4921 let mut owner__ = None;
4922 let mut initialized_at_cluster_version__ = None;
4923 let mut created_at_cluster_version__ = None;
4924 let mut subscription_state__ = None;
4925 while let Some(k) = map_.next_key()? {
4926 match k {
4927 GeneratedField::Id => {
4928 if id__.is_some() {
4929 return Err(serde::de::Error::duplicate_field("id"));
4930 }
4931 id__ =
4932 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4933 ;
4934 }
4935 GeneratedField::Name => {
4936 if name__.is_some() {
4937 return Err(serde::de::Error::duplicate_field("name"));
4938 }
4939 name__ = Some(map_.next_value()?);
4940 }
4941 GeneratedField::Definition => {
4942 if definition__.is_some() {
4943 return Err(serde::de::Error::duplicate_field("definition"));
4944 }
4945 definition__ = Some(map_.next_value()?);
4946 }
4947 GeneratedField::RetentionSeconds => {
4948 if retention_seconds__.is_some() {
4949 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
4950 }
4951 retention_seconds__ =
4952 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4953 ;
4954 }
4955 GeneratedField::DatabaseId => {
4956 if database_id__.is_some() {
4957 return Err(serde::de::Error::duplicate_field("databaseId"));
4958 }
4959 database_id__ =
4960 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4961 ;
4962 }
4963 GeneratedField::SchemaId => {
4964 if schema_id__.is_some() {
4965 return Err(serde::de::Error::duplicate_field("schemaId"));
4966 }
4967 schema_id__ =
4968 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4969 ;
4970 }
4971 GeneratedField::DependentTableId => {
4972 if dependent_table_id__.is_some() {
4973 return Err(serde::de::Error::duplicate_field("dependentTableId"));
4974 }
4975 dependent_table_id__ =
4976 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4977 ;
4978 }
4979 GeneratedField::InitializedAtEpoch => {
4980 if initialized_at_epoch__.is_some() {
4981 return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
4982 }
4983 initialized_at_epoch__ =
4984 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4985 ;
4986 }
4987 GeneratedField::CreatedAtEpoch => {
4988 if created_at_epoch__.is_some() {
4989 return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
4990 }
4991 created_at_epoch__ =
4992 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4993 ;
4994 }
4995 GeneratedField::Owner => {
4996 if owner__.is_some() {
4997 return Err(serde::de::Error::duplicate_field("owner"));
4998 }
4999 owner__ =
5000 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5001 ;
5002 }
5003 GeneratedField::InitializedAtClusterVersion => {
5004 if initialized_at_cluster_version__.is_some() {
5005 return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
5006 }
5007 initialized_at_cluster_version__ = map_.next_value()?;
5008 }
5009 GeneratedField::CreatedAtClusterVersion => {
5010 if created_at_cluster_version__.is_some() {
5011 return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
5012 }
5013 created_at_cluster_version__ = map_.next_value()?;
5014 }
5015 GeneratedField::SubscriptionState => {
5016 if subscription_state__.is_some() {
5017 return Err(serde::de::Error::duplicate_field("subscriptionState"));
5018 }
5019 subscription_state__ = Some(map_.next_value::<subscription::SubscriptionState>()? as i32);
5020 }
5021 }
5022 }
5023 Ok(Subscription {
5024 id: id__.unwrap_or_default(),
5025 name: name__.unwrap_or_default(),
5026 definition: definition__.unwrap_or_default(),
5027 retention_seconds: retention_seconds__.unwrap_or_default(),
5028 database_id: database_id__.unwrap_or_default(),
5029 schema_id: schema_id__.unwrap_or_default(),
5030 dependent_table_id: dependent_table_id__.unwrap_or_default(),
5031 initialized_at_epoch: initialized_at_epoch__,
5032 created_at_epoch: created_at_epoch__,
5033 owner: owner__.unwrap_or_default(),
5034 initialized_at_cluster_version: initialized_at_cluster_version__,
5035 created_at_cluster_version: created_at_cluster_version__,
5036 subscription_state: subscription_state__.unwrap_or_default(),
5037 })
5038 }
5039 }
5040 deserializer.deserialize_struct("catalog.Subscription", FIELDS, GeneratedVisitor)
5041 }
5042}
5043impl serde::Serialize for subscription::SubscriptionState {
5044 #[allow(deprecated)]
5045 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5046 where
5047 S: serde::Serializer,
5048 {
5049 let variant = match self {
5050 Self::Unspecified => "UNSPECIFIED",
5051 Self::Init => "INIT",
5052 Self::Created => "CREATED",
5053 };
5054 serializer.serialize_str(variant)
5055 }
5056}
5057impl<'de> serde::Deserialize<'de> for subscription::SubscriptionState {
5058 #[allow(deprecated)]
5059 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5060 where
5061 D: serde::Deserializer<'de>,
5062 {
5063 const FIELDS: &[&str] = &[
5064 "UNSPECIFIED",
5065 "INIT",
5066 "CREATED",
5067 ];
5068
5069 struct GeneratedVisitor;
5070
5071 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5072 type Value = subscription::SubscriptionState;
5073
5074 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5075 write!(formatter, "expected one of: {:?}", &FIELDS)
5076 }
5077
5078 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
5079 where
5080 E: serde::de::Error,
5081 {
5082 i32::try_from(v)
5083 .ok()
5084 .and_then(|x| x.try_into().ok())
5085 .ok_or_else(|| {
5086 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
5087 })
5088 }
5089
5090 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
5091 where
5092 E: serde::de::Error,
5093 {
5094 i32::try_from(v)
5095 .ok()
5096 .and_then(|x| x.try_into().ok())
5097 .ok_or_else(|| {
5098 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
5099 })
5100 }
5101
5102 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
5103 where
5104 E: serde::de::Error,
5105 {
5106 match value {
5107 "UNSPECIFIED" => Ok(subscription::SubscriptionState::Unspecified),
5108 "INIT" => Ok(subscription::SubscriptionState::Init),
5109 "CREATED" => Ok(subscription::SubscriptionState::Created),
5110 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
5111 }
5112 }
5113 }
5114 deserializer.deserialize_any(GeneratedVisitor)
5115 }
5116}
5117impl serde::Serialize for Table {
5118 #[allow(deprecated)]
5119 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5120 where
5121 S: serde::Serializer,
5122 {
5123 use serde::ser::SerializeStruct;
5124 let mut len = 0;
5125 if self.id != 0 {
5126 len += 1;
5127 }
5128 if self.schema_id != 0 {
5129 len += 1;
5130 }
5131 if self.database_id != 0 {
5132 len += 1;
5133 }
5134 if !self.name.is_empty() {
5135 len += 1;
5136 }
5137 if !self.columns.is_empty() {
5138 len += 1;
5139 }
5140 if !self.pk.is_empty() {
5141 len += 1;
5142 }
5143 if !self.dependent_relations.is_empty() {
5144 len += 1;
5145 }
5146 if self.table_type != 0 {
5147 len += 1;
5148 }
5149 if !self.distribution_key.is_empty() {
5150 len += 1;
5151 }
5152 if !self.stream_key.is_empty() {
5153 len += 1;
5154 }
5155 if self.append_only {
5156 len += 1;
5157 }
5158 if self.owner != 0 {
5159 len += 1;
5160 }
5161 if self.fragment_id != 0 {
5162 len += 1;
5163 }
5164 if self.vnode_col_index.is_some() {
5165 len += 1;
5166 }
5167 if self.row_id_index.is_some() {
5168 len += 1;
5169 }
5170 if !self.value_indices.is_empty() {
5171 len += 1;
5172 }
5173 if !self.definition.is_empty() {
5174 len += 1;
5175 }
5176 if self.handle_pk_conflict_behavior != 0 {
5177 len += 1;
5178 }
5179 if self.read_prefix_len_hint != 0 {
5180 len += 1;
5181 }
5182 if !self.watermark_indices.is_empty() {
5183 len += 1;
5184 }
5185 if !self.dist_key_in_pk.is_empty() {
5186 len += 1;
5187 }
5188 if self.dml_fragment_id.is_some() {
5189 len += 1;
5190 }
5191 if self.cardinality.is_some() {
5192 len += 1;
5193 }
5194 if self.initialized_at_epoch.is_some() {
5195 len += 1;
5196 }
5197 if self.created_at_epoch.is_some() {
5198 len += 1;
5199 }
5200 if self.cleaned_by_watermark {
5201 len += 1;
5202 }
5203 if self.stream_job_status != 0 {
5204 len += 1;
5205 }
5206 if self.create_type != 0 {
5207 len += 1;
5208 }
5209 if self.description.is_some() {
5210 len += 1;
5211 }
5212 if !self.incoming_sinks.is_empty() {
5213 len += 1;
5214 }
5215 if self.initialized_at_cluster_version.is_some() {
5216 len += 1;
5217 }
5218 if self.created_at_cluster_version.is_some() {
5219 len += 1;
5220 }
5221 if self.retention_seconds.is_some() {
5222 len += 1;
5223 }
5224 if self.version_column_index.is_some() {
5225 len += 1;
5226 }
5227 if self.cdc_table_id.is_some() {
5228 len += 1;
5229 }
5230 if self.maybe_vnode_count.is_some() {
5231 len += 1;
5232 }
5233 if self.webhook_info.is_some() {
5234 len += 1;
5235 }
5236 if self.job_id.is_some() {
5237 len += 1;
5238 }
5239 if self.engine.is_some() {
5240 len += 1;
5241 }
5242 if self.clean_watermark_index_in_pk.is_some() {
5243 len += 1;
5244 }
5245 if self.version.is_some() {
5246 len += 1;
5247 }
5248 if self.optional_associated_source_id.is_some() {
5249 len += 1;
5250 }
5251 let mut struct_ser = serializer.serialize_struct("catalog.Table", len)?;
5252 if self.id != 0 {
5253 struct_ser.serialize_field("id", &self.id)?;
5254 }
5255 if self.schema_id != 0 {
5256 struct_ser.serialize_field("schemaId", &self.schema_id)?;
5257 }
5258 if self.database_id != 0 {
5259 struct_ser.serialize_field("databaseId", &self.database_id)?;
5260 }
5261 if !self.name.is_empty() {
5262 struct_ser.serialize_field("name", &self.name)?;
5263 }
5264 if !self.columns.is_empty() {
5265 struct_ser.serialize_field("columns", &self.columns)?;
5266 }
5267 if !self.pk.is_empty() {
5268 struct_ser.serialize_field("pk", &self.pk)?;
5269 }
5270 if !self.dependent_relations.is_empty() {
5271 struct_ser.serialize_field("dependentRelations", &self.dependent_relations)?;
5272 }
5273 if self.table_type != 0 {
5274 let v = table::TableType::try_from(self.table_type)
5275 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.table_type)))?;
5276 struct_ser.serialize_field("tableType", &v)?;
5277 }
5278 if !self.distribution_key.is_empty() {
5279 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
5280 }
5281 if !self.stream_key.is_empty() {
5282 struct_ser.serialize_field("streamKey", &self.stream_key)?;
5283 }
5284 if self.append_only {
5285 struct_ser.serialize_field("appendOnly", &self.append_only)?;
5286 }
5287 if self.owner != 0 {
5288 struct_ser.serialize_field("owner", &self.owner)?;
5289 }
5290 if self.fragment_id != 0 {
5291 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5292 }
5293 if let Some(v) = self.vnode_col_index.as_ref() {
5294 struct_ser.serialize_field("vnodeColIndex", v)?;
5295 }
5296 if let Some(v) = self.row_id_index.as_ref() {
5297 struct_ser.serialize_field("rowIdIndex", v)?;
5298 }
5299 if !self.value_indices.is_empty() {
5300 struct_ser.serialize_field("valueIndices", &self.value_indices)?;
5301 }
5302 if !self.definition.is_empty() {
5303 struct_ser.serialize_field("definition", &self.definition)?;
5304 }
5305 if self.handle_pk_conflict_behavior != 0 {
5306 let v = HandleConflictBehavior::try_from(self.handle_pk_conflict_behavior)
5307 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.handle_pk_conflict_behavior)))?;
5308 struct_ser.serialize_field("handlePkConflictBehavior", &v)?;
5309 }
5310 if self.read_prefix_len_hint != 0 {
5311 struct_ser.serialize_field("readPrefixLenHint", &self.read_prefix_len_hint)?;
5312 }
5313 if !self.watermark_indices.is_empty() {
5314 struct_ser.serialize_field("watermarkIndices", &self.watermark_indices)?;
5315 }
5316 if !self.dist_key_in_pk.is_empty() {
5317 struct_ser.serialize_field("distKeyInPk", &self.dist_key_in_pk)?;
5318 }
5319 if let Some(v) = self.dml_fragment_id.as_ref() {
5320 struct_ser.serialize_field("dmlFragmentId", v)?;
5321 }
5322 if let Some(v) = self.cardinality.as_ref() {
5323 struct_ser.serialize_field("cardinality", v)?;
5324 }
5325 if let Some(v) = self.initialized_at_epoch.as_ref() {
5326 #[allow(clippy::needless_borrow)]
5327 #[allow(clippy::needless_borrows_for_generic_args)]
5328 struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
5329 }
5330 if let Some(v) = self.created_at_epoch.as_ref() {
5331 #[allow(clippy::needless_borrow)]
5332 #[allow(clippy::needless_borrows_for_generic_args)]
5333 struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
5334 }
5335 if self.cleaned_by_watermark {
5336 struct_ser.serialize_field("cleanedByWatermark", &self.cleaned_by_watermark)?;
5337 }
5338 if self.stream_job_status != 0 {
5339 let v = StreamJobStatus::try_from(self.stream_job_status)
5340 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_job_status)))?;
5341 struct_ser.serialize_field("streamJobStatus", &v)?;
5342 }
5343 if self.create_type != 0 {
5344 let v = CreateType::try_from(self.create_type)
5345 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.create_type)))?;
5346 struct_ser.serialize_field("createType", &v)?;
5347 }
5348 if let Some(v) = self.description.as_ref() {
5349 struct_ser.serialize_field("description", v)?;
5350 }
5351 if !self.incoming_sinks.is_empty() {
5352 struct_ser.serialize_field("incomingSinks", &self.incoming_sinks)?;
5353 }
5354 if let Some(v) = self.initialized_at_cluster_version.as_ref() {
5355 struct_ser.serialize_field("initializedAtClusterVersion", v)?;
5356 }
5357 if let Some(v) = self.created_at_cluster_version.as_ref() {
5358 struct_ser.serialize_field("createdAtClusterVersion", v)?;
5359 }
5360 if let Some(v) = self.retention_seconds.as_ref() {
5361 struct_ser.serialize_field("retentionSeconds", v)?;
5362 }
5363 if let Some(v) = self.version_column_index.as_ref() {
5364 struct_ser.serialize_field("versionColumnIndex", v)?;
5365 }
5366 if let Some(v) = self.cdc_table_id.as_ref() {
5367 struct_ser.serialize_field("cdcTableId", v)?;
5368 }
5369 if let Some(v) = self.maybe_vnode_count.as_ref() {
5370 struct_ser.serialize_field("maybeVnodeCount", v)?;
5371 }
5372 if let Some(v) = self.webhook_info.as_ref() {
5373 struct_ser.serialize_field("webhookInfo", v)?;
5374 }
5375 if let Some(v) = self.job_id.as_ref() {
5376 struct_ser.serialize_field("jobId", v)?;
5377 }
5378 if let Some(v) = self.engine.as_ref() {
5379 let v = table::Engine::try_from(*v)
5380 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
5381 struct_ser.serialize_field("engine", &v)?;
5382 }
5383 if let Some(v) = self.clean_watermark_index_in_pk.as_ref() {
5384 struct_ser.serialize_field("cleanWatermarkIndexInPk", v)?;
5385 }
5386 if let Some(v) = self.version.as_ref() {
5387 struct_ser.serialize_field("version", v)?;
5388 }
5389 if let Some(v) = self.optional_associated_source_id.as_ref() {
5390 match v {
5391 table::OptionalAssociatedSourceId::AssociatedSourceId(v) => {
5392 struct_ser.serialize_field("associatedSourceId", v)?;
5393 }
5394 }
5395 }
5396 struct_ser.end()
5397 }
5398}
5399impl<'de> serde::Deserialize<'de> for Table {
5400 #[allow(deprecated)]
5401 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5402 where
5403 D: serde::Deserializer<'de>,
5404 {
5405 const FIELDS: &[&str] = &[
5406 "id",
5407 "schema_id",
5408 "schemaId",
5409 "database_id",
5410 "databaseId",
5411 "name",
5412 "columns",
5413 "pk",
5414 "dependent_relations",
5415 "dependentRelations",
5416 "table_type",
5417 "tableType",
5418 "distribution_key",
5419 "distributionKey",
5420 "stream_key",
5421 "streamKey",
5422 "append_only",
5423 "appendOnly",
5424 "owner",
5425 "fragment_id",
5426 "fragmentId",
5427 "vnode_col_index",
5428 "vnodeColIndex",
5429 "row_id_index",
5430 "rowIdIndex",
5431 "value_indices",
5432 "valueIndices",
5433 "definition",
5434 "handle_pk_conflict_behavior",
5435 "handlePkConflictBehavior",
5436 "read_prefix_len_hint",
5437 "readPrefixLenHint",
5438 "watermark_indices",
5439 "watermarkIndices",
5440 "dist_key_in_pk",
5441 "distKeyInPk",
5442 "dml_fragment_id",
5443 "dmlFragmentId",
5444 "cardinality",
5445 "initialized_at_epoch",
5446 "initializedAtEpoch",
5447 "created_at_epoch",
5448 "createdAtEpoch",
5449 "cleaned_by_watermark",
5450 "cleanedByWatermark",
5451 "stream_job_status",
5452 "streamJobStatus",
5453 "create_type",
5454 "createType",
5455 "description",
5456 "incoming_sinks",
5457 "incomingSinks",
5458 "initialized_at_cluster_version",
5459 "initializedAtClusterVersion",
5460 "created_at_cluster_version",
5461 "createdAtClusterVersion",
5462 "retention_seconds",
5463 "retentionSeconds",
5464 "version_column_index",
5465 "versionColumnIndex",
5466 "cdc_table_id",
5467 "cdcTableId",
5468 "maybe_vnode_count",
5469 "maybeVnodeCount",
5470 "webhook_info",
5471 "webhookInfo",
5472 "job_id",
5473 "jobId",
5474 "engine",
5475 "clean_watermark_index_in_pk",
5476 "cleanWatermarkIndexInPk",
5477 "version",
5478 "associated_source_id",
5479 "associatedSourceId",
5480 ];
5481
5482 #[allow(clippy::enum_variant_names)]
5483 enum GeneratedField {
5484 Id,
5485 SchemaId,
5486 DatabaseId,
5487 Name,
5488 Columns,
5489 Pk,
5490 DependentRelations,
5491 TableType,
5492 DistributionKey,
5493 StreamKey,
5494 AppendOnly,
5495 Owner,
5496 FragmentId,
5497 VnodeColIndex,
5498 RowIdIndex,
5499 ValueIndices,
5500 Definition,
5501 HandlePkConflictBehavior,
5502 ReadPrefixLenHint,
5503 WatermarkIndices,
5504 DistKeyInPk,
5505 DmlFragmentId,
5506 Cardinality,
5507 InitializedAtEpoch,
5508 CreatedAtEpoch,
5509 CleanedByWatermark,
5510 StreamJobStatus,
5511 CreateType,
5512 Description,
5513 IncomingSinks,
5514 InitializedAtClusterVersion,
5515 CreatedAtClusterVersion,
5516 RetentionSeconds,
5517 VersionColumnIndex,
5518 CdcTableId,
5519 MaybeVnodeCount,
5520 WebhookInfo,
5521 JobId,
5522 Engine,
5523 CleanWatermarkIndexInPk,
5524 Version,
5525 AssociatedSourceId,
5526 }
5527 impl<'de> serde::Deserialize<'de> for GeneratedField {
5528 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5529 where
5530 D: serde::Deserializer<'de>,
5531 {
5532 struct GeneratedVisitor;
5533
5534 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5535 type Value = GeneratedField;
5536
5537 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5538 write!(formatter, "expected one of: {:?}", &FIELDS)
5539 }
5540
5541 #[allow(unused_variables)]
5542 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5543 where
5544 E: serde::de::Error,
5545 {
5546 match value {
5547 "id" => Ok(GeneratedField::Id),
5548 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
5549 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
5550 "name" => Ok(GeneratedField::Name),
5551 "columns" => Ok(GeneratedField::Columns),
5552 "pk" => Ok(GeneratedField::Pk),
5553 "dependentRelations" | "dependent_relations" => Ok(GeneratedField::DependentRelations),
5554 "tableType" | "table_type" => Ok(GeneratedField::TableType),
5555 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
5556 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
5557 "appendOnly" | "append_only" => Ok(GeneratedField::AppendOnly),
5558 "owner" => Ok(GeneratedField::Owner),
5559 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5560 "vnodeColIndex" | "vnode_col_index" => Ok(GeneratedField::VnodeColIndex),
5561 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
5562 "valueIndices" | "value_indices" => Ok(GeneratedField::ValueIndices),
5563 "definition" => Ok(GeneratedField::Definition),
5564 "handlePkConflictBehavior" | "handle_pk_conflict_behavior" => Ok(GeneratedField::HandlePkConflictBehavior),
5565 "readPrefixLenHint" | "read_prefix_len_hint" => Ok(GeneratedField::ReadPrefixLenHint),
5566 "watermarkIndices" | "watermark_indices" => Ok(GeneratedField::WatermarkIndices),
5567 "distKeyInPk" | "dist_key_in_pk" => Ok(GeneratedField::DistKeyInPk),
5568 "dmlFragmentId" | "dml_fragment_id" => Ok(GeneratedField::DmlFragmentId),
5569 "cardinality" => Ok(GeneratedField::Cardinality),
5570 "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
5571 "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
5572 "cleanedByWatermark" | "cleaned_by_watermark" => Ok(GeneratedField::CleanedByWatermark),
5573 "streamJobStatus" | "stream_job_status" => Ok(GeneratedField::StreamJobStatus),
5574 "createType" | "create_type" => Ok(GeneratedField::CreateType),
5575 "description" => Ok(GeneratedField::Description),
5576 "incomingSinks" | "incoming_sinks" => Ok(GeneratedField::IncomingSinks),
5577 "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
5578 "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
5579 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
5580 "versionColumnIndex" | "version_column_index" => Ok(GeneratedField::VersionColumnIndex),
5581 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
5582 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
5583 "webhookInfo" | "webhook_info" => Ok(GeneratedField::WebhookInfo),
5584 "jobId" | "job_id" => Ok(GeneratedField::JobId),
5585 "engine" => Ok(GeneratedField::Engine),
5586 "cleanWatermarkIndexInPk" | "clean_watermark_index_in_pk" => Ok(GeneratedField::CleanWatermarkIndexInPk),
5587 "version" => Ok(GeneratedField::Version),
5588 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
5589 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5590 }
5591 }
5592 }
5593 deserializer.deserialize_identifier(GeneratedVisitor)
5594 }
5595 }
5596 struct GeneratedVisitor;
5597 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5598 type Value = Table;
5599
5600 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5601 formatter.write_str("struct catalog.Table")
5602 }
5603
5604 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Table, V::Error>
5605 where
5606 V: serde::de::MapAccess<'de>,
5607 {
5608 let mut id__ = None;
5609 let mut schema_id__ = None;
5610 let mut database_id__ = None;
5611 let mut name__ = None;
5612 let mut columns__ = None;
5613 let mut pk__ = None;
5614 let mut dependent_relations__ = None;
5615 let mut table_type__ = None;
5616 let mut distribution_key__ = None;
5617 let mut stream_key__ = None;
5618 let mut append_only__ = None;
5619 let mut owner__ = None;
5620 let mut fragment_id__ = None;
5621 let mut vnode_col_index__ = None;
5622 let mut row_id_index__ = None;
5623 let mut value_indices__ = None;
5624 let mut definition__ = None;
5625 let mut handle_pk_conflict_behavior__ = None;
5626 let mut read_prefix_len_hint__ = None;
5627 let mut watermark_indices__ = None;
5628 let mut dist_key_in_pk__ = None;
5629 let mut dml_fragment_id__ = None;
5630 let mut cardinality__ = None;
5631 let mut initialized_at_epoch__ = None;
5632 let mut created_at_epoch__ = None;
5633 let mut cleaned_by_watermark__ = None;
5634 let mut stream_job_status__ = None;
5635 let mut create_type__ = None;
5636 let mut description__ = None;
5637 let mut incoming_sinks__ = None;
5638 let mut initialized_at_cluster_version__ = None;
5639 let mut created_at_cluster_version__ = None;
5640 let mut retention_seconds__ = None;
5641 let mut version_column_index__ = None;
5642 let mut cdc_table_id__ = None;
5643 let mut maybe_vnode_count__ = None;
5644 let mut webhook_info__ = None;
5645 let mut job_id__ = None;
5646 let mut engine__ = None;
5647 let mut clean_watermark_index_in_pk__ = None;
5648 let mut version__ = None;
5649 let mut optional_associated_source_id__ = None;
5650 while let Some(k) = map_.next_key()? {
5651 match k {
5652 GeneratedField::Id => {
5653 if id__.is_some() {
5654 return Err(serde::de::Error::duplicate_field("id"));
5655 }
5656 id__ =
5657 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5658 ;
5659 }
5660 GeneratedField::SchemaId => {
5661 if schema_id__.is_some() {
5662 return Err(serde::de::Error::duplicate_field("schemaId"));
5663 }
5664 schema_id__ =
5665 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5666 ;
5667 }
5668 GeneratedField::DatabaseId => {
5669 if database_id__.is_some() {
5670 return Err(serde::de::Error::duplicate_field("databaseId"));
5671 }
5672 database_id__ =
5673 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5674 ;
5675 }
5676 GeneratedField::Name => {
5677 if name__.is_some() {
5678 return Err(serde::de::Error::duplicate_field("name"));
5679 }
5680 name__ = Some(map_.next_value()?);
5681 }
5682 GeneratedField::Columns => {
5683 if columns__.is_some() {
5684 return Err(serde::de::Error::duplicate_field("columns"));
5685 }
5686 columns__ = Some(map_.next_value()?);
5687 }
5688 GeneratedField::Pk => {
5689 if pk__.is_some() {
5690 return Err(serde::de::Error::duplicate_field("pk"));
5691 }
5692 pk__ = Some(map_.next_value()?);
5693 }
5694 GeneratedField::DependentRelations => {
5695 if dependent_relations__.is_some() {
5696 return Err(serde::de::Error::duplicate_field("dependentRelations"));
5697 }
5698 dependent_relations__ =
5699 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5700 .into_iter().map(|x| x.0).collect())
5701 ;
5702 }
5703 GeneratedField::TableType => {
5704 if table_type__.is_some() {
5705 return Err(serde::de::Error::duplicate_field("tableType"));
5706 }
5707 table_type__ = Some(map_.next_value::<table::TableType>()? as i32);
5708 }
5709 GeneratedField::DistributionKey => {
5710 if distribution_key__.is_some() {
5711 return Err(serde::de::Error::duplicate_field("distributionKey"));
5712 }
5713 distribution_key__ =
5714 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5715 .into_iter().map(|x| x.0).collect())
5716 ;
5717 }
5718 GeneratedField::StreamKey => {
5719 if stream_key__.is_some() {
5720 return Err(serde::de::Error::duplicate_field("streamKey"));
5721 }
5722 stream_key__ =
5723 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5724 .into_iter().map(|x| x.0).collect())
5725 ;
5726 }
5727 GeneratedField::AppendOnly => {
5728 if append_only__.is_some() {
5729 return Err(serde::de::Error::duplicate_field("appendOnly"));
5730 }
5731 append_only__ = Some(map_.next_value()?);
5732 }
5733 GeneratedField::Owner => {
5734 if owner__.is_some() {
5735 return Err(serde::de::Error::duplicate_field("owner"));
5736 }
5737 owner__ =
5738 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5739 ;
5740 }
5741 GeneratedField::FragmentId => {
5742 if fragment_id__.is_some() {
5743 return Err(serde::de::Error::duplicate_field("fragmentId"));
5744 }
5745 fragment_id__ =
5746 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5747 ;
5748 }
5749 GeneratedField::VnodeColIndex => {
5750 if vnode_col_index__.is_some() {
5751 return Err(serde::de::Error::duplicate_field("vnodeColIndex"));
5752 }
5753 vnode_col_index__ =
5754 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5755 ;
5756 }
5757 GeneratedField::RowIdIndex => {
5758 if row_id_index__.is_some() {
5759 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
5760 }
5761 row_id_index__ =
5762 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5763 ;
5764 }
5765 GeneratedField::ValueIndices => {
5766 if value_indices__.is_some() {
5767 return Err(serde::de::Error::duplicate_field("valueIndices"));
5768 }
5769 value_indices__ =
5770 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5771 .into_iter().map(|x| x.0).collect())
5772 ;
5773 }
5774 GeneratedField::Definition => {
5775 if definition__.is_some() {
5776 return Err(serde::de::Error::duplicate_field("definition"));
5777 }
5778 definition__ = Some(map_.next_value()?);
5779 }
5780 GeneratedField::HandlePkConflictBehavior => {
5781 if handle_pk_conflict_behavior__.is_some() {
5782 return Err(serde::de::Error::duplicate_field("handlePkConflictBehavior"));
5783 }
5784 handle_pk_conflict_behavior__ = Some(map_.next_value::<HandleConflictBehavior>()? as i32);
5785 }
5786 GeneratedField::ReadPrefixLenHint => {
5787 if read_prefix_len_hint__.is_some() {
5788 return Err(serde::de::Error::duplicate_field("readPrefixLenHint"));
5789 }
5790 read_prefix_len_hint__ =
5791 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5792 ;
5793 }
5794 GeneratedField::WatermarkIndices => {
5795 if watermark_indices__.is_some() {
5796 return Err(serde::de::Error::duplicate_field("watermarkIndices"));
5797 }
5798 watermark_indices__ =
5799 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5800 .into_iter().map(|x| x.0).collect())
5801 ;
5802 }
5803 GeneratedField::DistKeyInPk => {
5804 if dist_key_in_pk__.is_some() {
5805 return Err(serde::de::Error::duplicate_field("distKeyInPk"));
5806 }
5807 dist_key_in_pk__ =
5808 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5809 .into_iter().map(|x| x.0).collect())
5810 ;
5811 }
5812 GeneratedField::DmlFragmentId => {
5813 if dml_fragment_id__.is_some() {
5814 return Err(serde::de::Error::duplicate_field("dmlFragmentId"));
5815 }
5816 dml_fragment_id__ =
5817 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5818 ;
5819 }
5820 GeneratedField::Cardinality => {
5821 if cardinality__.is_some() {
5822 return Err(serde::de::Error::duplicate_field("cardinality"));
5823 }
5824 cardinality__ = map_.next_value()?;
5825 }
5826 GeneratedField::InitializedAtEpoch => {
5827 if initialized_at_epoch__.is_some() {
5828 return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
5829 }
5830 initialized_at_epoch__ =
5831 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5832 ;
5833 }
5834 GeneratedField::CreatedAtEpoch => {
5835 if created_at_epoch__.is_some() {
5836 return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
5837 }
5838 created_at_epoch__ =
5839 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5840 ;
5841 }
5842 GeneratedField::CleanedByWatermark => {
5843 if cleaned_by_watermark__.is_some() {
5844 return Err(serde::de::Error::duplicate_field("cleanedByWatermark"));
5845 }
5846 cleaned_by_watermark__ = Some(map_.next_value()?);
5847 }
5848 GeneratedField::StreamJobStatus => {
5849 if stream_job_status__.is_some() {
5850 return Err(serde::de::Error::duplicate_field("streamJobStatus"));
5851 }
5852 stream_job_status__ = Some(map_.next_value::<StreamJobStatus>()? as i32);
5853 }
5854 GeneratedField::CreateType => {
5855 if create_type__.is_some() {
5856 return Err(serde::de::Error::duplicate_field("createType"));
5857 }
5858 create_type__ = Some(map_.next_value::<CreateType>()? as i32);
5859 }
5860 GeneratedField::Description => {
5861 if description__.is_some() {
5862 return Err(serde::de::Error::duplicate_field("description"));
5863 }
5864 description__ = map_.next_value()?;
5865 }
5866 GeneratedField::IncomingSinks => {
5867 if incoming_sinks__.is_some() {
5868 return Err(serde::de::Error::duplicate_field("incomingSinks"));
5869 }
5870 incoming_sinks__ =
5871 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5872 .into_iter().map(|x| x.0).collect())
5873 ;
5874 }
5875 GeneratedField::InitializedAtClusterVersion => {
5876 if initialized_at_cluster_version__.is_some() {
5877 return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
5878 }
5879 initialized_at_cluster_version__ = map_.next_value()?;
5880 }
5881 GeneratedField::CreatedAtClusterVersion => {
5882 if created_at_cluster_version__.is_some() {
5883 return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
5884 }
5885 created_at_cluster_version__ = map_.next_value()?;
5886 }
5887 GeneratedField::RetentionSeconds => {
5888 if retention_seconds__.is_some() {
5889 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
5890 }
5891 retention_seconds__ =
5892 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5893 ;
5894 }
5895 GeneratedField::VersionColumnIndex => {
5896 if version_column_index__.is_some() {
5897 return Err(serde::de::Error::duplicate_field("versionColumnIndex"));
5898 }
5899 version_column_index__ =
5900 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5901 ;
5902 }
5903 GeneratedField::CdcTableId => {
5904 if cdc_table_id__.is_some() {
5905 return Err(serde::de::Error::duplicate_field("cdcTableId"));
5906 }
5907 cdc_table_id__ = map_.next_value()?;
5908 }
5909 GeneratedField::MaybeVnodeCount => {
5910 if maybe_vnode_count__.is_some() {
5911 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
5912 }
5913 maybe_vnode_count__ =
5914 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5915 ;
5916 }
5917 GeneratedField::WebhookInfo => {
5918 if webhook_info__.is_some() {
5919 return Err(serde::de::Error::duplicate_field("webhookInfo"));
5920 }
5921 webhook_info__ = map_.next_value()?;
5922 }
5923 GeneratedField::JobId => {
5924 if job_id__.is_some() {
5925 return Err(serde::de::Error::duplicate_field("jobId"));
5926 }
5927 job_id__ =
5928 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5929 ;
5930 }
5931 GeneratedField::Engine => {
5932 if engine__.is_some() {
5933 return Err(serde::de::Error::duplicate_field("engine"));
5934 }
5935 engine__ = map_.next_value::<::std::option::Option<table::Engine>>()?.map(|x| x as i32);
5936 }
5937 GeneratedField::CleanWatermarkIndexInPk => {
5938 if clean_watermark_index_in_pk__.is_some() {
5939 return Err(serde::de::Error::duplicate_field("cleanWatermarkIndexInPk"));
5940 }
5941 clean_watermark_index_in_pk__ =
5942 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5943 ;
5944 }
5945 GeneratedField::Version => {
5946 if version__.is_some() {
5947 return Err(serde::de::Error::duplicate_field("version"));
5948 }
5949 version__ = map_.next_value()?;
5950 }
5951 GeneratedField::AssociatedSourceId => {
5952 if optional_associated_source_id__.is_some() {
5953 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
5954 }
5955 optional_associated_source_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| table::OptionalAssociatedSourceId::AssociatedSourceId(x.0));
5956 }
5957 }
5958 }
5959 Ok(Table {
5960 id: id__.unwrap_or_default(),
5961 schema_id: schema_id__.unwrap_or_default(),
5962 database_id: database_id__.unwrap_or_default(),
5963 name: name__.unwrap_or_default(),
5964 columns: columns__.unwrap_or_default(),
5965 pk: pk__.unwrap_or_default(),
5966 dependent_relations: dependent_relations__.unwrap_or_default(),
5967 table_type: table_type__.unwrap_or_default(),
5968 distribution_key: distribution_key__.unwrap_or_default(),
5969 stream_key: stream_key__.unwrap_or_default(),
5970 append_only: append_only__.unwrap_or_default(),
5971 owner: owner__.unwrap_or_default(),
5972 fragment_id: fragment_id__.unwrap_or_default(),
5973 vnode_col_index: vnode_col_index__,
5974 row_id_index: row_id_index__,
5975 value_indices: value_indices__.unwrap_or_default(),
5976 definition: definition__.unwrap_or_default(),
5977 handle_pk_conflict_behavior: handle_pk_conflict_behavior__.unwrap_or_default(),
5978 read_prefix_len_hint: read_prefix_len_hint__.unwrap_or_default(),
5979 watermark_indices: watermark_indices__.unwrap_or_default(),
5980 dist_key_in_pk: dist_key_in_pk__.unwrap_or_default(),
5981 dml_fragment_id: dml_fragment_id__,
5982 cardinality: cardinality__,
5983 initialized_at_epoch: initialized_at_epoch__,
5984 created_at_epoch: created_at_epoch__,
5985 cleaned_by_watermark: cleaned_by_watermark__.unwrap_or_default(),
5986 stream_job_status: stream_job_status__.unwrap_or_default(),
5987 create_type: create_type__.unwrap_or_default(),
5988 description: description__,
5989 incoming_sinks: incoming_sinks__.unwrap_or_default(),
5990 initialized_at_cluster_version: initialized_at_cluster_version__,
5991 created_at_cluster_version: created_at_cluster_version__,
5992 retention_seconds: retention_seconds__,
5993 version_column_index: version_column_index__,
5994 cdc_table_id: cdc_table_id__,
5995 maybe_vnode_count: maybe_vnode_count__,
5996 webhook_info: webhook_info__,
5997 job_id: job_id__,
5998 engine: engine__,
5999 clean_watermark_index_in_pk: clean_watermark_index_in_pk__,
6000 version: version__,
6001 optional_associated_source_id: optional_associated_source_id__,
6002 })
6003 }
6004 }
6005 deserializer.deserialize_struct("catalog.Table", FIELDS, GeneratedVisitor)
6006 }
6007}
6008impl serde::Serialize for table::Engine {
6009 #[allow(deprecated)]
6010 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6011 where
6012 S: serde::Serializer,
6013 {
6014 let variant = match self {
6015 Self::Unspecified => "ENGINE_UNSPECIFIED",
6016 Self::Hummock => "HUMMOCK",
6017 Self::Iceberg => "ICEBERG",
6018 };
6019 serializer.serialize_str(variant)
6020 }
6021}
6022impl<'de> serde::Deserialize<'de> for table::Engine {
6023 #[allow(deprecated)]
6024 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6025 where
6026 D: serde::Deserializer<'de>,
6027 {
6028 const FIELDS: &[&str] = &[
6029 "ENGINE_UNSPECIFIED",
6030 "HUMMOCK",
6031 "ICEBERG",
6032 ];
6033
6034 struct GeneratedVisitor;
6035
6036 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6037 type Value = table::Engine;
6038
6039 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6040 write!(formatter, "expected one of: {:?}", &FIELDS)
6041 }
6042
6043 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6044 where
6045 E: serde::de::Error,
6046 {
6047 i32::try_from(v)
6048 .ok()
6049 .and_then(|x| x.try_into().ok())
6050 .ok_or_else(|| {
6051 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6052 })
6053 }
6054
6055 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6056 where
6057 E: serde::de::Error,
6058 {
6059 i32::try_from(v)
6060 .ok()
6061 .and_then(|x| x.try_into().ok())
6062 .ok_or_else(|| {
6063 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6064 })
6065 }
6066
6067 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6068 where
6069 E: serde::de::Error,
6070 {
6071 match value {
6072 "ENGINE_UNSPECIFIED" => Ok(table::Engine::Unspecified),
6073 "HUMMOCK" => Ok(table::Engine::Hummock),
6074 "ICEBERG" => Ok(table::Engine::Iceberg),
6075 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6076 }
6077 }
6078 }
6079 deserializer.deserialize_any(GeneratedVisitor)
6080 }
6081}
6082impl serde::Serialize for table::TableType {
6083 #[allow(deprecated)]
6084 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6085 where
6086 S: serde::Serializer,
6087 {
6088 let variant = match self {
6089 Self::Unspecified => "UNSPECIFIED",
6090 Self::Table => "TABLE",
6091 Self::MaterializedView => "MATERIALIZED_VIEW",
6092 Self::Index => "INDEX",
6093 Self::Internal => "INTERNAL",
6094 };
6095 serializer.serialize_str(variant)
6096 }
6097}
6098impl<'de> serde::Deserialize<'de> for table::TableType {
6099 #[allow(deprecated)]
6100 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6101 where
6102 D: serde::Deserializer<'de>,
6103 {
6104 const FIELDS: &[&str] = &[
6105 "UNSPECIFIED",
6106 "TABLE",
6107 "MATERIALIZED_VIEW",
6108 "INDEX",
6109 "INTERNAL",
6110 ];
6111
6112 struct GeneratedVisitor;
6113
6114 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6115 type Value = table::TableType;
6116
6117 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6118 write!(formatter, "expected one of: {:?}", &FIELDS)
6119 }
6120
6121 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6122 where
6123 E: serde::de::Error,
6124 {
6125 i32::try_from(v)
6126 .ok()
6127 .and_then(|x| x.try_into().ok())
6128 .ok_or_else(|| {
6129 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6130 })
6131 }
6132
6133 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6134 where
6135 E: serde::de::Error,
6136 {
6137 i32::try_from(v)
6138 .ok()
6139 .and_then(|x| x.try_into().ok())
6140 .ok_or_else(|| {
6141 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6142 })
6143 }
6144
6145 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6146 where
6147 E: serde::de::Error,
6148 {
6149 match value {
6150 "UNSPECIFIED" => Ok(table::TableType::Unspecified),
6151 "TABLE" => Ok(table::TableType::Table),
6152 "MATERIALIZED_VIEW" => Ok(table::TableType::MaterializedView),
6153 "INDEX" => Ok(table::TableType::Index),
6154 "INTERNAL" => Ok(table::TableType::Internal),
6155 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6156 }
6157 }
6158 }
6159 deserializer.deserialize_any(GeneratedVisitor)
6160 }
6161}
6162impl serde::Serialize for table::TableVersion {
6163 #[allow(deprecated)]
6164 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6165 where
6166 S: serde::Serializer,
6167 {
6168 use serde::ser::SerializeStruct;
6169 let mut len = 0;
6170 if self.version != 0 {
6171 len += 1;
6172 }
6173 if self.next_column_id != 0 {
6174 len += 1;
6175 }
6176 let mut struct_ser = serializer.serialize_struct("catalog.Table.TableVersion", len)?;
6177 if self.version != 0 {
6178 #[allow(clippy::needless_borrow)]
6179 #[allow(clippy::needless_borrows_for_generic_args)]
6180 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
6181 }
6182 if self.next_column_id != 0 {
6183 struct_ser.serialize_field("nextColumnId", &self.next_column_id)?;
6184 }
6185 struct_ser.end()
6186 }
6187}
6188impl<'de> serde::Deserialize<'de> for table::TableVersion {
6189 #[allow(deprecated)]
6190 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6191 where
6192 D: serde::Deserializer<'de>,
6193 {
6194 const FIELDS: &[&str] = &[
6195 "version",
6196 "next_column_id",
6197 "nextColumnId",
6198 ];
6199
6200 #[allow(clippy::enum_variant_names)]
6201 enum GeneratedField {
6202 Version,
6203 NextColumnId,
6204 }
6205 impl<'de> serde::Deserialize<'de> for GeneratedField {
6206 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6207 where
6208 D: serde::Deserializer<'de>,
6209 {
6210 struct GeneratedVisitor;
6211
6212 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6213 type Value = GeneratedField;
6214
6215 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6216 write!(formatter, "expected one of: {:?}", &FIELDS)
6217 }
6218
6219 #[allow(unused_variables)]
6220 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6221 where
6222 E: serde::de::Error,
6223 {
6224 match value {
6225 "version" => Ok(GeneratedField::Version),
6226 "nextColumnId" | "next_column_id" => Ok(GeneratedField::NextColumnId),
6227 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6228 }
6229 }
6230 }
6231 deserializer.deserialize_identifier(GeneratedVisitor)
6232 }
6233 }
6234 struct GeneratedVisitor;
6235 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6236 type Value = table::TableVersion;
6237
6238 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6239 formatter.write_str("struct catalog.Table.TableVersion")
6240 }
6241
6242 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table::TableVersion, V::Error>
6243 where
6244 V: serde::de::MapAccess<'de>,
6245 {
6246 let mut version__ = None;
6247 let mut next_column_id__ = None;
6248 while let Some(k) = map_.next_key()? {
6249 match k {
6250 GeneratedField::Version => {
6251 if version__.is_some() {
6252 return Err(serde::de::Error::duplicate_field("version"));
6253 }
6254 version__ =
6255 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6256 ;
6257 }
6258 GeneratedField::NextColumnId => {
6259 if next_column_id__.is_some() {
6260 return Err(serde::de::Error::duplicate_field("nextColumnId"));
6261 }
6262 next_column_id__ =
6263 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6264 ;
6265 }
6266 }
6267 }
6268 Ok(table::TableVersion {
6269 version: version__.unwrap_or_default(),
6270 next_column_id: next_column_id__.unwrap_or_default(),
6271 })
6272 }
6273 }
6274 deserializer.deserialize_struct("catalog.Table.TableVersion", FIELDS, GeneratedVisitor)
6275 }
6276}
6277impl serde::Serialize for View {
6278 #[allow(deprecated)]
6279 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6280 where
6281 S: serde::Serializer,
6282 {
6283 use serde::ser::SerializeStruct;
6284 let mut len = 0;
6285 if self.id != 0 {
6286 len += 1;
6287 }
6288 if self.schema_id != 0 {
6289 len += 1;
6290 }
6291 if self.database_id != 0 {
6292 len += 1;
6293 }
6294 if !self.name.is_empty() {
6295 len += 1;
6296 }
6297 if self.owner != 0 {
6298 len += 1;
6299 }
6300 if !self.properties.is_empty() {
6301 len += 1;
6302 }
6303 if !self.sql.is_empty() {
6304 len += 1;
6305 }
6306 if !self.dependent_relations.is_empty() {
6307 len += 1;
6308 }
6309 if !self.columns.is_empty() {
6310 len += 1;
6311 }
6312 let mut struct_ser = serializer.serialize_struct("catalog.View", len)?;
6313 if self.id != 0 {
6314 struct_ser.serialize_field("id", &self.id)?;
6315 }
6316 if self.schema_id != 0 {
6317 struct_ser.serialize_field("schemaId", &self.schema_id)?;
6318 }
6319 if self.database_id != 0 {
6320 struct_ser.serialize_field("databaseId", &self.database_id)?;
6321 }
6322 if !self.name.is_empty() {
6323 struct_ser.serialize_field("name", &self.name)?;
6324 }
6325 if self.owner != 0 {
6326 struct_ser.serialize_field("owner", &self.owner)?;
6327 }
6328 if !self.properties.is_empty() {
6329 struct_ser.serialize_field("properties", &self.properties)?;
6330 }
6331 if !self.sql.is_empty() {
6332 struct_ser.serialize_field("sql", &self.sql)?;
6333 }
6334 if !self.dependent_relations.is_empty() {
6335 struct_ser.serialize_field("dependentRelations", &self.dependent_relations)?;
6336 }
6337 if !self.columns.is_empty() {
6338 struct_ser.serialize_field("columns", &self.columns)?;
6339 }
6340 struct_ser.end()
6341 }
6342}
6343impl<'de> serde::Deserialize<'de> for View {
6344 #[allow(deprecated)]
6345 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6346 where
6347 D: serde::Deserializer<'de>,
6348 {
6349 const FIELDS: &[&str] = &[
6350 "id",
6351 "schema_id",
6352 "schemaId",
6353 "database_id",
6354 "databaseId",
6355 "name",
6356 "owner",
6357 "properties",
6358 "sql",
6359 "dependent_relations",
6360 "dependentRelations",
6361 "columns",
6362 ];
6363
6364 #[allow(clippy::enum_variant_names)]
6365 enum GeneratedField {
6366 Id,
6367 SchemaId,
6368 DatabaseId,
6369 Name,
6370 Owner,
6371 Properties,
6372 Sql,
6373 DependentRelations,
6374 Columns,
6375 }
6376 impl<'de> serde::Deserialize<'de> for GeneratedField {
6377 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6378 where
6379 D: serde::Deserializer<'de>,
6380 {
6381 struct GeneratedVisitor;
6382
6383 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6384 type Value = GeneratedField;
6385
6386 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6387 write!(formatter, "expected one of: {:?}", &FIELDS)
6388 }
6389
6390 #[allow(unused_variables)]
6391 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6392 where
6393 E: serde::de::Error,
6394 {
6395 match value {
6396 "id" => Ok(GeneratedField::Id),
6397 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
6398 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
6399 "name" => Ok(GeneratedField::Name),
6400 "owner" => Ok(GeneratedField::Owner),
6401 "properties" => Ok(GeneratedField::Properties),
6402 "sql" => Ok(GeneratedField::Sql),
6403 "dependentRelations" | "dependent_relations" => Ok(GeneratedField::DependentRelations),
6404 "columns" => Ok(GeneratedField::Columns),
6405 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6406 }
6407 }
6408 }
6409 deserializer.deserialize_identifier(GeneratedVisitor)
6410 }
6411 }
6412 struct GeneratedVisitor;
6413 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6414 type Value = View;
6415
6416 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6417 formatter.write_str("struct catalog.View")
6418 }
6419
6420 fn visit_map<V>(self, mut map_: V) -> std::result::Result<View, V::Error>
6421 where
6422 V: serde::de::MapAccess<'de>,
6423 {
6424 let mut id__ = None;
6425 let mut schema_id__ = None;
6426 let mut database_id__ = None;
6427 let mut name__ = None;
6428 let mut owner__ = None;
6429 let mut properties__ = None;
6430 let mut sql__ = None;
6431 let mut dependent_relations__ = None;
6432 let mut columns__ = None;
6433 while let Some(k) = map_.next_key()? {
6434 match k {
6435 GeneratedField::Id => {
6436 if id__.is_some() {
6437 return Err(serde::de::Error::duplicate_field("id"));
6438 }
6439 id__ =
6440 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6441 ;
6442 }
6443 GeneratedField::SchemaId => {
6444 if schema_id__.is_some() {
6445 return Err(serde::de::Error::duplicate_field("schemaId"));
6446 }
6447 schema_id__ =
6448 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6449 ;
6450 }
6451 GeneratedField::DatabaseId => {
6452 if database_id__.is_some() {
6453 return Err(serde::de::Error::duplicate_field("databaseId"));
6454 }
6455 database_id__ =
6456 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6457 ;
6458 }
6459 GeneratedField::Name => {
6460 if name__.is_some() {
6461 return Err(serde::de::Error::duplicate_field("name"));
6462 }
6463 name__ = Some(map_.next_value()?);
6464 }
6465 GeneratedField::Owner => {
6466 if owner__.is_some() {
6467 return Err(serde::de::Error::duplicate_field("owner"));
6468 }
6469 owner__ =
6470 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6471 ;
6472 }
6473 GeneratedField::Properties => {
6474 if properties__.is_some() {
6475 return Err(serde::de::Error::duplicate_field("properties"));
6476 }
6477 properties__ = Some(
6478 map_.next_value::<std::collections::BTreeMap<_, _>>()?
6479 );
6480 }
6481 GeneratedField::Sql => {
6482 if sql__.is_some() {
6483 return Err(serde::de::Error::duplicate_field("sql"));
6484 }
6485 sql__ = Some(map_.next_value()?);
6486 }
6487 GeneratedField::DependentRelations => {
6488 if dependent_relations__.is_some() {
6489 return Err(serde::de::Error::duplicate_field("dependentRelations"));
6490 }
6491 dependent_relations__ =
6492 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6493 .into_iter().map(|x| x.0).collect())
6494 ;
6495 }
6496 GeneratedField::Columns => {
6497 if columns__.is_some() {
6498 return Err(serde::de::Error::duplicate_field("columns"));
6499 }
6500 columns__ = Some(map_.next_value()?);
6501 }
6502 }
6503 }
6504 Ok(View {
6505 id: id__.unwrap_or_default(),
6506 schema_id: schema_id__.unwrap_or_default(),
6507 database_id: database_id__.unwrap_or_default(),
6508 name: name__.unwrap_or_default(),
6509 owner: owner__.unwrap_or_default(),
6510 properties: properties__.unwrap_or_default(),
6511 sql: sql__.unwrap_or_default(),
6512 dependent_relations: dependent_relations__.unwrap_or_default(),
6513 columns: columns__.unwrap_or_default(),
6514 })
6515 }
6516 }
6517 deserializer.deserialize_struct("catalog.View", FIELDS, GeneratedVisitor)
6518 }
6519}
6520impl serde::Serialize for WatermarkDesc {
6521 #[allow(deprecated)]
6522 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6523 where
6524 S: serde::Serializer,
6525 {
6526 use serde::ser::SerializeStruct;
6527 let mut len = 0;
6528 if self.watermark_idx != 0 {
6529 len += 1;
6530 }
6531 if self.expr.is_some() {
6532 len += 1;
6533 }
6534 let mut struct_ser = serializer.serialize_struct("catalog.WatermarkDesc", len)?;
6535 if self.watermark_idx != 0 {
6536 struct_ser.serialize_field("watermarkIdx", &self.watermark_idx)?;
6537 }
6538 if let Some(v) = self.expr.as_ref() {
6539 struct_ser.serialize_field("expr", v)?;
6540 }
6541 struct_ser.end()
6542 }
6543}
6544impl<'de> serde::Deserialize<'de> for WatermarkDesc {
6545 #[allow(deprecated)]
6546 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6547 where
6548 D: serde::Deserializer<'de>,
6549 {
6550 const FIELDS: &[&str] = &[
6551 "watermark_idx",
6552 "watermarkIdx",
6553 "expr",
6554 ];
6555
6556 #[allow(clippy::enum_variant_names)]
6557 enum GeneratedField {
6558 WatermarkIdx,
6559 Expr,
6560 }
6561 impl<'de> serde::Deserialize<'de> for GeneratedField {
6562 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6563 where
6564 D: serde::Deserializer<'de>,
6565 {
6566 struct GeneratedVisitor;
6567
6568 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6569 type Value = GeneratedField;
6570
6571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6572 write!(formatter, "expected one of: {:?}", &FIELDS)
6573 }
6574
6575 #[allow(unused_variables)]
6576 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6577 where
6578 E: serde::de::Error,
6579 {
6580 match value {
6581 "watermarkIdx" | "watermark_idx" => Ok(GeneratedField::WatermarkIdx),
6582 "expr" => Ok(GeneratedField::Expr),
6583 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6584 }
6585 }
6586 }
6587 deserializer.deserialize_identifier(GeneratedVisitor)
6588 }
6589 }
6590 struct GeneratedVisitor;
6591 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6592 type Value = WatermarkDesc;
6593
6594 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6595 formatter.write_str("struct catalog.WatermarkDesc")
6596 }
6597
6598 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkDesc, V::Error>
6599 where
6600 V: serde::de::MapAccess<'de>,
6601 {
6602 let mut watermark_idx__ = None;
6603 let mut expr__ = None;
6604 while let Some(k) = map_.next_key()? {
6605 match k {
6606 GeneratedField::WatermarkIdx => {
6607 if watermark_idx__.is_some() {
6608 return Err(serde::de::Error::duplicate_field("watermarkIdx"));
6609 }
6610 watermark_idx__ =
6611 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6612 ;
6613 }
6614 GeneratedField::Expr => {
6615 if expr__.is_some() {
6616 return Err(serde::de::Error::duplicate_field("expr"));
6617 }
6618 expr__ = map_.next_value()?;
6619 }
6620 }
6621 }
6622 Ok(WatermarkDesc {
6623 watermark_idx: watermark_idx__.unwrap_or_default(),
6624 expr: expr__,
6625 })
6626 }
6627 }
6628 deserializer.deserialize_struct("catalog.WatermarkDesc", FIELDS, GeneratedVisitor)
6629 }
6630}
6631impl serde::Serialize for WebhookSourceInfo {
6632 #[allow(deprecated)]
6633 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6634 where
6635 S: serde::Serializer,
6636 {
6637 use serde::ser::SerializeStruct;
6638 let mut len = 0;
6639 if self.secret_ref.is_some() {
6640 len += 1;
6641 }
6642 if self.signature_expr.is_some() {
6643 len += 1;
6644 }
6645 if self.wait_for_persistence {
6646 len += 1;
6647 }
6648 if self.is_batched {
6649 len += 1;
6650 }
6651 let mut struct_ser = serializer.serialize_struct("catalog.WebhookSourceInfo", len)?;
6652 if let Some(v) = self.secret_ref.as_ref() {
6653 struct_ser.serialize_field("secretRef", v)?;
6654 }
6655 if let Some(v) = self.signature_expr.as_ref() {
6656 struct_ser.serialize_field("signatureExpr", v)?;
6657 }
6658 if self.wait_for_persistence {
6659 struct_ser.serialize_field("waitForPersistence", &self.wait_for_persistence)?;
6660 }
6661 if self.is_batched {
6662 struct_ser.serialize_field("isBatched", &self.is_batched)?;
6663 }
6664 struct_ser.end()
6665 }
6666}
6667impl<'de> serde::Deserialize<'de> for WebhookSourceInfo {
6668 #[allow(deprecated)]
6669 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6670 where
6671 D: serde::Deserializer<'de>,
6672 {
6673 const FIELDS: &[&str] = &[
6674 "secret_ref",
6675 "secretRef",
6676 "signature_expr",
6677 "signatureExpr",
6678 "wait_for_persistence",
6679 "waitForPersistence",
6680 "is_batched",
6681 "isBatched",
6682 ];
6683
6684 #[allow(clippy::enum_variant_names)]
6685 enum GeneratedField {
6686 SecretRef,
6687 SignatureExpr,
6688 WaitForPersistence,
6689 IsBatched,
6690 }
6691 impl<'de> serde::Deserialize<'de> for GeneratedField {
6692 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6693 where
6694 D: serde::Deserializer<'de>,
6695 {
6696 struct GeneratedVisitor;
6697
6698 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6699 type Value = GeneratedField;
6700
6701 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6702 write!(formatter, "expected one of: {:?}", &FIELDS)
6703 }
6704
6705 #[allow(unused_variables)]
6706 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6707 where
6708 E: serde::de::Error,
6709 {
6710 match value {
6711 "secretRef" | "secret_ref" => Ok(GeneratedField::SecretRef),
6712 "signatureExpr" | "signature_expr" => Ok(GeneratedField::SignatureExpr),
6713 "waitForPersistence" | "wait_for_persistence" => Ok(GeneratedField::WaitForPersistence),
6714 "isBatched" | "is_batched" => Ok(GeneratedField::IsBatched),
6715 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6716 }
6717 }
6718 }
6719 deserializer.deserialize_identifier(GeneratedVisitor)
6720 }
6721 }
6722 struct GeneratedVisitor;
6723 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6724 type Value = WebhookSourceInfo;
6725
6726 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6727 formatter.write_str("struct catalog.WebhookSourceInfo")
6728 }
6729
6730 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WebhookSourceInfo, V::Error>
6731 where
6732 V: serde::de::MapAccess<'de>,
6733 {
6734 let mut secret_ref__ = None;
6735 let mut signature_expr__ = None;
6736 let mut wait_for_persistence__ = None;
6737 let mut is_batched__ = None;
6738 while let Some(k) = map_.next_key()? {
6739 match k {
6740 GeneratedField::SecretRef => {
6741 if secret_ref__.is_some() {
6742 return Err(serde::de::Error::duplicate_field("secretRef"));
6743 }
6744 secret_ref__ = map_.next_value()?;
6745 }
6746 GeneratedField::SignatureExpr => {
6747 if signature_expr__.is_some() {
6748 return Err(serde::de::Error::duplicate_field("signatureExpr"));
6749 }
6750 signature_expr__ = map_.next_value()?;
6751 }
6752 GeneratedField::WaitForPersistence => {
6753 if wait_for_persistence__.is_some() {
6754 return Err(serde::de::Error::duplicate_field("waitForPersistence"));
6755 }
6756 wait_for_persistence__ = Some(map_.next_value()?);
6757 }
6758 GeneratedField::IsBatched => {
6759 if is_batched__.is_some() {
6760 return Err(serde::de::Error::duplicate_field("isBatched"));
6761 }
6762 is_batched__ = Some(map_.next_value()?);
6763 }
6764 }
6765 }
6766 Ok(WebhookSourceInfo {
6767 secret_ref: secret_ref__,
6768 signature_expr: signature_expr__,
6769 wait_for_persistence: wait_for_persistence__.unwrap_or_default(),
6770 is_batched: is_batched__.unwrap_or_default(),
6771 })
6772 }
6773 }
6774 deserializer.deserialize_struct("catalog.WebhookSourceInfo", FIELDS, GeneratedVisitor)
6775 }
6776}