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.distribution_key.is_empty() {
2966 len += 1;
2967 }
2968 if !self.downstream_pk.is_empty() {
2969 len += 1;
2970 }
2971 if self.sink_type != 0 {
2972 len += 1;
2973 }
2974 if self.owner != 0 {
2975 len += 1;
2976 }
2977 if !self.properties.is_empty() {
2978 len += 1;
2979 }
2980 if !self.definition.is_empty() {
2981 len += 1;
2982 }
2983 if self.connection_id.is_some() {
2984 len += 1;
2985 }
2986 if self.initialized_at_epoch.is_some() {
2987 len += 1;
2988 }
2989 if self.created_at_epoch.is_some() {
2990 len += 1;
2991 }
2992 if !self.db_name.is_empty() {
2993 len += 1;
2994 }
2995 if !self.sink_from_name.is_empty() {
2996 len += 1;
2997 }
2998 if self.stream_job_status != 0 {
2999 len += 1;
3000 }
3001 if self.format_desc.is_some() {
3002 len += 1;
3003 }
3004 if self.target_table.is_some() {
3005 len += 1;
3006 }
3007 if self.initialized_at_cluster_version.is_some() {
3008 len += 1;
3009 }
3010 if self.created_at_cluster_version.is_some() {
3011 len += 1;
3012 }
3013 if self.create_type != 0 {
3014 len += 1;
3015 }
3016 if !self.secret_refs.is_empty() {
3017 len += 1;
3018 }
3019 if !self.original_target_columns.is_empty() {
3020 len += 1;
3021 }
3022 let mut struct_ser = serializer.serialize_struct("catalog.Sink", len)?;
3023 if self.id != 0 {
3024 struct_ser.serialize_field("id", &self.id)?;
3025 }
3026 if self.schema_id != 0 {
3027 struct_ser.serialize_field("schemaId", &self.schema_id)?;
3028 }
3029 if self.database_id != 0 {
3030 struct_ser.serialize_field("databaseId", &self.database_id)?;
3031 }
3032 if !self.name.is_empty() {
3033 struct_ser.serialize_field("name", &self.name)?;
3034 }
3035 if !self.columns.is_empty() {
3036 struct_ser.serialize_field("columns", &self.columns)?;
3037 }
3038 if !self.plan_pk.is_empty() {
3039 struct_ser.serialize_field("planPk", &self.plan_pk)?;
3040 }
3041 if !self.distribution_key.is_empty() {
3042 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
3043 }
3044 if !self.downstream_pk.is_empty() {
3045 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
3046 }
3047 if self.sink_type != 0 {
3048 let v = SinkType::try_from(self.sink_type)
3049 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
3050 struct_ser.serialize_field("sinkType", &v)?;
3051 }
3052 if self.owner != 0 {
3053 struct_ser.serialize_field("owner", &self.owner)?;
3054 }
3055 if !self.properties.is_empty() {
3056 struct_ser.serialize_field("properties", &self.properties)?;
3057 }
3058 if !self.definition.is_empty() {
3059 struct_ser.serialize_field("definition", &self.definition)?;
3060 }
3061 if let Some(v) = self.connection_id.as_ref() {
3062 struct_ser.serialize_field("connectionId", v)?;
3063 }
3064 if let Some(v) = self.initialized_at_epoch.as_ref() {
3065 #[allow(clippy::needless_borrow)]
3066 #[allow(clippy::needless_borrows_for_generic_args)]
3067 struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
3068 }
3069 if let Some(v) = self.created_at_epoch.as_ref() {
3070 #[allow(clippy::needless_borrow)]
3071 #[allow(clippy::needless_borrows_for_generic_args)]
3072 struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
3073 }
3074 if !self.db_name.is_empty() {
3075 struct_ser.serialize_field("dbName", &self.db_name)?;
3076 }
3077 if !self.sink_from_name.is_empty() {
3078 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
3079 }
3080 if self.stream_job_status != 0 {
3081 let v = StreamJobStatus::try_from(self.stream_job_status)
3082 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_job_status)))?;
3083 struct_ser.serialize_field("streamJobStatus", &v)?;
3084 }
3085 if let Some(v) = self.format_desc.as_ref() {
3086 struct_ser.serialize_field("formatDesc", v)?;
3087 }
3088 if let Some(v) = self.target_table.as_ref() {
3089 struct_ser.serialize_field("targetTable", v)?;
3090 }
3091 if let Some(v) = self.initialized_at_cluster_version.as_ref() {
3092 struct_ser.serialize_field("initializedAtClusterVersion", v)?;
3093 }
3094 if let Some(v) = self.created_at_cluster_version.as_ref() {
3095 struct_ser.serialize_field("createdAtClusterVersion", v)?;
3096 }
3097 if self.create_type != 0 {
3098 let v = CreateType::try_from(self.create_type)
3099 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.create_type)))?;
3100 struct_ser.serialize_field("createType", &v)?;
3101 }
3102 if !self.secret_refs.is_empty() {
3103 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
3104 }
3105 if !self.original_target_columns.is_empty() {
3106 struct_ser.serialize_field("originalTargetColumns", &self.original_target_columns)?;
3107 }
3108 struct_ser.end()
3109 }
3110}
3111impl<'de> serde::Deserialize<'de> for Sink {
3112 #[allow(deprecated)]
3113 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3114 where
3115 D: serde::Deserializer<'de>,
3116 {
3117 const FIELDS: &[&str] = &[
3118 "id",
3119 "schema_id",
3120 "schemaId",
3121 "database_id",
3122 "databaseId",
3123 "name",
3124 "columns",
3125 "plan_pk",
3126 "planPk",
3127 "distribution_key",
3128 "distributionKey",
3129 "downstream_pk",
3130 "downstreamPk",
3131 "sink_type",
3132 "sinkType",
3133 "owner",
3134 "properties",
3135 "definition",
3136 "connection_id",
3137 "connectionId",
3138 "initialized_at_epoch",
3139 "initializedAtEpoch",
3140 "created_at_epoch",
3141 "createdAtEpoch",
3142 "db_name",
3143 "dbName",
3144 "sink_from_name",
3145 "sinkFromName",
3146 "stream_job_status",
3147 "streamJobStatus",
3148 "format_desc",
3149 "formatDesc",
3150 "target_table",
3151 "targetTable",
3152 "initialized_at_cluster_version",
3153 "initializedAtClusterVersion",
3154 "created_at_cluster_version",
3155 "createdAtClusterVersion",
3156 "create_type",
3157 "createType",
3158 "secret_refs",
3159 "secretRefs",
3160 "original_target_columns",
3161 "originalTargetColumns",
3162 ];
3163
3164 #[allow(clippy::enum_variant_names)]
3165 enum GeneratedField {
3166 Id,
3167 SchemaId,
3168 DatabaseId,
3169 Name,
3170 Columns,
3171 PlanPk,
3172 DistributionKey,
3173 DownstreamPk,
3174 SinkType,
3175 Owner,
3176 Properties,
3177 Definition,
3178 ConnectionId,
3179 InitializedAtEpoch,
3180 CreatedAtEpoch,
3181 DbName,
3182 SinkFromName,
3183 StreamJobStatus,
3184 FormatDesc,
3185 TargetTable,
3186 InitializedAtClusterVersion,
3187 CreatedAtClusterVersion,
3188 CreateType,
3189 SecretRefs,
3190 OriginalTargetColumns,
3191 }
3192 impl<'de> serde::Deserialize<'de> for GeneratedField {
3193 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3194 where
3195 D: serde::Deserializer<'de>,
3196 {
3197 struct GeneratedVisitor;
3198
3199 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3200 type Value = GeneratedField;
3201
3202 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3203 write!(formatter, "expected one of: {:?}", &FIELDS)
3204 }
3205
3206 #[allow(unused_variables)]
3207 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3208 where
3209 E: serde::de::Error,
3210 {
3211 match value {
3212 "id" => Ok(GeneratedField::Id),
3213 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
3214 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
3215 "name" => Ok(GeneratedField::Name),
3216 "columns" => Ok(GeneratedField::Columns),
3217 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
3218 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
3219 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
3220 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
3221 "owner" => Ok(GeneratedField::Owner),
3222 "properties" => Ok(GeneratedField::Properties),
3223 "definition" => Ok(GeneratedField::Definition),
3224 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
3225 "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
3226 "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
3227 "dbName" | "db_name" => Ok(GeneratedField::DbName),
3228 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
3229 "streamJobStatus" | "stream_job_status" => Ok(GeneratedField::StreamJobStatus),
3230 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
3231 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
3232 "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
3233 "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
3234 "createType" | "create_type" => Ok(GeneratedField::CreateType),
3235 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
3236 "originalTargetColumns" | "original_target_columns" => Ok(GeneratedField::OriginalTargetColumns),
3237 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3238 }
3239 }
3240 }
3241 deserializer.deserialize_identifier(GeneratedVisitor)
3242 }
3243 }
3244 struct GeneratedVisitor;
3245 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3246 type Value = Sink;
3247
3248 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3249 formatter.write_str("struct catalog.Sink")
3250 }
3251
3252 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Sink, V::Error>
3253 where
3254 V: serde::de::MapAccess<'de>,
3255 {
3256 let mut id__ = None;
3257 let mut schema_id__ = None;
3258 let mut database_id__ = None;
3259 let mut name__ = None;
3260 let mut columns__ = None;
3261 let mut plan_pk__ = None;
3262 let mut distribution_key__ = None;
3263 let mut downstream_pk__ = None;
3264 let mut sink_type__ = None;
3265 let mut owner__ = None;
3266 let mut properties__ = None;
3267 let mut definition__ = None;
3268 let mut connection_id__ = None;
3269 let mut initialized_at_epoch__ = None;
3270 let mut created_at_epoch__ = None;
3271 let mut db_name__ = None;
3272 let mut sink_from_name__ = None;
3273 let mut stream_job_status__ = None;
3274 let mut format_desc__ = None;
3275 let mut target_table__ = None;
3276 let mut initialized_at_cluster_version__ = None;
3277 let mut created_at_cluster_version__ = None;
3278 let mut create_type__ = None;
3279 let mut secret_refs__ = None;
3280 let mut original_target_columns__ = None;
3281 while let Some(k) = map_.next_key()? {
3282 match k {
3283 GeneratedField::Id => {
3284 if id__.is_some() {
3285 return Err(serde::de::Error::duplicate_field("id"));
3286 }
3287 id__ =
3288 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3289 ;
3290 }
3291 GeneratedField::SchemaId => {
3292 if schema_id__.is_some() {
3293 return Err(serde::de::Error::duplicate_field("schemaId"));
3294 }
3295 schema_id__ =
3296 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3297 ;
3298 }
3299 GeneratedField::DatabaseId => {
3300 if database_id__.is_some() {
3301 return Err(serde::de::Error::duplicate_field("databaseId"));
3302 }
3303 database_id__ =
3304 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3305 ;
3306 }
3307 GeneratedField::Name => {
3308 if name__.is_some() {
3309 return Err(serde::de::Error::duplicate_field("name"));
3310 }
3311 name__ = Some(map_.next_value()?);
3312 }
3313 GeneratedField::Columns => {
3314 if columns__.is_some() {
3315 return Err(serde::de::Error::duplicate_field("columns"));
3316 }
3317 columns__ = Some(map_.next_value()?);
3318 }
3319 GeneratedField::PlanPk => {
3320 if plan_pk__.is_some() {
3321 return Err(serde::de::Error::duplicate_field("planPk"));
3322 }
3323 plan_pk__ = Some(map_.next_value()?);
3324 }
3325 GeneratedField::DistributionKey => {
3326 if distribution_key__.is_some() {
3327 return Err(serde::de::Error::duplicate_field("distributionKey"));
3328 }
3329 distribution_key__ =
3330 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3331 .into_iter().map(|x| x.0).collect())
3332 ;
3333 }
3334 GeneratedField::DownstreamPk => {
3335 if downstream_pk__.is_some() {
3336 return Err(serde::de::Error::duplicate_field("downstreamPk"));
3337 }
3338 downstream_pk__ =
3339 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3340 .into_iter().map(|x| x.0).collect())
3341 ;
3342 }
3343 GeneratedField::SinkType => {
3344 if sink_type__.is_some() {
3345 return Err(serde::de::Error::duplicate_field("sinkType"));
3346 }
3347 sink_type__ = Some(map_.next_value::<SinkType>()? as i32);
3348 }
3349 GeneratedField::Owner => {
3350 if owner__.is_some() {
3351 return Err(serde::de::Error::duplicate_field("owner"));
3352 }
3353 owner__ =
3354 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3355 ;
3356 }
3357 GeneratedField::Properties => {
3358 if properties__.is_some() {
3359 return Err(serde::de::Error::duplicate_field("properties"));
3360 }
3361 properties__ = Some(
3362 map_.next_value::<std::collections::BTreeMap<_, _>>()?
3363 );
3364 }
3365 GeneratedField::Definition => {
3366 if definition__.is_some() {
3367 return Err(serde::de::Error::duplicate_field("definition"));
3368 }
3369 definition__ = Some(map_.next_value()?);
3370 }
3371 GeneratedField::ConnectionId => {
3372 if connection_id__.is_some() {
3373 return Err(serde::de::Error::duplicate_field("connectionId"));
3374 }
3375 connection_id__ =
3376 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3377 ;
3378 }
3379 GeneratedField::InitializedAtEpoch => {
3380 if initialized_at_epoch__.is_some() {
3381 return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
3382 }
3383 initialized_at_epoch__ =
3384 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3385 ;
3386 }
3387 GeneratedField::CreatedAtEpoch => {
3388 if created_at_epoch__.is_some() {
3389 return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
3390 }
3391 created_at_epoch__ =
3392 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3393 ;
3394 }
3395 GeneratedField::DbName => {
3396 if db_name__.is_some() {
3397 return Err(serde::de::Error::duplicate_field("dbName"));
3398 }
3399 db_name__ = Some(map_.next_value()?);
3400 }
3401 GeneratedField::SinkFromName => {
3402 if sink_from_name__.is_some() {
3403 return Err(serde::de::Error::duplicate_field("sinkFromName"));
3404 }
3405 sink_from_name__ = Some(map_.next_value()?);
3406 }
3407 GeneratedField::StreamJobStatus => {
3408 if stream_job_status__.is_some() {
3409 return Err(serde::de::Error::duplicate_field("streamJobStatus"));
3410 }
3411 stream_job_status__ = Some(map_.next_value::<StreamJobStatus>()? as i32);
3412 }
3413 GeneratedField::FormatDesc => {
3414 if format_desc__.is_some() {
3415 return Err(serde::de::Error::duplicate_field("formatDesc"));
3416 }
3417 format_desc__ = map_.next_value()?;
3418 }
3419 GeneratedField::TargetTable => {
3420 if target_table__.is_some() {
3421 return Err(serde::de::Error::duplicate_field("targetTable"));
3422 }
3423 target_table__ =
3424 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3425 ;
3426 }
3427 GeneratedField::InitializedAtClusterVersion => {
3428 if initialized_at_cluster_version__.is_some() {
3429 return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
3430 }
3431 initialized_at_cluster_version__ = map_.next_value()?;
3432 }
3433 GeneratedField::CreatedAtClusterVersion => {
3434 if created_at_cluster_version__.is_some() {
3435 return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
3436 }
3437 created_at_cluster_version__ = map_.next_value()?;
3438 }
3439 GeneratedField::CreateType => {
3440 if create_type__.is_some() {
3441 return Err(serde::de::Error::duplicate_field("createType"));
3442 }
3443 create_type__ = Some(map_.next_value::<CreateType>()? as i32);
3444 }
3445 GeneratedField::SecretRefs => {
3446 if secret_refs__.is_some() {
3447 return Err(serde::de::Error::duplicate_field("secretRefs"));
3448 }
3449 secret_refs__ = Some(
3450 map_.next_value::<std::collections::BTreeMap<_, _>>()?
3451 );
3452 }
3453 GeneratedField::OriginalTargetColumns => {
3454 if original_target_columns__.is_some() {
3455 return Err(serde::de::Error::duplicate_field("originalTargetColumns"));
3456 }
3457 original_target_columns__ = Some(map_.next_value()?);
3458 }
3459 }
3460 }
3461 Ok(Sink {
3462 id: id__.unwrap_or_default(),
3463 schema_id: schema_id__.unwrap_or_default(),
3464 database_id: database_id__.unwrap_or_default(),
3465 name: name__.unwrap_or_default(),
3466 columns: columns__.unwrap_or_default(),
3467 plan_pk: plan_pk__.unwrap_or_default(),
3468 distribution_key: distribution_key__.unwrap_or_default(),
3469 downstream_pk: downstream_pk__.unwrap_or_default(),
3470 sink_type: sink_type__.unwrap_or_default(),
3471 owner: owner__.unwrap_or_default(),
3472 properties: properties__.unwrap_or_default(),
3473 definition: definition__.unwrap_or_default(),
3474 connection_id: connection_id__,
3475 initialized_at_epoch: initialized_at_epoch__,
3476 created_at_epoch: created_at_epoch__,
3477 db_name: db_name__.unwrap_or_default(),
3478 sink_from_name: sink_from_name__.unwrap_or_default(),
3479 stream_job_status: stream_job_status__.unwrap_or_default(),
3480 format_desc: format_desc__,
3481 target_table: target_table__,
3482 initialized_at_cluster_version: initialized_at_cluster_version__,
3483 created_at_cluster_version: created_at_cluster_version__,
3484 create_type: create_type__.unwrap_or_default(),
3485 secret_refs: secret_refs__.unwrap_or_default(),
3486 original_target_columns: original_target_columns__.unwrap_or_default(),
3487 })
3488 }
3489 }
3490 deserializer.deserialize_struct("catalog.Sink", FIELDS, GeneratedVisitor)
3491 }
3492}
3493impl serde::Serialize for SinkFormatDesc {
3494 #[allow(deprecated)]
3495 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3496 where
3497 S: serde::Serializer,
3498 {
3499 use serde::ser::SerializeStruct;
3500 let mut len = 0;
3501 if self.format != 0 {
3502 len += 1;
3503 }
3504 if self.encode != 0 {
3505 len += 1;
3506 }
3507 if !self.options.is_empty() {
3508 len += 1;
3509 }
3510 if self.key_encode.is_some() {
3511 len += 1;
3512 }
3513 if !self.secret_refs.is_empty() {
3514 len += 1;
3515 }
3516 if self.connection_id.is_some() {
3517 len += 1;
3518 }
3519 let mut struct_ser = serializer.serialize_struct("catalog.SinkFormatDesc", len)?;
3520 if self.format != 0 {
3521 let v = super::plan_common::FormatType::try_from(self.format)
3522 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?;
3523 struct_ser.serialize_field("format", &v)?;
3524 }
3525 if self.encode != 0 {
3526 let v = super::plan_common::EncodeType::try_from(self.encode)
3527 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.encode)))?;
3528 struct_ser.serialize_field("encode", &v)?;
3529 }
3530 if !self.options.is_empty() {
3531 struct_ser.serialize_field("options", &self.options)?;
3532 }
3533 if let Some(v) = self.key_encode.as_ref() {
3534 let v = super::plan_common::EncodeType::try_from(*v)
3535 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
3536 struct_ser.serialize_field("keyEncode", &v)?;
3537 }
3538 if !self.secret_refs.is_empty() {
3539 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
3540 }
3541 if let Some(v) = self.connection_id.as_ref() {
3542 struct_ser.serialize_field("connectionId", v)?;
3543 }
3544 struct_ser.end()
3545 }
3546}
3547impl<'de> serde::Deserialize<'de> for SinkFormatDesc {
3548 #[allow(deprecated)]
3549 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3550 where
3551 D: serde::Deserializer<'de>,
3552 {
3553 const FIELDS: &[&str] = &[
3554 "format",
3555 "encode",
3556 "options",
3557 "key_encode",
3558 "keyEncode",
3559 "secret_refs",
3560 "secretRefs",
3561 "connection_id",
3562 "connectionId",
3563 ];
3564
3565 #[allow(clippy::enum_variant_names)]
3566 enum GeneratedField {
3567 Format,
3568 Encode,
3569 Options,
3570 KeyEncode,
3571 SecretRefs,
3572 ConnectionId,
3573 }
3574 impl<'de> serde::Deserialize<'de> for GeneratedField {
3575 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3576 where
3577 D: serde::Deserializer<'de>,
3578 {
3579 struct GeneratedVisitor;
3580
3581 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3582 type Value = GeneratedField;
3583
3584 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3585 write!(formatter, "expected one of: {:?}", &FIELDS)
3586 }
3587
3588 #[allow(unused_variables)]
3589 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3590 where
3591 E: serde::de::Error,
3592 {
3593 match value {
3594 "format" => Ok(GeneratedField::Format),
3595 "encode" => Ok(GeneratedField::Encode),
3596 "options" => Ok(GeneratedField::Options),
3597 "keyEncode" | "key_encode" => Ok(GeneratedField::KeyEncode),
3598 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
3599 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
3600 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3601 }
3602 }
3603 }
3604 deserializer.deserialize_identifier(GeneratedVisitor)
3605 }
3606 }
3607 struct GeneratedVisitor;
3608 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3609 type Value = SinkFormatDesc;
3610
3611 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3612 formatter.write_str("struct catalog.SinkFormatDesc")
3613 }
3614
3615 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkFormatDesc, V::Error>
3616 where
3617 V: serde::de::MapAccess<'de>,
3618 {
3619 let mut format__ = None;
3620 let mut encode__ = None;
3621 let mut options__ = None;
3622 let mut key_encode__ = None;
3623 let mut secret_refs__ = None;
3624 let mut connection_id__ = None;
3625 while let Some(k) = map_.next_key()? {
3626 match k {
3627 GeneratedField::Format => {
3628 if format__.is_some() {
3629 return Err(serde::de::Error::duplicate_field("format"));
3630 }
3631 format__ = Some(map_.next_value::<super::plan_common::FormatType>()? as i32);
3632 }
3633 GeneratedField::Encode => {
3634 if encode__.is_some() {
3635 return Err(serde::de::Error::duplicate_field("encode"));
3636 }
3637 encode__ = Some(map_.next_value::<super::plan_common::EncodeType>()? as i32);
3638 }
3639 GeneratedField::Options => {
3640 if options__.is_some() {
3641 return Err(serde::de::Error::duplicate_field("options"));
3642 }
3643 options__ = Some(
3644 map_.next_value::<std::collections::BTreeMap<_, _>>()?
3645 );
3646 }
3647 GeneratedField::KeyEncode => {
3648 if key_encode__.is_some() {
3649 return Err(serde::de::Error::duplicate_field("keyEncode"));
3650 }
3651 key_encode__ = map_.next_value::<::std::option::Option<super::plan_common::EncodeType>>()?.map(|x| x as i32);
3652 }
3653 GeneratedField::SecretRefs => {
3654 if secret_refs__.is_some() {
3655 return Err(serde::de::Error::duplicate_field("secretRefs"));
3656 }
3657 secret_refs__ = Some(
3658 map_.next_value::<std::collections::BTreeMap<_, _>>()?
3659 );
3660 }
3661 GeneratedField::ConnectionId => {
3662 if connection_id__.is_some() {
3663 return Err(serde::de::Error::duplicate_field("connectionId"));
3664 }
3665 connection_id__ =
3666 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3667 ;
3668 }
3669 }
3670 }
3671 Ok(SinkFormatDesc {
3672 format: format__.unwrap_or_default(),
3673 encode: encode__.unwrap_or_default(),
3674 options: options__.unwrap_or_default(),
3675 key_encode: key_encode__,
3676 secret_refs: secret_refs__.unwrap_or_default(),
3677 connection_id: connection_id__,
3678 })
3679 }
3680 }
3681 deserializer.deserialize_struct("catalog.SinkFormatDesc", FIELDS, GeneratedVisitor)
3682 }
3683}
3684impl serde::Serialize for SinkType {
3685 #[allow(deprecated)]
3686 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3687 where
3688 S: serde::Serializer,
3689 {
3690 let variant = match self {
3691 Self::Unspecified => "SINK_TYPE_UNSPECIFIED",
3692 Self::AppendOnly => "SINK_TYPE_APPEND_ONLY",
3693 Self::ForceAppendOnly => "SINK_TYPE_FORCE_APPEND_ONLY",
3694 Self::Upsert => "SINK_TYPE_UPSERT",
3695 };
3696 serializer.serialize_str(variant)
3697 }
3698}
3699impl<'de> serde::Deserialize<'de> for SinkType {
3700 #[allow(deprecated)]
3701 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3702 where
3703 D: serde::Deserializer<'de>,
3704 {
3705 const FIELDS: &[&str] = &[
3706 "SINK_TYPE_UNSPECIFIED",
3707 "SINK_TYPE_APPEND_ONLY",
3708 "SINK_TYPE_FORCE_APPEND_ONLY",
3709 "SINK_TYPE_UPSERT",
3710 ];
3711
3712 struct GeneratedVisitor;
3713
3714 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3715 type Value = SinkType;
3716
3717 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3718 write!(formatter, "expected one of: {:?}", &FIELDS)
3719 }
3720
3721 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3722 where
3723 E: serde::de::Error,
3724 {
3725 i32::try_from(v)
3726 .ok()
3727 .and_then(|x| x.try_into().ok())
3728 .ok_or_else(|| {
3729 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3730 })
3731 }
3732
3733 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3734 where
3735 E: serde::de::Error,
3736 {
3737 i32::try_from(v)
3738 .ok()
3739 .and_then(|x| x.try_into().ok())
3740 .ok_or_else(|| {
3741 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3742 })
3743 }
3744
3745 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3746 where
3747 E: serde::de::Error,
3748 {
3749 match value {
3750 "SINK_TYPE_UNSPECIFIED" => Ok(SinkType::Unspecified),
3751 "SINK_TYPE_APPEND_ONLY" => Ok(SinkType::AppendOnly),
3752 "SINK_TYPE_FORCE_APPEND_ONLY" => Ok(SinkType::ForceAppendOnly),
3753 "SINK_TYPE_UPSERT" => Ok(SinkType::Upsert),
3754 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3755 }
3756 }
3757 }
3758 deserializer.deserialize_any(GeneratedVisitor)
3759 }
3760}
3761impl serde::Serialize for Source {
3762 #[allow(deprecated)]
3763 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3764 where
3765 S: serde::Serializer,
3766 {
3767 use serde::ser::SerializeStruct;
3768 let mut len = 0;
3769 if self.id != 0 {
3770 len += 1;
3771 }
3772 if self.schema_id != 0 {
3773 len += 1;
3774 }
3775 if self.database_id != 0 {
3776 len += 1;
3777 }
3778 if !self.name.is_empty() {
3779 len += 1;
3780 }
3781 if self.row_id_index.is_some() {
3782 len += 1;
3783 }
3784 if !self.columns.is_empty() {
3785 len += 1;
3786 }
3787 if !self.pk_column_ids.is_empty() {
3788 len += 1;
3789 }
3790 if !self.with_properties.is_empty() {
3791 len += 1;
3792 }
3793 if self.owner != 0 {
3794 len += 1;
3795 }
3796 if self.info.is_some() {
3797 len += 1;
3798 }
3799 if !self.watermark_descs.is_empty() {
3800 len += 1;
3801 }
3802 if !self.definition.is_empty() {
3803 len += 1;
3804 }
3805 if self.connection_id.is_some() {
3806 len += 1;
3807 }
3808 if self.initialized_at_epoch.is_some() {
3809 len += 1;
3810 }
3811 if self.created_at_epoch.is_some() {
3812 len += 1;
3813 }
3814 if self.initialized_at_cluster_version.is_some() {
3815 len += 1;
3816 }
3817 if self.created_at_cluster_version.is_some() {
3818 len += 1;
3819 }
3820 if !self.secret_refs.is_empty() {
3821 len += 1;
3822 }
3823 if self.version != 0 {
3824 len += 1;
3825 }
3826 if self.rate_limit.is_some() {
3827 len += 1;
3828 }
3829 if self.optional_associated_table_id.is_some() {
3830 len += 1;
3831 }
3832 let mut struct_ser = serializer.serialize_struct("catalog.Source", len)?;
3833 if self.id != 0 {
3834 struct_ser.serialize_field("id", &self.id)?;
3835 }
3836 if self.schema_id != 0 {
3837 struct_ser.serialize_field("schemaId", &self.schema_id)?;
3838 }
3839 if self.database_id != 0 {
3840 struct_ser.serialize_field("databaseId", &self.database_id)?;
3841 }
3842 if !self.name.is_empty() {
3843 struct_ser.serialize_field("name", &self.name)?;
3844 }
3845 if let Some(v) = self.row_id_index.as_ref() {
3846 struct_ser.serialize_field("rowIdIndex", v)?;
3847 }
3848 if !self.columns.is_empty() {
3849 struct_ser.serialize_field("columns", &self.columns)?;
3850 }
3851 if !self.pk_column_ids.is_empty() {
3852 struct_ser.serialize_field("pkColumnIds", &self.pk_column_ids)?;
3853 }
3854 if !self.with_properties.is_empty() {
3855 struct_ser.serialize_field("withProperties", &self.with_properties)?;
3856 }
3857 if self.owner != 0 {
3858 struct_ser.serialize_field("owner", &self.owner)?;
3859 }
3860 if let Some(v) = self.info.as_ref() {
3861 struct_ser.serialize_field("info", v)?;
3862 }
3863 if !self.watermark_descs.is_empty() {
3864 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
3865 }
3866 if !self.definition.is_empty() {
3867 struct_ser.serialize_field("definition", &self.definition)?;
3868 }
3869 if let Some(v) = self.connection_id.as_ref() {
3870 struct_ser.serialize_field("connectionId", v)?;
3871 }
3872 if let Some(v) = self.initialized_at_epoch.as_ref() {
3873 #[allow(clippy::needless_borrow)]
3874 #[allow(clippy::needless_borrows_for_generic_args)]
3875 struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
3876 }
3877 if let Some(v) = self.created_at_epoch.as_ref() {
3878 #[allow(clippy::needless_borrow)]
3879 #[allow(clippy::needless_borrows_for_generic_args)]
3880 struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
3881 }
3882 if let Some(v) = self.initialized_at_cluster_version.as_ref() {
3883 struct_ser.serialize_field("initializedAtClusterVersion", v)?;
3884 }
3885 if let Some(v) = self.created_at_cluster_version.as_ref() {
3886 struct_ser.serialize_field("createdAtClusterVersion", v)?;
3887 }
3888 if !self.secret_refs.is_empty() {
3889 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
3890 }
3891 if self.version != 0 {
3892 #[allow(clippy::needless_borrow)]
3893 #[allow(clippy::needless_borrows_for_generic_args)]
3894 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
3895 }
3896 if let Some(v) = self.rate_limit.as_ref() {
3897 struct_ser.serialize_field("rateLimit", v)?;
3898 }
3899 if let Some(v) = self.optional_associated_table_id.as_ref() {
3900 match v {
3901 source::OptionalAssociatedTableId::AssociatedTableId(v) => {
3902 struct_ser.serialize_field("associatedTableId", v)?;
3903 }
3904 }
3905 }
3906 struct_ser.end()
3907 }
3908}
3909impl<'de> serde::Deserialize<'de> for Source {
3910 #[allow(deprecated)]
3911 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3912 where
3913 D: serde::Deserializer<'de>,
3914 {
3915 const FIELDS: &[&str] = &[
3916 "id",
3917 "schema_id",
3918 "schemaId",
3919 "database_id",
3920 "databaseId",
3921 "name",
3922 "row_id_index",
3923 "rowIdIndex",
3924 "columns",
3925 "pk_column_ids",
3926 "pkColumnIds",
3927 "with_properties",
3928 "withProperties",
3929 "owner",
3930 "info",
3931 "watermark_descs",
3932 "watermarkDescs",
3933 "definition",
3934 "connection_id",
3935 "connectionId",
3936 "initialized_at_epoch",
3937 "initializedAtEpoch",
3938 "created_at_epoch",
3939 "createdAtEpoch",
3940 "initialized_at_cluster_version",
3941 "initializedAtClusterVersion",
3942 "created_at_cluster_version",
3943 "createdAtClusterVersion",
3944 "secret_refs",
3945 "secretRefs",
3946 "version",
3947 "rate_limit",
3948 "rateLimit",
3949 "associated_table_id",
3950 "associatedTableId",
3951 ];
3952
3953 #[allow(clippy::enum_variant_names)]
3954 enum GeneratedField {
3955 Id,
3956 SchemaId,
3957 DatabaseId,
3958 Name,
3959 RowIdIndex,
3960 Columns,
3961 PkColumnIds,
3962 WithProperties,
3963 Owner,
3964 Info,
3965 WatermarkDescs,
3966 Definition,
3967 ConnectionId,
3968 InitializedAtEpoch,
3969 CreatedAtEpoch,
3970 InitializedAtClusterVersion,
3971 CreatedAtClusterVersion,
3972 SecretRefs,
3973 Version,
3974 RateLimit,
3975 AssociatedTableId,
3976 }
3977 impl<'de> serde::Deserialize<'de> for GeneratedField {
3978 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3979 where
3980 D: serde::Deserializer<'de>,
3981 {
3982 struct GeneratedVisitor;
3983
3984 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3985 type Value = GeneratedField;
3986
3987 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3988 write!(formatter, "expected one of: {:?}", &FIELDS)
3989 }
3990
3991 #[allow(unused_variables)]
3992 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3993 where
3994 E: serde::de::Error,
3995 {
3996 match value {
3997 "id" => Ok(GeneratedField::Id),
3998 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
3999 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4000 "name" => Ok(GeneratedField::Name),
4001 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
4002 "columns" => Ok(GeneratedField::Columns),
4003 "pkColumnIds" | "pk_column_ids" => Ok(GeneratedField::PkColumnIds),
4004 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
4005 "owner" => Ok(GeneratedField::Owner),
4006 "info" => Ok(GeneratedField::Info),
4007 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
4008 "definition" => Ok(GeneratedField::Definition),
4009 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
4010 "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
4011 "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
4012 "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
4013 "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
4014 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
4015 "version" => Ok(GeneratedField::Version),
4016 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
4017 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
4018 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4019 }
4020 }
4021 }
4022 deserializer.deserialize_identifier(GeneratedVisitor)
4023 }
4024 }
4025 struct GeneratedVisitor;
4026 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4027 type Value = Source;
4028
4029 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4030 formatter.write_str("struct catalog.Source")
4031 }
4032
4033 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Source, V::Error>
4034 where
4035 V: serde::de::MapAccess<'de>,
4036 {
4037 let mut id__ = None;
4038 let mut schema_id__ = None;
4039 let mut database_id__ = None;
4040 let mut name__ = None;
4041 let mut row_id_index__ = None;
4042 let mut columns__ = None;
4043 let mut pk_column_ids__ = None;
4044 let mut with_properties__ = None;
4045 let mut owner__ = None;
4046 let mut info__ = None;
4047 let mut watermark_descs__ = None;
4048 let mut definition__ = None;
4049 let mut connection_id__ = None;
4050 let mut initialized_at_epoch__ = None;
4051 let mut created_at_epoch__ = None;
4052 let mut initialized_at_cluster_version__ = None;
4053 let mut created_at_cluster_version__ = None;
4054 let mut secret_refs__ = None;
4055 let mut version__ = None;
4056 let mut rate_limit__ = None;
4057 let mut optional_associated_table_id__ = None;
4058 while let Some(k) = map_.next_key()? {
4059 match k {
4060 GeneratedField::Id => {
4061 if id__.is_some() {
4062 return Err(serde::de::Error::duplicate_field("id"));
4063 }
4064 id__ =
4065 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4066 ;
4067 }
4068 GeneratedField::SchemaId => {
4069 if schema_id__.is_some() {
4070 return Err(serde::de::Error::duplicate_field("schemaId"));
4071 }
4072 schema_id__ =
4073 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4074 ;
4075 }
4076 GeneratedField::DatabaseId => {
4077 if database_id__.is_some() {
4078 return Err(serde::de::Error::duplicate_field("databaseId"));
4079 }
4080 database_id__ =
4081 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4082 ;
4083 }
4084 GeneratedField::Name => {
4085 if name__.is_some() {
4086 return Err(serde::de::Error::duplicate_field("name"));
4087 }
4088 name__ = Some(map_.next_value()?);
4089 }
4090 GeneratedField::RowIdIndex => {
4091 if row_id_index__.is_some() {
4092 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
4093 }
4094 row_id_index__ =
4095 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4096 ;
4097 }
4098 GeneratedField::Columns => {
4099 if columns__.is_some() {
4100 return Err(serde::de::Error::duplicate_field("columns"));
4101 }
4102 columns__ = Some(map_.next_value()?);
4103 }
4104 GeneratedField::PkColumnIds => {
4105 if pk_column_ids__.is_some() {
4106 return Err(serde::de::Error::duplicate_field("pkColumnIds"));
4107 }
4108 pk_column_ids__ =
4109 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4110 .into_iter().map(|x| x.0).collect())
4111 ;
4112 }
4113 GeneratedField::WithProperties => {
4114 if with_properties__.is_some() {
4115 return Err(serde::de::Error::duplicate_field("withProperties"));
4116 }
4117 with_properties__ = Some(
4118 map_.next_value::<std::collections::BTreeMap<_, _>>()?
4119 );
4120 }
4121 GeneratedField::Owner => {
4122 if owner__.is_some() {
4123 return Err(serde::de::Error::duplicate_field("owner"));
4124 }
4125 owner__ =
4126 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4127 ;
4128 }
4129 GeneratedField::Info => {
4130 if info__.is_some() {
4131 return Err(serde::de::Error::duplicate_field("info"));
4132 }
4133 info__ = map_.next_value()?;
4134 }
4135 GeneratedField::WatermarkDescs => {
4136 if watermark_descs__.is_some() {
4137 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
4138 }
4139 watermark_descs__ = Some(map_.next_value()?);
4140 }
4141 GeneratedField::Definition => {
4142 if definition__.is_some() {
4143 return Err(serde::de::Error::duplicate_field("definition"));
4144 }
4145 definition__ = Some(map_.next_value()?);
4146 }
4147 GeneratedField::ConnectionId => {
4148 if connection_id__.is_some() {
4149 return Err(serde::de::Error::duplicate_field("connectionId"));
4150 }
4151 connection_id__ =
4152 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4153 ;
4154 }
4155 GeneratedField::InitializedAtEpoch => {
4156 if initialized_at_epoch__.is_some() {
4157 return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
4158 }
4159 initialized_at_epoch__ =
4160 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4161 ;
4162 }
4163 GeneratedField::CreatedAtEpoch => {
4164 if created_at_epoch__.is_some() {
4165 return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
4166 }
4167 created_at_epoch__ =
4168 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4169 ;
4170 }
4171 GeneratedField::InitializedAtClusterVersion => {
4172 if initialized_at_cluster_version__.is_some() {
4173 return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
4174 }
4175 initialized_at_cluster_version__ = map_.next_value()?;
4176 }
4177 GeneratedField::CreatedAtClusterVersion => {
4178 if created_at_cluster_version__.is_some() {
4179 return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
4180 }
4181 created_at_cluster_version__ = map_.next_value()?;
4182 }
4183 GeneratedField::SecretRefs => {
4184 if secret_refs__.is_some() {
4185 return Err(serde::de::Error::duplicate_field("secretRefs"));
4186 }
4187 secret_refs__ = Some(
4188 map_.next_value::<std::collections::BTreeMap<_, _>>()?
4189 );
4190 }
4191 GeneratedField::Version => {
4192 if version__.is_some() {
4193 return Err(serde::de::Error::duplicate_field("version"));
4194 }
4195 version__ =
4196 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4197 ;
4198 }
4199 GeneratedField::RateLimit => {
4200 if rate_limit__.is_some() {
4201 return Err(serde::de::Error::duplicate_field("rateLimit"));
4202 }
4203 rate_limit__ =
4204 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4205 ;
4206 }
4207 GeneratedField::AssociatedTableId => {
4208 if optional_associated_table_id__.is_some() {
4209 return Err(serde::de::Error::duplicate_field("associatedTableId"));
4210 }
4211 optional_associated_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| source::OptionalAssociatedTableId::AssociatedTableId(x.0));
4212 }
4213 }
4214 }
4215 Ok(Source {
4216 id: id__.unwrap_or_default(),
4217 schema_id: schema_id__.unwrap_or_default(),
4218 database_id: database_id__.unwrap_or_default(),
4219 name: name__.unwrap_or_default(),
4220 row_id_index: row_id_index__,
4221 columns: columns__.unwrap_or_default(),
4222 pk_column_ids: pk_column_ids__.unwrap_or_default(),
4223 with_properties: with_properties__.unwrap_or_default(),
4224 owner: owner__.unwrap_or_default(),
4225 info: info__,
4226 watermark_descs: watermark_descs__.unwrap_or_default(),
4227 definition: definition__.unwrap_or_default(),
4228 connection_id: connection_id__,
4229 initialized_at_epoch: initialized_at_epoch__,
4230 created_at_epoch: created_at_epoch__,
4231 initialized_at_cluster_version: initialized_at_cluster_version__,
4232 created_at_cluster_version: created_at_cluster_version__,
4233 secret_refs: secret_refs__.unwrap_or_default(),
4234 version: version__.unwrap_or_default(),
4235 rate_limit: rate_limit__,
4236 optional_associated_table_id: optional_associated_table_id__,
4237 })
4238 }
4239 }
4240 deserializer.deserialize_struct("catalog.Source", FIELDS, GeneratedVisitor)
4241 }
4242}
4243impl serde::Serialize for StreamJobStatus {
4244 #[allow(deprecated)]
4245 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4246 where
4247 S: serde::Serializer,
4248 {
4249 let variant = match self {
4250 Self::Unspecified => "STREAM_JOB_STATUS_UNSPECIFIED",
4251 Self::Creating => "STREAM_JOB_STATUS_CREATING",
4252 Self::Created => "STREAM_JOB_STATUS_CREATED",
4253 };
4254 serializer.serialize_str(variant)
4255 }
4256}
4257impl<'de> serde::Deserialize<'de> for StreamJobStatus {
4258 #[allow(deprecated)]
4259 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4260 where
4261 D: serde::Deserializer<'de>,
4262 {
4263 const FIELDS: &[&str] = &[
4264 "STREAM_JOB_STATUS_UNSPECIFIED",
4265 "STREAM_JOB_STATUS_CREATING",
4266 "STREAM_JOB_STATUS_CREATED",
4267 ];
4268
4269 struct GeneratedVisitor;
4270
4271 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4272 type Value = StreamJobStatus;
4273
4274 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4275 write!(formatter, "expected one of: {:?}", &FIELDS)
4276 }
4277
4278 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
4279 where
4280 E: serde::de::Error,
4281 {
4282 i32::try_from(v)
4283 .ok()
4284 .and_then(|x| x.try_into().ok())
4285 .ok_or_else(|| {
4286 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
4287 })
4288 }
4289
4290 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
4291 where
4292 E: serde::de::Error,
4293 {
4294 i32::try_from(v)
4295 .ok()
4296 .and_then(|x| x.try_into().ok())
4297 .ok_or_else(|| {
4298 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
4299 })
4300 }
4301
4302 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
4303 where
4304 E: serde::de::Error,
4305 {
4306 match value {
4307 "STREAM_JOB_STATUS_UNSPECIFIED" => Ok(StreamJobStatus::Unspecified),
4308 "STREAM_JOB_STATUS_CREATING" => Ok(StreamJobStatus::Creating),
4309 "STREAM_JOB_STATUS_CREATED" => Ok(StreamJobStatus::Created),
4310 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
4311 }
4312 }
4313 }
4314 deserializer.deserialize_any(GeneratedVisitor)
4315 }
4316}
4317impl serde::Serialize for StreamSourceInfo {
4318 #[allow(deprecated)]
4319 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4320 where
4321 S: serde::Serializer,
4322 {
4323 use serde::ser::SerializeStruct;
4324 let mut len = 0;
4325 if self.row_format != 0 {
4326 len += 1;
4327 }
4328 if !self.row_schema_location.is_empty() {
4329 len += 1;
4330 }
4331 if self.use_schema_registry {
4332 len += 1;
4333 }
4334 if !self.proto_message_name.is_empty() {
4335 len += 1;
4336 }
4337 if self.csv_delimiter != 0 {
4338 len += 1;
4339 }
4340 if self.csv_has_header {
4341 len += 1;
4342 }
4343 if self.format != 0 {
4344 len += 1;
4345 }
4346 if self.row_encode != 0 {
4347 len += 1;
4348 }
4349 if self.name_strategy != 0 {
4350 len += 1;
4351 }
4352 if self.key_message_name.is_some() {
4353 len += 1;
4354 }
4355 if self.external_table.is_some() {
4356 len += 1;
4357 }
4358 if self.cdc_source_job {
4359 len += 1;
4360 }
4361 if self.is_distributed {
4362 len += 1;
4363 }
4364 if !self.format_encode_options.is_empty() {
4365 len += 1;
4366 }
4367 if !self.format_encode_secret_refs.is_empty() {
4368 len += 1;
4369 }
4370 if self.connection_id.is_some() {
4371 len += 1;
4372 }
4373 let mut struct_ser = serializer.serialize_struct("catalog.StreamSourceInfo", len)?;
4374 if self.row_format != 0 {
4375 let v = super::plan_common::RowFormatType::try_from(self.row_format)
4376 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.row_format)))?;
4377 struct_ser.serialize_field("rowFormat", &v)?;
4378 }
4379 if !self.row_schema_location.is_empty() {
4380 struct_ser.serialize_field("rowSchemaLocation", &self.row_schema_location)?;
4381 }
4382 if self.use_schema_registry {
4383 struct_ser.serialize_field("useSchemaRegistry", &self.use_schema_registry)?;
4384 }
4385 if !self.proto_message_name.is_empty() {
4386 struct_ser.serialize_field("protoMessageName", &self.proto_message_name)?;
4387 }
4388 if self.csv_delimiter != 0 {
4389 struct_ser.serialize_field("csvDelimiter", &self.csv_delimiter)?;
4390 }
4391 if self.csv_has_header {
4392 struct_ser.serialize_field("csvHasHeader", &self.csv_has_header)?;
4393 }
4394 if self.format != 0 {
4395 let v = super::plan_common::FormatType::try_from(self.format)
4396 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?;
4397 struct_ser.serialize_field("format", &v)?;
4398 }
4399 if self.row_encode != 0 {
4400 let v = super::plan_common::EncodeType::try_from(self.row_encode)
4401 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.row_encode)))?;
4402 struct_ser.serialize_field("rowEncode", &v)?;
4403 }
4404 if self.name_strategy != 0 {
4405 let v = SchemaRegistryNameStrategy::try_from(self.name_strategy)
4406 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.name_strategy)))?;
4407 struct_ser.serialize_field("nameStrategy", &v)?;
4408 }
4409 if let Some(v) = self.key_message_name.as_ref() {
4410 struct_ser.serialize_field("keyMessageName", v)?;
4411 }
4412 if let Some(v) = self.external_table.as_ref() {
4413 struct_ser.serialize_field("externalTable", v)?;
4414 }
4415 if self.cdc_source_job {
4416 struct_ser.serialize_field("cdcSourceJob", &self.cdc_source_job)?;
4417 }
4418 if self.is_distributed {
4419 struct_ser.serialize_field("isDistributed", &self.is_distributed)?;
4420 }
4421 if !self.format_encode_options.is_empty() {
4422 struct_ser.serialize_field("formatEncodeOptions", &self.format_encode_options)?;
4423 }
4424 if !self.format_encode_secret_refs.is_empty() {
4425 struct_ser.serialize_field("formatEncodeSecretRefs", &self.format_encode_secret_refs)?;
4426 }
4427 if let Some(v) = self.connection_id.as_ref() {
4428 struct_ser.serialize_field("connectionId", v)?;
4429 }
4430 struct_ser.end()
4431 }
4432}
4433impl<'de> serde::Deserialize<'de> for StreamSourceInfo {
4434 #[allow(deprecated)]
4435 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4436 where
4437 D: serde::Deserializer<'de>,
4438 {
4439 const FIELDS: &[&str] = &[
4440 "row_format",
4441 "rowFormat",
4442 "row_schema_location",
4443 "rowSchemaLocation",
4444 "use_schema_registry",
4445 "useSchemaRegistry",
4446 "proto_message_name",
4447 "protoMessageName",
4448 "csv_delimiter",
4449 "csvDelimiter",
4450 "csv_has_header",
4451 "csvHasHeader",
4452 "format",
4453 "row_encode",
4454 "rowEncode",
4455 "name_strategy",
4456 "nameStrategy",
4457 "key_message_name",
4458 "keyMessageName",
4459 "external_table",
4460 "externalTable",
4461 "cdc_source_job",
4462 "cdcSourceJob",
4463 "is_distributed",
4464 "isDistributed",
4465 "format_encode_options",
4466 "formatEncodeOptions",
4467 "format_encode_secret_refs",
4468 "formatEncodeSecretRefs",
4469 "connection_id",
4470 "connectionId",
4471 ];
4472
4473 #[allow(clippy::enum_variant_names)]
4474 enum GeneratedField {
4475 RowFormat,
4476 RowSchemaLocation,
4477 UseSchemaRegistry,
4478 ProtoMessageName,
4479 CsvDelimiter,
4480 CsvHasHeader,
4481 Format,
4482 RowEncode,
4483 NameStrategy,
4484 KeyMessageName,
4485 ExternalTable,
4486 CdcSourceJob,
4487 IsDistributed,
4488 FormatEncodeOptions,
4489 FormatEncodeSecretRefs,
4490 ConnectionId,
4491 }
4492 impl<'de> serde::Deserialize<'de> for GeneratedField {
4493 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4494 where
4495 D: serde::Deserializer<'de>,
4496 {
4497 struct GeneratedVisitor;
4498
4499 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4500 type Value = GeneratedField;
4501
4502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4503 write!(formatter, "expected one of: {:?}", &FIELDS)
4504 }
4505
4506 #[allow(unused_variables)]
4507 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4508 where
4509 E: serde::de::Error,
4510 {
4511 match value {
4512 "rowFormat" | "row_format" => Ok(GeneratedField::RowFormat),
4513 "rowSchemaLocation" | "row_schema_location" => Ok(GeneratedField::RowSchemaLocation),
4514 "useSchemaRegistry" | "use_schema_registry" => Ok(GeneratedField::UseSchemaRegistry),
4515 "protoMessageName" | "proto_message_name" => Ok(GeneratedField::ProtoMessageName),
4516 "csvDelimiter" | "csv_delimiter" => Ok(GeneratedField::CsvDelimiter),
4517 "csvHasHeader" | "csv_has_header" => Ok(GeneratedField::CsvHasHeader),
4518 "format" => Ok(GeneratedField::Format),
4519 "rowEncode" | "row_encode" => Ok(GeneratedField::RowEncode),
4520 "nameStrategy" | "name_strategy" => Ok(GeneratedField::NameStrategy),
4521 "keyMessageName" | "key_message_name" => Ok(GeneratedField::KeyMessageName),
4522 "externalTable" | "external_table" => Ok(GeneratedField::ExternalTable),
4523 "cdcSourceJob" | "cdc_source_job" => Ok(GeneratedField::CdcSourceJob),
4524 "isDistributed" | "is_distributed" => Ok(GeneratedField::IsDistributed),
4525 "formatEncodeOptions" | "format_encode_options" => Ok(GeneratedField::FormatEncodeOptions),
4526 "formatEncodeSecretRefs" | "format_encode_secret_refs" => Ok(GeneratedField::FormatEncodeSecretRefs),
4527 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
4528 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4529 }
4530 }
4531 }
4532 deserializer.deserialize_identifier(GeneratedVisitor)
4533 }
4534 }
4535 struct GeneratedVisitor;
4536 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4537 type Value = StreamSourceInfo;
4538
4539 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4540 formatter.write_str("struct catalog.StreamSourceInfo")
4541 }
4542
4543 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSourceInfo, V::Error>
4544 where
4545 V: serde::de::MapAccess<'de>,
4546 {
4547 let mut row_format__ = None;
4548 let mut row_schema_location__ = None;
4549 let mut use_schema_registry__ = None;
4550 let mut proto_message_name__ = None;
4551 let mut csv_delimiter__ = None;
4552 let mut csv_has_header__ = None;
4553 let mut format__ = None;
4554 let mut row_encode__ = None;
4555 let mut name_strategy__ = None;
4556 let mut key_message_name__ = None;
4557 let mut external_table__ = None;
4558 let mut cdc_source_job__ = None;
4559 let mut is_distributed__ = None;
4560 let mut format_encode_options__ = None;
4561 let mut format_encode_secret_refs__ = None;
4562 let mut connection_id__ = None;
4563 while let Some(k) = map_.next_key()? {
4564 match k {
4565 GeneratedField::RowFormat => {
4566 if row_format__.is_some() {
4567 return Err(serde::de::Error::duplicate_field("rowFormat"));
4568 }
4569 row_format__ = Some(map_.next_value::<super::plan_common::RowFormatType>()? as i32);
4570 }
4571 GeneratedField::RowSchemaLocation => {
4572 if row_schema_location__.is_some() {
4573 return Err(serde::de::Error::duplicate_field("rowSchemaLocation"));
4574 }
4575 row_schema_location__ = Some(map_.next_value()?);
4576 }
4577 GeneratedField::UseSchemaRegistry => {
4578 if use_schema_registry__.is_some() {
4579 return Err(serde::de::Error::duplicate_field("useSchemaRegistry"));
4580 }
4581 use_schema_registry__ = Some(map_.next_value()?);
4582 }
4583 GeneratedField::ProtoMessageName => {
4584 if proto_message_name__.is_some() {
4585 return Err(serde::de::Error::duplicate_field("protoMessageName"));
4586 }
4587 proto_message_name__ = Some(map_.next_value()?);
4588 }
4589 GeneratedField::CsvDelimiter => {
4590 if csv_delimiter__.is_some() {
4591 return Err(serde::de::Error::duplicate_field("csvDelimiter"));
4592 }
4593 csv_delimiter__ =
4594 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4595 ;
4596 }
4597 GeneratedField::CsvHasHeader => {
4598 if csv_has_header__.is_some() {
4599 return Err(serde::de::Error::duplicate_field("csvHasHeader"));
4600 }
4601 csv_has_header__ = Some(map_.next_value()?);
4602 }
4603 GeneratedField::Format => {
4604 if format__.is_some() {
4605 return Err(serde::de::Error::duplicate_field("format"));
4606 }
4607 format__ = Some(map_.next_value::<super::plan_common::FormatType>()? as i32);
4608 }
4609 GeneratedField::RowEncode => {
4610 if row_encode__.is_some() {
4611 return Err(serde::de::Error::duplicate_field("rowEncode"));
4612 }
4613 row_encode__ = Some(map_.next_value::<super::plan_common::EncodeType>()? as i32);
4614 }
4615 GeneratedField::NameStrategy => {
4616 if name_strategy__.is_some() {
4617 return Err(serde::de::Error::duplicate_field("nameStrategy"));
4618 }
4619 name_strategy__ = Some(map_.next_value::<SchemaRegistryNameStrategy>()? as i32);
4620 }
4621 GeneratedField::KeyMessageName => {
4622 if key_message_name__.is_some() {
4623 return Err(serde::de::Error::duplicate_field("keyMessageName"));
4624 }
4625 key_message_name__ = map_.next_value()?;
4626 }
4627 GeneratedField::ExternalTable => {
4628 if external_table__.is_some() {
4629 return Err(serde::de::Error::duplicate_field("externalTable"));
4630 }
4631 external_table__ = map_.next_value()?;
4632 }
4633 GeneratedField::CdcSourceJob => {
4634 if cdc_source_job__.is_some() {
4635 return Err(serde::de::Error::duplicate_field("cdcSourceJob"));
4636 }
4637 cdc_source_job__ = Some(map_.next_value()?);
4638 }
4639 GeneratedField::IsDistributed => {
4640 if is_distributed__.is_some() {
4641 return Err(serde::de::Error::duplicate_field("isDistributed"));
4642 }
4643 is_distributed__ = Some(map_.next_value()?);
4644 }
4645 GeneratedField::FormatEncodeOptions => {
4646 if format_encode_options__.is_some() {
4647 return Err(serde::de::Error::duplicate_field("formatEncodeOptions"));
4648 }
4649 format_encode_options__ = Some(
4650 map_.next_value::<std::collections::BTreeMap<_, _>>()?
4651 );
4652 }
4653 GeneratedField::FormatEncodeSecretRefs => {
4654 if format_encode_secret_refs__.is_some() {
4655 return Err(serde::de::Error::duplicate_field("formatEncodeSecretRefs"));
4656 }
4657 format_encode_secret_refs__ = Some(
4658 map_.next_value::<std::collections::BTreeMap<_, _>>()?
4659 );
4660 }
4661 GeneratedField::ConnectionId => {
4662 if connection_id__.is_some() {
4663 return Err(serde::de::Error::duplicate_field("connectionId"));
4664 }
4665 connection_id__ =
4666 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4667 ;
4668 }
4669 }
4670 }
4671 Ok(StreamSourceInfo {
4672 row_format: row_format__.unwrap_or_default(),
4673 row_schema_location: row_schema_location__.unwrap_or_default(),
4674 use_schema_registry: use_schema_registry__.unwrap_or_default(),
4675 proto_message_name: proto_message_name__.unwrap_or_default(),
4676 csv_delimiter: csv_delimiter__.unwrap_or_default(),
4677 csv_has_header: csv_has_header__.unwrap_or_default(),
4678 format: format__.unwrap_or_default(),
4679 row_encode: row_encode__.unwrap_or_default(),
4680 name_strategy: name_strategy__.unwrap_or_default(),
4681 key_message_name: key_message_name__,
4682 external_table: external_table__,
4683 cdc_source_job: cdc_source_job__.unwrap_or_default(),
4684 is_distributed: is_distributed__.unwrap_or_default(),
4685 format_encode_options: format_encode_options__.unwrap_or_default(),
4686 format_encode_secret_refs: format_encode_secret_refs__.unwrap_or_default(),
4687 connection_id: connection_id__,
4688 })
4689 }
4690 }
4691 deserializer.deserialize_struct("catalog.StreamSourceInfo", FIELDS, GeneratedVisitor)
4692 }
4693}
4694impl serde::Serialize for Subscription {
4695 #[allow(deprecated)]
4696 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4697 where
4698 S: serde::Serializer,
4699 {
4700 use serde::ser::SerializeStruct;
4701 let mut len = 0;
4702 if self.id != 0 {
4703 len += 1;
4704 }
4705 if !self.name.is_empty() {
4706 len += 1;
4707 }
4708 if !self.definition.is_empty() {
4709 len += 1;
4710 }
4711 if self.retention_seconds != 0 {
4712 len += 1;
4713 }
4714 if self.database_id != 0 {
4715 len += 1;
4716 }
4717 if self.schema_id != 0 {
4718 len += 1;
4719 }
4720 if self.dependent_table_id != 0 {
4721 len += 1;
4722 }
4723 if self.initialized_at_epoch.is_some() {
4724 len += 1;
4725 }
4726 if self.created_at_epoch.is_some() {
4727 len += 1;
4728 }
4729 if self.owner != 0 {
4730 len += 1;
4731 }
4732 if self.initialized_at_cluster_version.is_some() {
4733 len += 1;
4734 }
4735 if self.created_at_cluster_version.is_some() {
4736 len += 1;
4737 }
4738 if self.subscription_state != 0 {
4739 len += 1;
4740 }
4741 let mut struct_ser = serializer.serialize_struct("catalog.Subscription", len)?;
4742 if self.id != 0 {
4743 struct_ser.serialize_field("id", &self.id)?;
4744 }
4745 if !self.name.is_empty() {
4746 struct_ser.serialize_field("name", &self.name)?;
4747 }
4748 if !self.definition.is_empty() {
4749 struct_ser.serialize_field("definition", &self.definition)?;
4750 }
4751 if self.retention_seconds != 0 {
4752 #[allow(clippy::needless_borrow)]
4753 #[allow(clippy::needless_borrows_for_generic_args)]
4754 struct_ser.serialize_field("retentionSeconds", ToString::to_string(&self.retention_seconds).as_str())?;
4755 }
4756 if self.database_id != 0 {
4757 struct_ser.serialize_field("databaseId", &self.database_id)?;
4758 }
4759 if self.schema_id != 0 {
4760 struct_ser.serialize_field("schemaId", &self.schema_id)?;
4761 }
4762 if self.dependent_table_id != 0 {
4763 struct_ser.serialize_field("dependentTableId", &self.dependent_table_id)?;
4764 }
4765 if let Some(v) = self.initialized_at_epoch.as_ref() {
4766 #[allow(clippy::needless_borrow)]
4767 #[allow(clippy::needless_borrows_for_generic_args)]
4768 struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
4769 }
4770 if let Some(v) = self.created_at_epoch.as_ref() {
4771 #[allow(clippy::needless_borrow)]
4772 #[allow(clippy::needless_borrows_for_generic_args)]
4773 struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
4774 }
4775 if self.owner != 0 {
4776 struct_ser.serialize_field("owner", &self.owner)?;
4777 }
4778 if let Some(v) = self.initialized_at_cluster_version.as_ref() {
4779 struct_ser.serialize_field("initializedAtClusterVersion", v)?;
4780 }
4781 if let Some(v) = self.created_at_cluster_version.as_ref() {
4782 struct_ser.serialize_field("createdAtClusterVersion", v)?;
4783 }
4784 if self.subscription_state != 0 {
4785 let v = subscription::SubscriptionState::try_from(self.subscription_state)
4786 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscription_state)))?;
4787 struct_ser.serialize_field("subscriptionState", &v)?;
4788 }
4789 struct_ser.end()
4790 }
4791}
4792impl<'de> serde::Deserialize<'de> for Subscription {
4793 #[allow(deprecated)]
4794 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4795 where
4796 D: serde::Deserializer<'de>,
4797 {
4798 const FIELDS: &[&str] = &[
4799 "id",
4800 "name",
4801 "definition",
4802 "retention_seconds",
4803 "retentionSeconds",
4804 "database_id",
4805 "databaseId",
4806 "schema_id",
4807 "schemaId",
4808 "dependent_table_id",
4809 "dependentTableId",
4810 "initialized_at_epoch",
4811 "initializedAtEpoch",
4812 "created_at_epoch",
4813 "createdAtEpoch",
4814 "owner",
4815 "initialized_at_cluster_version",
4816 "initializedAtClusterVersion",
4817 "created_at_cluster_version",
4818 "createdAtClusterVersion",
4819 "subscription_state",
4820 "subscriptionState",
4821 ];
4822
4823 #[allow(clippy::enum_variant_names)]
4824 enum GeneratedField {
4825 Id,
4826 Name,
4827 Definition,
4828 RetentionSeconds,
4829 DatabaseId,
4830 SchemaId,
4831 DependentTableId,
4832 InitializedAtEpoch,
4833 CreatedAtEpoch,
4834 Owner,
4835 InitializedAtClusterVersion,
4836 CreatedAtClusterVersion,
4837 SubscriptionState,
4838 }
4839 impl<'de> serde::Deserialize<'de> for GeneratedField {
4840 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4841 where
4842 D: serde::Deserializer<'de>,
4843 {
4844 struct GeneratedVisitor;
4845
4846 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4847 type Value = GeneratedField;
4848
4849 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4850 write!(formatter, "expected one of: {:?}", &FIELDS)
4851 }
4852
4853 #[allow(unused_variables)]
4854 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4855 where
4856 E: serde::de::Error,
4857 {
4858 match value {
4859 "id" => Ok(GeneratedField::Id),
4860 "name" => Ok(GeneratedField::Name),
4861 "definition" => Ok(GeneratedField::Definition),
4862 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
4863 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4864 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
4865 "dependentTableId" | "dependent_table_id" => Ok(GeneratedField::DependentTableId),
4866 "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
4867 "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
4868 "owner" => Ok(GeneratedField::Owner),
4869 "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
4870 "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
4871 "subscriptionState" | "subscription_state" => Ok(GeneratedField::SubscriptionState),
4872 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4873 }
4874 }
4875 }
4876 deserializer.deserialize_identifier(GeneratedVisitor)
4877 }
4878 }
4879 struct GeneratedVisitor;
4880 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4881 type Value = Subscription;
4882
4883 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4884 formatter.write_str("struct catalog.Subscription")
4885 }
4886
4887 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Subscription, V::Error>
4888 where
4889 V: serde::de::MapAccess<'de>,
4890 {
4891 let mut id__ = None;
4892 let mut name__ = None;
4893 let mut definition__ = None;
4894 let mut retention_seconds__ = None;
4895 let mut database_id__ = None;
4896 let mut schema_id__ = None;
4897 let mut dependent_table_id__ = None;
4898 let mut initialized_at_epoch__ = None;
4899 let mut created_at_epoch__ = None;
4900 let mut owner__ = None;
4901 let mut initialized_at_cluster_version__ = None;
4902 let mut created_at_cluster_version__ = None;
4903 let mut subscription_state__ = None;
4904 while let Some(k) = map_.next_key()? {
4905 match k {
4906 GeneratedField::Id => {
4907 if id__.is_some() {
4908 return Err(serde::de::Error::duplicate_field("id"));
4909 }
4910 id__ =
4911 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4912 ;
4913 }
4914 GeneratedField::Name => {
4915 if name__.is_some() {
4916 return Err(serde::de::Error::duplicate_field("name"));
4917 }
4918 name__ = Some(map_.next_value()?);
4919 }
4920 GeneratedField::Definition => {
4921 if definition__.is_some() {
4922 return Err(serde::de::Error::duplicate_field("definition"));
4923 }
4924 definition__ = Some(map_.next_value()?);
4925 }
4926 GeneratedField::RetentionSeconds => {
4927 if retention_seconds__.is_some() {
4928 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
4929 }
4930 retention_seconds__ =
4931 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4932 ;
4933 }
4934 GeneratedField::DatabaseId => {
4935 if database_id__.is_some() {
4936 return Err(serde::de::Error::duplicate_field("databaseId"));
4937 }
4938 database_id__ =
4939 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4940 ;
4941 }
4942 GeneratedField::SchemaId => {
4943 if schema_id__.is_some() {
4944 return Err(serde::de::Error::duplicate_field("schemaId"));
4945 }
4946 schema_id__ =
4947 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4948 ;
4949 }
4950 GeneratedField::DependentTableId => {
4951 if dependent_table_id__.is_some() {
4952 return Err(serde::de::Error::duplicate_field("dependentTableId"));
4953 }
4954 dependent_table_id__ =
4955 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4956 ;
4957 }
4958 GeneratedField::InitializedAtEpoch => {
4959 if initialized_at_epoch__.is_some() {
4960 return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
4961 }
4962 initialized_at_epoch__ =
4963 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4964 ;
4965 }
4966 GeneratedField::CreatedAtEpoch => {
4967 if created_at_epoch__.is_some() {
4968 return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
4969 }
4970 created_at_epoch__ =
4971 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4972 ;
4973 }
4974 GeneratedField::Owner => {
4975 if owner__.is_some() {
4976 return Err(serde::de::Error::duplicate_field("owner"));
4977 }
4978 owner__ =
4979 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4980 ;
4981 }
4982 GeneratedField::InitializedAtClusterVersion => {
4983 if initialized_at_cluster_version__.is_some() {
4984 return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
4985 }
4986 initialized_at_cluster_version__ = map_.next_value()?;
4987 }
4988 GeneratedField::CreatedAtClusterVersion => {
4989 if created_at_cluster_version__.is_some() {
4990 return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
4991 }
4992 created_at_cluster_version__ = map_.next_value()?;
4993 }
4994 GeneratedField::SubscriptionState => {
4995 if subscription_state__.is_some() {
4996 return Err(serde::de::Error::duplicate_field("subscriptionState"));
4997 }
4998 subscription_state__ = Some(map_.next_value::<subscription::SubscriptionState>()? as i32);
4999 }
5000 }
5001 }
5002 Ok(Subscription {
5003 id: id__.unwrap_or_default(),
5004 name: name__.unwrap_or_default(),
5005 definition: definition__.unwrap_or_default(),
5006 retention_seconds: retention_seconds__.unwrap_or_default(),
5007 database_id: database_id__.unwrap_or_default(),
5008 schema_id: schema_id__.unwrap_or_default(),
5009 dependent_table_id: dependent_table_id__.unwrap_or_default(),
5010 initialized_at_epoch: initialized_at_epoch__,
5011 created_at_epoch: created_at_epoch__,
5012 owner: owner__.unwrap_or_default(),
5013 initialized_at_cluster_version: initialized_at_cluster_version__,
5014 created_at_cluster_version: created_at_cluster_version__,
5015 subscription_state: subscription_state__.unwrap_or_default(),
5016 })
5017 }
5018 }
5019 deserializer.deserialize_struct("catalog.Subscription", FIELDS, GeneratedVisitor)
5020 }
5021}
5022impl serde::Serialize for subscription::SubscriptionState {
5023 #[allow(deprecated)]
5024 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5025 where
5026 S: serde::Serializer,
5027 {
5028 let variant = match self {
5029 Self::Unspecified => "UNSPECIFIED",
5030 Self::Init => "INIT",
5031 Self::Created => "CREATED",
5032 };
5033 serializer.serialize_str(variant)
5034 }
5035}
5036impl<'de> serde::Deserialize<'de> for subscription::SubscriptionState {
5037 #[allow(deprecated)]
5038 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5039 where
5040 D: serde::Deserializer<'de>,
5041 {
5042 const FIELDS: &[&str] = &[
5043 "UNSPECIFIED",
5044 "INIT",
5045 "CREATED",
5046 ];
5047
5048 struct GeneratedVisitor;
5049
5050 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5051 type Value = subscription::SubscriptionState;
5052
5053 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5054 write!(formatter, "expected one of: {:?}", &FIELDS)
5055 }
5056
5057 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
5058 where
5059 E: serde::de::Error,
5060 {
5061 i32::try_from(v)
5062 .ok()
5063 .and_then(|x| x.try_into().ok())
5064 .ok_or_else(|| {
5065 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
5066 })
5067 }
5068
5069 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
5070 where
5071 E: serde::de::Error,
5072 {
5073 i32::try_from(v)
5074 .ok()
5075 .and_then(|x| x.try_into().ok())
5076 .ok_or_else(|| {
5077 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
5078 })
5079 }
5080
5081 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
5082 where
5083 E: serde::de::Error,
5084 {
5085 match value {
5086 "UNSPECIFIED" => Ok(subscription::SubscriptionState::Unspecified),
5087 "INIT" => Ok(subscription::SubscriptionState::Init),
5088 "CREATED" => Ok(subscription::SubscriptionState::Created),
5089 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
5090 }
5091 }
5092 }
5093 deserializer.deserialize_any(GeneratedVisitor)
5094 }
5095}
5096impl serde::Serialize for Table {
5097 #[allow(deprecated)]
5098 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5099 where
5100 S: serde::Serializer,
5101 {
5102 use serde::ser::SerializeStruct;
5103 let mut len = 0;
5104 if self.id != 0 {
5105 len += 1;
5106 }
5107 if self.schema_id != 0 {
5108 len += 1;
5109 }
5110 if self.database_id != 0 {
5111 len += 1;
5112 }
5113 if !self.name.is_empty() {
5114 len += 1;
5115 }
5116 if !self.columns.is_empty() {
5117 len += 1;
5118 }
5119 if !self.pk.is_empty() {
5120 len += 1;
5121 }
5122 if self.table_type != 0 {
5123 len += 1;
5124 }
5125 if !self.distribution_key.is_empty() {
5126 len += 1;
5127 }
5128 if !self.stream_key.is_empty() {
5129 len += 1;
5130 }
5131 if self.append_only {
5132 len += 1;
5133 }
5134 if self.owner != 0 {
5135 len += 1;
5136 }
5137 if self.fragment_id != 0 {
5138 len += 1;
5139 }
5140 if self.vnode_col_index.is_some() {
5141 len += 1;
5142 }
5143 if self.row_id_index.is_some() {
5144 len += 1;
5145 }
5146 if !self.value_indices.is_empty() {
5147 len += 1;
5148 }
5149 if !self.definition.is_empty() {
5150 len += 1;
5151 }
5152 if self.handle_pk_conflict_behavior != 0 {
5153 len += 1;
5154 }
5155 if self.read_prefix_len_hint != 0 {
5156 len += 1;
5157 }
5158 if !self.watermark_indices.is_empty() {
5159 len += 1;
5160 }
5161 if !self.dist_key_in_pk.is_empty() {
5162 len += 1;
5163 }
5164 if self.dml_fragment_id.is_some() {
5165 len += 1;
5166 }
5167 if self.cardinality.is_some() {
5168 len += 1;
5169 }
5170 if self.initialized_at_epoch.is_some() {
5171 len += 1;
5172 }
5173 if self.created_at_epoch.is_some() {
5174 len += 1;
5175 }
5176 if self.cleaned_by_watermark {
5177 len += 1;
5178 }
5179 if self.stream_job_status != 0 {
5180 len += 1;
5181 }
5182 if self.create_type != 0 {
5183 len += 1;
5184 }
5185 if self.description.is_some() {
5186 len += 1;
5187 }
5188 if !self.incoming_sinks.is_empty() {
5189 len += 1;
5190 }
5191 if self.initialized_at_cluster_version.is_some() {
5192 len += 1;
5193 }
5194 if self.created_at_cluster_version.is_some() {
5195 len += 1;
5196 }
5197 if self.retention_seconds.is_some() {
5198 len += 1;
5199 }
5200 if self.version_column_index.is_some() {
5201 len += 1;
5202 }
5203 if self.cdc_table_id.is_some() {
5204 len += 1;
5205 }
5206 if self.maybe_vnode_count.is_some() {
5207 len += 1;
5208 }
5209 if self.webhook_info.is_some() {
5210 len += 1;
5211 }
5212 if self.job_id.is_some() {
5213 len += 1;
5214 }
5215 if self.engine.is_some() {
5216 len += 1;
5217 }
5218 if self.clean_watermark_index_in_pk.is_some() {
5219 len += 1;
5220 }
5221 if self.version.is_some() {
5222 len += 1;
5223 }
5224 if self.optional_associated_source_id.is_some() {
5225 len += 1;
5226 }
5227 let mut struct_ser = serializer.serialize_struct("catalog.Table", len)?;
5228 if self.id != 0 {
5229 struct_ser.serialize_field("id", &self.id)?;
5230 }
5231 if self.schema_id != 0 {
5232 struct_ser.serialize_field("schemaId", &self.schema_id)?;
5233 }
5234 if self.database_id != 0 {
5235 struct_ser.serialize_field("databaseId", &self.database_id)?;
5236 }
5237 if !self.name.is_empty() {
5238 struct_ser.serialize_field("name", &self.name)?;
5239 }
5240 if !self.columns.is_empty() {
5241 struct_ser.serialize_field("columns", &self.columns)?;
5242 }
5243 if !self.pk.is_empty() {
5244 struct_ser.serialize_field("pk", &self.pk)?;
5245 }
5246 if self.table_type != 0 {
5247 let v = table::TableType::try_from(self.table_type)
5248 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.table_type)))?;
5249 struct_ser.serialize_field("tableType", &v)?;
5250 }
5251 if !self.distribution_key.is_empty() {
5252 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
5253 }
5254 if !self.stream_key.is_empty() {
5255 struct_ser.serialize_field("streamKey", &self.stream_key)?;
5256 }
5257 if self.append_only {
5258 struct_ser.serialize_field("appendOnly", &self.append_only)?;
5259 }
5260 if self.owner != 0 {
5261 struct_ser.serialize_field("owner", &self.owner)?;
5262 }
5263 if self.fragment_id != 0 {
5264 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5265 }
5266 if let Some(v) = self.vnode_col_index.as_ref() {
5267 struct_ser.serialize_field("vnodeColIndex", v)?;
5268 }
5269 if let Some(v) = self.row_id_index.as_ref() {
5270 struct_ser.serialize_field("rowIdIndex", v)?;
5271 }
5272 if !self.value_indices.is_empty() {
5273 struct_ser.serialize_field("valueIndices", &self.value_indices)?;
5274 }
5275 if !self.definition.is_empty() {
5276 struct_ser.serialize_field("definition", &self.definition)?;
5277 }
5278 if self.handle_pk_conflict_behavior != 0 {
5279 let v = HandleConflictBehavior::try_from(self.handle_pk_conflict_behavior)
5280 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.handle_pk_conflict_behavior)))?;
5281 struct_ser.serialize_field("handlePkConflictBehavior", &v)?;
5282 }
5283 if self.read_prefix_len_hint != 0 {
5284 struct_ser.serialize_field("readPrefixLenHint", &self.read_prefix_len_hint)?;
5285 }
5286 if !self.watermark_indices.is_empty() {
5287 struct_ser.serialize_field("watermarkIndices", &self.watermark_indices)?;
5288 }
5289 if !self.dist_key_in_pk.is_empty() {
5290 struct_ser.serialize_field("distKeyInPk", &self.dist_key_in_pk)?;
5291 }
5292 if let Some(v) = self.dml_fragment_id.as_ref() {
5293 struct_ser.serialize_field("dmlFragmentId", v)?;
5294 }
5295 if let Some(v) = self.cardinality.as_ref() {
5296 struct_ser.serialize_field("cardinality", v)?;
5297 }
5298 if let Some(v) = self.initialized_at_epoch.as_ref() {
5299 #[allow(clippy::needless_borrow)]
5300 #[allow(clippy::needless_borrows_for_generic_args)]
5301 struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
5302 }
5303 if let Some(v) = self.created_at_epoch.as_ref() {
5304 #[allow(clippy::needless_borrow)]
5305 #[allow(clippy::needless_borrows_for_generic_args)]
5306 struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
5307 }
5308 if self.cleaned_by_watermark {
5309 struct_ser.serialize_field("cleanedByWatermark", &self.cleaned_by_watermark)?;
5310 }
5311 if self.stream_job_status != 0 {
5312 let v = StreamJobStatus::try_from(self.stream_job_status)
5313 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_job_status)))?;
5314 struct_ser.serialize_field("streamJobStatus", &v)?;
5315 }
5316 if self.create_type != 0 {
5317 let v = CreateType::try_from(self.create_type)
5318 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.create_type)))?;
5319 struct_ser.serialize_field("createType", &v)?;
5320 }
5321 if let Some(v) = self.description.as_ref() {
5322 struct_ser.serialize_field("description", v)?;
5323 }
5324 if !self.incoming_sinks.is_empty() {
5325 struct_ser.serialize_field("incomingSinks", &self.incoming_sinks)?;
5326 }
5327 if let Some(v) = self.initialized_at_cluster_version.as_ref() {
5328 struct_ser.serialize_field("initializedAtClusterVersion", v)?;
5329 }
5330 if let Some(v) = self.created_at_cluster_version.as_ref() {
5331 struct_ser.serialize_field("createdAtClusterVersion", v)?;
5332 }
5333 if let Some(v) = self.retention_seconds.as_ref() {
5334 struct_ser.serialize_field("retentionSeconds", v)?;
5335 }
5336 if let Some(v) = self.version_column_index.as_ref() {
5337 struct_ser.serialize_field("versionColumnIndex", v)?;
5338 }
5339 if let Some(v) = self.cdc_table_id.as_ref() {
5340 struct_ser.serialize_field("cdcTableId", v)?;
5341 }
5342 if let Some(v) = self.maybe_vnode_count.as_ref() {
5343 struct_ser.serialize_field("maybeVnodeCount", v)?;
5344 }
5345 if let Some(v) = self.webhook_info.as_ref() {
5346 struct_ser.serialize_field("webhookInfo", v)?;
5347 }
5348 if let Some(v) = self.job_id.as_ref() {
5349 struct_ser.serialize_field("jobId", v)?;
5350 }
5351 if let Some(v) = self.engine.as_ref() {
5352 let v = table::Engine::try_from(*v)
5353 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
5354 struct_ser.serialize_field("engine", &v)?;
5355 }
5356 if let Some(v) = self.clean_watermark_index_in_pk.as_ref() {
5357 struct_ser.serialize_field("cleanWatermarkIndexInPk", v)?;
5358 }
5359 if let Some(v) = self.version.as_ref() {
5360 struct_ser.serialize_field("version", v)?;
5361 }
5362 if let Some(v) = self.optional_associated_source_id.as_ref() {
5363 match v {
5364 table::OptionalAssociatedSourceId::AssociatedSourceId(v) => {
5365 struct_ser.serialize_field("associatedSourceId", v)?;
5366 }
5367 }
5368 }
5369 struct_ser.end()
5370 }
5371}
5372impl<'de> serde::Deserialize<'de> for Table {
5373 #[allow(deprecated)]
5374 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5375 where
5376 D: serde::Deserializer<'de>,
5377 {
5378 const FIELDS: &[&str] = &[
5379 "id",
5380 "schema_id",
5381 "schemaId",
5382 "database_id",
5383 "databaseId",
5384 "name",
5385 "columns",
5386 "pk",
5387 "table_type",
5388 "tableType",
5389 "distribution_key",
5390 "distributionKey",
5391 "stream_key",
5392 "streamKey",
5393 "append_only",
5394 "appendOnly",
5395 "owner",
5396 "fragment_id",
5397 "fragmentId",
5398 "vnode_col_index",
5399 "vnodeColIndex",
5400 "row_id_index",
5401 "rowIdIndex",
5402 "value_indices",
5403 "valueIndices",
5404 "definition",
5405 "handle_pk_conflict_behavior",
5406 "handlePkConflictBehavior",
5407 "read_prefix_len_hint",
5408 "readPrefixLenHint",
5409 "watermark_indices",
5410 "watermarkIndices",
5411 "dist_key_in_pk",
5412 "distKeyInPk",
5413 "dml_fragment_id",
5414 "dmlFragmentId",
5415 "cardinality",
5416 "initialized_at_epoch",
5417 "initializedAtEpoch",
5418 "created_at_epoch",
5419 "createdAtEpoch",
5420 "cleaned_by_watermark",
5421 "cleanedByWatermark",
5422 "stream_job_status",
5423 "streamJobStatus",
5424 "create_type",
5425 "createType",
5426 "description",
5427 "incoming_sinks",
5428 "incomingSinks",
5429 "initialized_at_cluster_version",
5430 "initializedAtClusterVersion",
5431 "created_at_cluster_version",
5432 "createdAtClusterVersion",
5433 "retention_seconds",
5434 "retentionSeconds",
5435 "version_column_index",
5436 "versionColumnIndex",
5437 "cdc_table_id",
5438 "cdcTableId",
5439 "maybe_vnode_count",
5440 "maybeVnodeCount",
5441 "webhook_info",
5442 "webhookInfo",
5443 "job_id",
5444 "jobId",
5445 "engine",
5446 "clean_watermark_index_in_pk",
5447 "cleanWatermarkIndexInPk",
5448 "version",
5449 "associated_source_id",
5450 "associatedSourceId",
5451 ];
5452
5453 #[allow(clippy::enum_variant_names)]
5454 enum GeneratedField {
5455 Id,
5456 SchemaId,
5457 DatabaseId,
5458 Name,
5459 Columns,
5460 Pk,
5461 TableType,
5462 DistributionKey,
5463 StreamKey,
5464 AppendOnly,
5465 Owner,
5466 FragmentId,
5467 VnodeColIndex,
5468 RowIdIndex,
5469 ValueIndices,
5470 Definition,
5471 HandlePkConflictBehavior,
5472 ReadPrefixLenHint,
5473 WatermarkIndices,
5474 DistKeyInPk,
5475 DmlFragmentId,
5476 Cardinality,
5477 InitializedAtEpoch,
5478 CreatedAtEpoch,
5479 CleanedByWatermark,
5480 StreamJobStatus,
5481 CreateType,
5482 Description,
5483 IncomingSinks,
5484 InitializedAtClusterVersion,
5485 CreatedAtClusterVersion,
5486 RetentionSeconds,
5487 VersionColumnIndex,
5488 CdcTableId,
5489 MaybeVnodeCount,
5490 WebhookInfo,
5491 JobId,
5492 Engine,
5493 CleanWatermarkIndexInPk,
5494 Version,
5495 AssociatedSourceId,
5496 }
5497 impl<'de> serde::Deserialize<'de> for GeneratedField {
5498 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5499 where
5500 D: serde::Deserializer<'de>,
5501 {
5502 struct GeneratedVisitor;
5503
5504 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5505 type Value = GeneratedField;
5506
5507 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5508 write!(formatter, "expected one of: {:?}", &FIELDS)
5509 }
5510
5511 #[allow(unused_variables)]
5512 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5513 where
5514 E: serde::de::Error,
5515 {
5516 match value {
5517 "id" => Ok(GeneratedField::Id),
5518 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
5519 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
5520 "name" => Ok(GeneratedField::Name),
5521 "columns" => Ok(GeneratedField::Columns),
5522 "pk" => Ok(GeneratedField::Pk),
5523 "tableType" | "table_type" => Ok(GeneratedField::TableType),
5524 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
5525 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
5526 "appendOnly" | "append_only" => Ok(GeneratedField::AppendOnly),
5527 "owner" => Ok(GeneratedField::Owner),
5528 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5529 "vnodeColIndex" | "vnode_col_index" => Ok(GeneratedField::VnodeColIndex),
5530 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
5531 "valueIndices" | "value_indices" => Ok(GeneratedField::ValueIndices),
5532 "definition" => Ok(GeneratedField::Definition),
5533 "handlePkConflictBehavior" | "handle_pk_conflict_behavior" => Ok(GeneratedField::HandlePkConflictBehavior),
5534 "readPrefixLenHint" | "read_prefix_len_hint" => Ok(GeneratedField::ReadPrefixLenHint),
5535 "watermarkIndices" | "watermark_indices" => Ok(GeneratedField::WatermarkIndices),
5536 "distKeyInPk" | "dist_key_in_pk" => Ok(GeneratedField::DistKeyInPk),
5537 "dmlFragmentId" | "dml_fragment_id" => Ok(GeneratedField::DmlFragmentId),
5538 "cardinality" => Ok(GeneratedField::Cardinality),
5539 "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
5540 "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
5541 "cleanedByWatermark" | "cleaned_by_watermark" => Ok(GeneratedField::CleanedByWatermark),
5542 "streamJobStatus" | "stream_job_status" => Ok(GeneratedField::StreamJobStatus),
5543 "createType" | "create_type" => Ok(GeneratedField::CreateType),
5544 "description" => Ok(GeneratedField::Description),
5545 "incomingSinks" | "incoming_sinks" => Ok(GeneratedField::IncomingSinks),
5546 "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
5547 "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
5548 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
5549 "versionColumnIndex" | "version_column_index" => Ok(GeneratedField::VersionColumnIndex),
5550 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
5551 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
5552 "webhookInfo" | "webhook_info" => Ok(GeneratedField::WebhookInfo),
5553 "jobId" | "job_id" => Ok(GeneratedField::JobId),
5554 "engine" => Ok(GeneratedField::Engine),
5555 "cleanWatermarkIndexInPk" | "clean_watermark_index_in_pk" => Ok(GeneratedField::CleanWatermarkIndexInPk),
5556 "version" => Ok(GeneratedField::Version),
5557 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
5558 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5559 }
5560 }
5561 }
5562 deserializer.deserialize_identifier(GeneratedVisitor)
5563 }
5564 }
5565 struct GeneratedVisitor;
5566 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5567 type Value = Table;
5568
5569 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5570 formatter.write_str("struct catalog.Table")
5571 }
5572
5573 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Table, V::Error>
5574 where
5575 V: serde::de::MapAccess<'de>,
5576 {
5577 let mut id__ = None;
5578 let mut schema_id__ = None;
5579 let mut database_id__ = None;
5580 let mut name__ = None;
5581 let mut columns__ = None;
5582 let mut pk__ = None;
5583 let mut table_type__ = None;
5584 let mut distribution_key__ = None;
5585 let mut stream_key__ = None;
5586 let mut append_only__ = None;
5587 let mut owner__ = None;
5588 let mut fragment_id__ = None;
5589 let mut vnode_col_index__ = None;
5590 let mut row_id_index__ = None;
5591 let mut value_indices__ = None;
5592 let mut definition__ = None;
5593 let mut handle_pk_conflict_behavior__ = None;
5594 let mut read_prefix_len_hint__ = None;
5595 let mut watermark_indices__ = None;
5596 let mut dist_key_in_pk__ = None;
5597 let mut dml_fragment_id__ = None;
5598 let mut cardinality__ = None;
5599 let mut initialized_at_epoch__ = None;
5600 let mut created_at_epoch__ = None;
5601 let mut cleaned_by_watermark__ = None;
5602 let mut stream_job_status__ = None;
5603 let mut create_type__ = None;
5604 let mut description__ = None;
5605 let mut incoming_sinks__ = None;
5606 let mut initialized_at_cluster_version__ = None;
5607 let mut created_at_cluster_version__ = None;
5608 let mut retention_seconds__ = None;
5609 let mut version_column_index__ = None;
5610 let mut cdc_table_id__ = None;
5611 let mut maybe_vnode_count__ = None;
5612 let mut webhook_info__ = None;
5613 let mut job_id__ = None;
5614 let mut engine__ = None;
5615 let mut clean_watermark_index_in_pk__ = None;
5616 let mut version__ = None;
5617 let mut optional_associated_source_id__ = None;
5618 while let Some(k) = map_.next_key()? {
5619 match k {
5620 GeneratedField::Id => {
5621 if id__.is_some() {
5622 return Err(serde::de::Error::duplicate_field("id"));
5623 }
5624 id__ =
5625 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5626 ;
5627 }
5628 GeneratedField::SchemaId => {
5629 if schema_id__.is_some() {
5630 return Err(serde::de::Error::duplicate_field("schemaId"));
5631 }
5632 schema_id__ =
5633 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5634 ;
5635 }
5636 GeneratedField::DatabaseId => {
5637 if database_id__.is_some() {
5638 return Err(serde::de::Error::duplicate_field("databaseId"));
5639 }
5640 database_id__ =
5641 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5642 ;
5643 }
5644 GeneratedField::Name => {
5645 if name__.is_some() {
5646 return Err(serde::de::Error::duplicate_field("name"));
5647 }
5648 name__ = Some(map_.next_value()?);
5649 }
5650 GeneratedField::Columns => {
5651 if columns__.is_some() {
5652 return Err(serde::de::Error::duplicate_field("columns"));
5653 }
5654 columns__ = Some(map_.next_value()?);
5655 }
5656 GeneratedField::Pk => {
5657 if pk__.is_some() {
5658 return Err(serde::de::Error::duplicate_field("pk"));
5659 }
5660 pk__ = Some(map_.next_value()?);
5661 }
5662 GeneratedField::TableType => {
5663 if table_type__.is_some() {
5664 return Err(serde::de::Error::duplicate_field("tableType"));
5665 }
5666 table_type__ = Some(map_.next_value::<table::TableType>()? as i32);
5667 }
5668 GeneratedField::DistributionKey => {
5669 if distribution_key__.is_some() {
5670 return Err(serde::de::Error::duplicate_field("distributionKey"));
5671 }
5672 distribution_key__ =
5673 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5674 .into_iter().map(|x| x.0).collect())
5675 ;
5676 }
5677 GeneratedField::StreamKey => {
5678 if stream_key__.is_some() {
5679 return Err(serde::de::Error::duplicate_field("streamKey"));
5680 }
5681 stream_key__ =
5682 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5683 .into_iter().map(|x| x.0).collect())
5684 ;
5685 }
5686 GeneratedField::AppendOnly => {
5687 if append_only__.is_some() {
5688 return Err(serde::de::Error::duplicate_field("appendOnly"));
5689 }
5690 append_only__ = Some(map_.next_value()?);
5691 }
5692 GeneratedField::Owner => {
5693 if owner__.is_some() {
5694 return Err(serde::de::Error::duplicate_field("owner"));
5695 }
5696 owner__ =
5697 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5698 ;
5699 }
5700 GeneratedField::FragmentId => {
5701 if fragment_id__.is_some() {
5702 return Err(serde::de::Error::duplicate_field("fragmentId"));
5703 }
5704 fragment_id__ =
5705 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5706 ;
5707 }
5708 GeneratedField::VnodeColIndex => {
5709 if vnode_col_index__.is_some() {
5710 return Err(serde::de::Error::duplicate_field("vnodeColIndex"));
5711 }
5712 vnode_col_index__ =
5713 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5714 ;
5715 }
5716 GeneratedField::RowIdIndex => {
5717 if row_id_index__.is_some() {
5718 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
5719 }
5720 row_id_index__ =
5721 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5722 ;
5723 }
5724 GeneratedField::ValueIndices => {
5725 if value_indices__.is_some() {
5726 return Err(serde::de::Error::duplicate_field("valueIndices"));
5727 }
5728 value_indices__ =
5729 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5730 .into_iter().map(|x| x.0).collect())
5731 ;
5732 }
5733 GeneratedField::Definition => {
5734 if definition__.is_some() {
5735 return Err(serde::de::Error::duplicate_field("definition"));
5736 }
5737 definition__ = Some(map_.next_value()?);
5738 }
5739 GeneratedField::HandlePkConflictBehavior => {
5740 if handle_pk_conflict_behavior__.is_some() {
5741 return Err(serde::de::Error::duplicate_field("handlePkConflictBehavior"));
5742 }
5743 handle_pk_conflict_behavior__ = Some(map_.next_value::<HandleConflictBehavior>()? as i32);
5744 }
5745 GeneratedField::ReadPrefixLenHint => {
5746 if read_prefix_len_hint__.is_some() {
5747 return Err(serde::de::Error::duplicate_field("readPrefixLenHint"));
5748 }
5749 read_prefix_len_hint__ =
5750 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5751 ;
5752 }
5753 GeneratedField::WatermarkIndices => {
5754 if watermark_indices__.is_some() {
5755 return Err(serde::de::Error::duplicate_field("watermarkIndices"));
5756 }
5757 watermark_indices__ =
5758 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5759 .into_iter().map(|x| x.0).collect())
5760 ;
5761 }
5762 GeneratedField::DistKeyInPk => {
5763 if dist_key_in_pk__.is_some() {
5764 return Err(serde::de::Error::duplicate_field("distKeyInPk"));
5765 }
5766 dist_key_in_pk__ =
5767 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5768 .into_iter().map(|x| x.0).collect())
5769 ;
5770 }
5771 GeneratedField::DmlFragmentId => {
5772 if dml_fragment_id__.is_some() {
5773 return Err(serde::de::Error::duplicate_field("dmlFragmentId"));
5774 }
5775 dml_fragment_id__ =
5776 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5777 ;
5778 }
5779 GeneratedField::Cardinality => {
5780 if cardinality__.is_some() {
5781 return Err(serde::de::Error::duplicate_field("cardinality"));
5782 }
5783 cardinality__ = map_.next_value()?;
5784 }
5785 GeneratedField::InitializedAtEpoch => {
5786 if initialized_at_epoch__.is_some() {
5787 return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
5788 }
5789 initialized_at_epoch__ =
5790 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5791 ;
5792 }
5793 GeneratedField::CreatedAtEpoch => {
5794 if created_at_epoch__.is_some() {
5795 return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
5796 }
5797 created_at_epoch__ =
5798 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5799 ;
5800 }
5801 GeneratedField::CleanedByWatermark => {
5802 if cleaned_by_watermark__.is_some() {
5803 return Err(serde::de::Error::duplicate_field("cleanedByWatermark"));
5804 }
5805 cleaned_by_watermark__ = Some(map_.next_value()?);
5806 }
5807 GeneratedField::StreamJobStatus => {
5808 if stream_job_status__.is_some() {
5809 return Err(serde::de::Error::duplicate_field("streamJobStatus"));
5810 }
5811 stream_job_status__ = Some(map_.next_value::<StreamJobStatus>()? as i32);
5812 }
5813 GeneratedField::CreateType => {
5814 if create_type__.is_some() {
5815 return Err(serde::de::Error::duplicate_field("createType"));
5816 }
5817 create_type__ = Some(map_.next_value::<CreateType>()? as i32);
5818 }
5819 GeneratedField::Description => {
5820 if description__.is_some() {
5821 return Err(serde::de::Error::duplicate_field("description"));
5822 }
5823 description__ = map_.next_value()?;
5824 }
5825 GeneratedField::IncomingSinks => {
5826 if incoming_sinks__.is_some() {
5827 return Err(serde::de::Error::duplicate_field("incomingSinks"));
5828 }
5829 incoming_sinks__ =
5830 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5831 .into_iter().map(|x| x.0).collect())
5832 ;
5833 }
5834 GeneratedField::InitializedAtClusterVersion => {
5835 if initialized_at_cluster_version__.is_some() {
5836 return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
5837 }
5838 initialized_at_cluster_version__ = map_.next_value()?;
5839 }
5840 GeneratedField::CreatedAtClusterVersion => {
5841 if created_at_cluster_version__.is_some() {
5842 return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
5843 }
5844 created_at_cluster_version__ = map_.next_value()?;
5845 }
5846 GeneratedField::RetentionSeconds => {
5847 if retention_seconds__.is_some() {
5848 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
5849 }
5850 retention_seconds__ =
5851 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5852 ;
5853 }
5854 GeneratedField::VersionColumnIndex => {
5855 if version_column_index__.is_some() {
5856 return Err(serde::de::Error::duplicate_field("versionColumnIndex"));
5857 }
5858 version_column_index__ =
5859 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5860 ;
5861 }
5862 GeneratedField::CdcTableId => {
5863 if cdc_table_id__.is_some() {
5864 return Err(serde::de::Error::duplicate_field("cdcTableId"));
5865 }
5866 cdc_table_id__ = map_.next_value()?;
5867 }
5868 GeneratedField::MaybeVnodeCount => {
5869 if maybe_vnode_count__.is_some() {
5870 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
5871 }
5872 maybe_vnode_count__ =
5873 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5874 ;
5875 }
5876 GeneratedField::WebhookInfo => {
5877 if webhook_info__.is_some() {
5878 return Err(serde::de::Error::duplicate_field("webhookInfo"));
5879 }
5880 webhook_info__ = map_.next_value()?;
5881 }
5882 GeneratedField::JobId => {
5883 if job_id__.is_some() {
5884 return Err(serde::de::Error::duplicate_field("jobId"));
5885 }
5886 job_id__ =
5887 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5888 ;
5889 }
5890 GeneratedField::Engine => {
5891 if engine__.is_some() {
5892 return Err(serde::de::Error::duplicate_field("engine"));
5893 }
5894 engine__ = map_.next_value::<::std::option::Option<table::Engine>>()?.map(|x| x as i32);
5895 }
5896 GeneratedField::CleanWatermarkIndexInPk => {
5897 if clean_watermark_index_in_pk__.is_some() {
5898 return Err(serde::de::Error::duplicate_field("cleanWatermarkIndexInPk"));
5899 }
5900 clean_watermark_index_in_pk__ =
5901 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5902 ;
5903 }
5904 GeneratedField::Version => {
5905 if version__.is_some() {
5906 return Err(serde::de::Error::duplicate_field("version"));
5907 }
5908 version__ = map_.next_value()?;
5909 }
5910 GeneratedField::AssociatedSourceId => {
5911 if optional_associated_source_id__.is_some() {
5912 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
5913 }
5914 optional_associated_source_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| table::OptionalAssociatedSourceId::AssociatedSourceId(x.0));
5915 }
5916 }
5917 }
5918 Ok(Table {
5919 id: id__.unwrap_or_default(),
5920 schema_id: schema_id__.unwrap_or_default(),
5921 database_id: database_id__.unwrap_or_default(),
5922 name: name__.unwrap_or_default(),
5923 columns: columns__.unwrap_or_default(),
5924 pk: pk__.unwrap_or_default(),
5925 table_type: table_type__.unwrap_or_default(),
5926 distribution_key: distribution_key__.unwrap_or_default(),
5927 stream_key: stream_key__.unwrap_or_default(),
5928 append_only: append_only__.unwrap_or_default(),
5929 owner: owner__.unwrap_or_default(),
5930 fragment_id: fragment_id__.unwrap_or_default(),
5931 vnode_col_index: vnode_col_index__,
5932 row_id_index: row_id_index__,
5933 value_indices: value_indices__.unwrap_or_default(),
5934 definition: definition__.unwrap_or_default(),
5935 handle_pk_conflict_behavior: handle_pk_conflict_behavior__.unwrap_or_default(),
5936 read_prefix_len_hint: read_prefix_len_hint__.unwrap_or_default(),
5937 watermark_indices: watermark_indices__.unwrap_or_default(),
5938 dist_key_in_pk: dist_key_in_pk__.unwrap_or_default(),
5939 dml_fragment_id: dml_fragment_id__,
5940 cardinality: cardinality__,
5941 initialized_at_epoch: initialized_at_epoch__,
5942 created_at_epoch: created_at_epoch__,
5943 cleaned_by_watermark: cleaned_by_watermark__.unwrap_or_default(),
5944 stream_job_status: stream_job_status__.unwrap_or_default(),
5945 create_type: create_type__.unwrap_or_default(),
5946 description: description__,
5947 incoming_sinks: incoming_sinks__.unwrap_or_default(),
5948 initialized_at_cluster_version: initialized_at_cluster_version__,
5949 created_at_cluster_version: created_at_cluster_version__,
5950 retention_seconds: retention_seconds__,
5951 version_column_index: version_column_index__,
5952 cdc_table_id: cdc_table_id__,
5953 maybe_vnode_count: maybe_vnode_count__,
5954 webhook_info: webhook_info__,
5955 job_id: job_id__,
5956 engine: engine__,
5957 clean_watermark_index_in_pk: clean_watermark_index_in_pk__,
5958 version: version__,
5959 optional_associated_source_id: optional_associated_source_id__,
5960 })
5961 }
5962 }
5963 deserializer.deserialize_struct("catalog.Table", FIELDS, GeneratedVisitor)
5964 }
5965}
5966impl serde::Serialize for table::Engine {
5967 #[allow(deprecated)]
5968 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5969 where
5970 S: serde::Serializer,
5971 {
5972 let variant = match self {
5973 Self::Unspecified => "ENGINE_UNSPECIFIED",
5974 Self::Hummock => "HUMMOCK",
5975 Self::Iceberg => "ICEBERG",
5976 };
5977 serializer.serialize_str(variant)
5978 }
5979}
5980impl<'de> serde::Deserialize<'de> for table::Engine {
5981 #[allow(deprecated)]
5982 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5983 where
5984 D: serde::Deserializer<'de>,
5985 {
5986 const FIELDS: &[&str] = &[
5987 "ENGINE_UNSPECIFIED",
5988 "HUMMOCK",
5989 "ICEBERG",
5990 ];
5991
5992 struct GeneratedVisitor;
5993
5994 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5995 type Value = table::Engine;
5996
5997 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5998 write!(formatter, "expected one of: {:?}", &FIELDS)
5999 }
6000
6001 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6002 where
6003 E: serde::de::Error,
6004 {
6005 i32::try_from(v)
6006 .ok()
6007 .and_then(|x| x.try_into().ok())
6008 .ok_or_else(|| {
6009 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6010 })
6011 }
6012
6013 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6014 where
6015 E: serde::de::Error,
6016 {
6017 i32::try_from(v)
6018 .ok()
6019 .and_then(|x| x.try_into().ok())
6020 .ok_or_else(|| {
6021 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6022 })
6023 }
6024
6025 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6026 where
6027 E: serde::de::Error,
6028 {
6029 match value {
6030 "ENGINE_UNSPECIFIED" => Ok(table::Engine::Unspecified),
6031 "HUMMOCK" => Ok(table::Engine::Hummock),
6032 "ICEBERG" => Ok(table::Engine::Iceberg),
6033 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6034 }
6035 }
6036 }
6037 deserializer.deserialize_any(GeneratedVisitor)
6038 }
6039}
6040impl serde::Serialize for table::TableType {
6041 #[allow(deprecated)]
6042 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6043 where
6044 S: serde::Serializer,
6045 {
6046 let variant = match self {
6047 Self::Unspecified => "UNSPECIFIED",
6048 Self::Table => "TABLE",
6049 Self::MaterializedView => "MATERIALIZED_VIEW",
6050 Self::Index => "INDEX",
6051 Self::Internal => "INTERNAL",
6052 };
6053 serializer.serialize_str(variant)
6054 }
6055}
6056impl<'de> serde::Deserialize<'de> for table::TableType {
6057 #[allow(deprecated)]
6058 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6059 where
6060 D: serde::Deserializer<'de>,
6061 {
6062 const FIELDS: &[&str] = &[
6063 "UNSPECIFIED",
6064 "TABLE",
6065 "MATERIALIZED_VIEW",
6066 "INDEX",
6067 "INTERNAL",
6068 ];
6069
6070 struct GeneratedVisitor;
6071
6072 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6073 type Value = table::TableType;
6074
6075 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6076 write!(formatter, "expected one of: {:?}", &FIELDS)
6077 }
6078
6079 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6080 where
6081 E: serde::de::Error,
6082 {
6083 i32::try_from(v)
6084 .ok()
6085 .and_then(|x| x.try_into().ok())
6086 .ok_or_else(|| {
6087 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6088 })
6089 }
6090
6091 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6092 where
6093 E: serde::de::Error,
6094 {
6095 i32::try_from(v)
6096 .ok()
6097 .and_then(|x| x.try_into().ok())
6098 .ok_or_else(|| {
6099 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6100 })
6101 }
6102
6103 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6104 where
6105 E: serde::de::Error,
6106 {
6107 match value {
6108 "UNSPECIFIED" => Ok(table::TableType::Unspecified),
6109 "TABLE" => Ok(table::TableType::Table),
6110 "MATERIALIZED_VIEW" => Ok(table::TableType::MaterializedView),
6111 "INDEX" => Ok(table::TableType::Index),
6112 "INTERNAL" => Ok(table::TableType::Internal),
6113 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6114 }
6115 }
6116 }
6117 deserializer.deserialize_any(GeneratedVisitor)
6118 }
6119}
6120impl serde::Serialize for table::TableVersion {
6121 #[allow(deprecated)]
6122 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6123 where
6124 S: serde::Serializer,
6125 {
6126 use serde::ser::SerializeStruct;
6127 let mut len = 0;
6128 if self.version != 0 {
6129 len += 1;
6130 }
6131 if self.next_column_id != 0 {
6132 len += 1;
6133 }
6134 let mut struct_ser = serializer.serialize_struct("catalog.Table.TableVersion", len)?;
6135 if self.version != 0 {
6136 #[allow(clippy::needless_borrow)]
6137 #[allow(clippy::needless_borrows_for_generic_args)]
6138 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
6139 }
6140 if self.next_column_id != 0 {
6141 struct_ser.serialize_field("nextColumnId", &self.next_column_id)?;
6142 }
6143 struct_ser.end()
6144 }
6145}
6146impl<'de> serde::Deserialize<'de> for table::TableVersion {
6147 #[allow(deprecated)]
6148 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6149 where
6150 D: serde::Deserializer<'de>,
6151 {
6152 const FIELDS: &[&str] = &[
6153 "version",
6154 "next_column_id",
6155 "nextColumnId",
6156 ];
6157
6158 #[allow(clippy::enum_variant_names)]
6159 enum GeneratedField {
6160 Version,
6161 NextColumnId,
6162 }
6163 impl<'de> serde::Deserialize<'de> for GeneratedField {
6164 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6165 where
6166 D: serde::Deserializer<'de>,
6167 {
6168 struct GeneratedVisitor;
6169
6170 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6171 type Value = GeneratedField;
6172
6173 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6174 write!(formatter, "expected one of: {:?}", &FIELDS)
6175 }
6176
6177 #[allow(unused_variables)]
6178 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6179 where
6180 E: serde::de::Error,
6181 {
6182 match value {
6183 "version" => Ok(GeneratedField::Version),
6184 "nextColumnId" | "next_column_id" => Ok(GeneratedField::NextColumnId),
6185 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6186 }
6187 }
6188 }
6189 deserializer.deserialize_identifier(GeneratedVisitor)
6190 }
6191 }
6192 struct GeneratedVisitor;
6193 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6194 type Value = table::TableVersion;
6195
6196 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6197 formatter.write_str("struct catalog.Table.TableVersion")
6198 }
6199
6200 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table::TableVersion, V::Error>
6201 where
6202 V: serde::de::MapAccess<'de>,
6203 {
6204 let mut version__ = None;
6205 let mut next_column_id__ = None;
6206 while let Some(k) = map_.next_key()? {
6207 match k {
6208 GeneratedField::Version => {
6209 if version__.is_some() {
6210 return Err(serde::de::Error::duplicate_field("version"));
6211 }
6212 version__ =
6213 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6214 ;
6215 }
6216 GeneratedField::NextColumnId => {
6217 if next_column_id__.is_some() {
6218 return Err(serde::de::Error::duplicate_field("nextColumnId"));
6219 }
6220 next_column_id__ =
6221 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6222 ;
6223 }
6224 }
6225 }
6226 Ok(table::TableVersion {
6227 version: version__.unwrap_or_default(),
6228 next_column_id: next_column_id__.unwrap_or_default(),
6229 })
6230 }
6231 }
6232 deserializer.deserialize_struct("catalog.Table.TableVersion", FIELDS, GeneratedVisitor)
6233 }
6234}
6235impl serde::Serialize for View {
6236 #[allow(deprecated)]
6237 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6238 where
6239 S: serde::Serializer,
6240 {
6241 use serde::ser::SerializeStruct;
6242 let mut len = 0;
6243 if self.id != 0 {
6244 len += 1;
6245 }
6246 if self.schema_id != 0 {
6247 len += 1;
6248 }
6249 if self.database_id != 0 {
6250 len += 1;
6251 }
6252 if !self.name.is_empty() {
6253 len += 1;
6254 }
6255 if self.owner != 0 {
6256 len += 1;
6257 }
6258 if !self.properties.is_empty() {
6259 len += 1;
6260 }
6261 if !self.sql.is_empty() {
6262 len += 1;
6263 }
6264 if !self.columns.is_empty() {
6265 len += 1;
6266 }
6267 let mut struct_ser = serializer.serialize_struct("catalog.View", len)?;
6268 if self.id != 0 {
6269 struct_ser.serialize_field("id", &self.id)?;
6270 }
6271 if self.schema_id != 0 {
6272 struct_ser.serialize_field("schemaId", &self.schema_id)?;
6273 }
6274 if self.database_id != 0 {
6275 struct_ser.serialize_field("databaseId", &self.database_id)?;
6276 }
6277 if !self.name.is_empty() {
6278 struct_ser.serialize_field("name", &self.name)?;
6279 }
6280 if self.owner != 0 {
6281 struct_ser.serialize_field("owner", &self.owner)?;
6282 }
6283 if !self.properties.is_empty() {
6284 struct_ser.serialize_field("properties", &self.properties)?;
6285 }
6286 if !self.sql.is_empty() {
6287 struct_ser.serialize_field("sql", &self.sql)?;
6288 }
6289 if !self.columns.is_empty() {
6290 struct_ser.serialize_field("columns", &self.columns)?;
6291 }
6292 struct_ser.end()
6293 }
6294}
6295impl<'de> serde::Deserialize<'de> for View {
6296 #[allow(deprecated)]
6297 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6298 where
6299 D: serde::Deserializer<'de>,
6300 {
6301 const FIELDS: &[&str] = &[
6302 "id",
6303 "schema_id",
6304 "schemaId",
6305 "database_id",
6306 "databaseId",
6307 "name",
6308 "owner",
6309 "properties",
6310 "sql",
6311 "columns",
6312 ];
6313
6314 #[allow(clippy::enum_variant_names)]
6315 enum GeneratedField {
6316 Id,
6317 SchemaId,
6318 DatabaseId,
6319 Name,
6320 Owner,
6321 Properties,
6322 Sql,
6323 Columns,
6324 }
6325 impl<'de> serde::Deserialize<'de> for GeneratedField {
6326 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6327 where
6328 D: serde::Deserializer<'de>,
6329 {
6330 struct GeneratedVisitor;
6331
6332 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6333 type Value = GeneratedField;
6334
6335 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6336 write!(formatter, "expected one of: {:?}", &FIELDS)
6337 }
6338
6339 #[allow(unused_variables)]
6340 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6341 where
6342 E: serde::de::Error,
6343 {
6344 match value {
6345 "id" => Ok(GeneratedField::Id),
6346 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
6347 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
6348 "name" => Ok(GeneratedField::Name),
6349 "owner" => Ok(GeneratedField::Owner),
6350 "properties" => Ok(GeneratedField::Properties),
6351 "sql" => Ok(GeneratedField::Sql),
6352 "columns" => Ok(GeneratedField::Columns),
6353 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6354 }
6355 }
6356 }
6357 deserializer.deserialize_identifier(GeneratedVisitor)
6358 }
6359 }
6360 struct GeneratedVisitor;
6361 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6362 type Value = View;
6363
6364 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6365 formatter.write_str("struct catalog.View")
6366 }
6367
6368 fn visit_map<V>(self, mut map_: V) -> std::result::Result<View, V::Error>
6369 where
6370 V: serde::de::MapAccess<'de>,
6371 {
6372 let mut id__ = None;
6373 let mut schema_id__ = None;
6374 let mut database_id__ = None;
6375 let mut name__ = None;
6376 let mut owner__ = None;
6377 let mut properties__ = None;
6378 let mut sql__ = None;
6379 let mut columns__ = None;
6380 while let Some(k) = map_.next_key()? {
6381 match k {
6382 GeneratedField::Id => {
6383 if id__.is_some() {
6384 return Err(serde::de::Error::duplicate_field("id"));
6385 }
6386 id__ =
6387 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6388 ;
6389 }
6390 GeneratedField::SchemaId => {
6391 if schema_id__.is_some() {
6392 return Err(serde::de::Error::duplicate_field("schemaId"));
6393 }
6394 schema_id__ =
6395 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6396 ;
6397 }
6398 GeneratedField::DatabaseId => {
6399 if database_id__.is_some() {
6400 return Err(serde::de::Error::duplicate_field("databaseId"));
6401 }
6402 database_id__ =
6403 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6404 ;
6405 }
6406 GeneratedField::Name => {
6407 if name__.is_some() {
6408 return Err(serde::de::Error::duplicate_field("name"));
6409 }
6410 name__ = Some(map_.next_value()?);
6411 }
6412 GeneratedField::Owner => {
6413 if owner__.is_some() {
6414 return Err(serde::de::Error::duplicate_field("owner"));
6415 }
6416 owner__ =
6417 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6418 ;
6419 }
6420 GeneratedField::Properties => {
6421 if properties__.is_some() {
6422 return Err(serde::de::Error::duplicate_field("properties"));
6423 }
6424 properties__ = Some(
6425 map_.next_value::<std::collections::BTreeMap<_, _>>()?
6426 );
6427 }
6428 GeneratedField::Sql => {
6429 if sql__.is_some() {
6430 return Err(serde::de::Error::duplicate_field("sql"));
6431 }
6432 sql__ = Some(map_.next_value()?);
6433 }
6434 GeneratedField::Columns => {
6435 if columns__.is_some() {
6436 return Err(serde::de::Error::duplicate_field("columns"));
6437 }
6438 columns__ = Some(map_.next_value()?);
6439 }
6440 }
6441 }
6442 Ok(View {
6443 id: id__.unwrap_or_default(),
6444 schema_id: schema_id__.unwrap_or_default(),
6445 database_id: database_id__.unwrap_or_default(),
6446 name: name__.unwrap_or_default(),
6447 owner: owner__.unwrap_or_default(),
6448 properties: properties__.unwrap_or_default(),
6449 sql: sql__.unwrap_or_default(),
6450 columns: columns__.unwrap_or_default(),
6451 })
6452 }
6453 }
6454 deserializer.deserialize_struct("catalog.View", FIELDS, GeneratedVisitor)
6455 }
6456}
6457impl serde::Serialize for WatermarkDesc {
6458 #[allow(deprecated)]
6459 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6460 where
6461 S: serde::Serializer,
6462 {
6463 use serde::ser::SerializeStruct;
6464 let mut len = 0;
6465 if self.watermark_idx != 0 {
6466 len += 1;
6467 }
6468 if self.expr.is_some() {
6469 len += 1;
6470 }
6471 let mut struct_ser = serializer.serialize_struct("catalog.WatermarkDesc", len)?;
6472 if self.watermark_idx != 0 {
6473 struct_ser.serialize_field("watermarkIdx", &self.watermark_idx)?;
6474 }
6475 if let Some(v) = self.expr.as_ref() {
6476 struct_ser.serialize_field("expr", v)?;
6477 }
6478 struct_ser.end()
6479 }
6480}
6481impl<'de> serde::Deserialize<'de> for WatermarkDesc {
6482 #[allow(deprecated)]
6483 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6484 where
6485 D: serde::Deserializer<'de>,
6486 {
6487 const FIELDS: &[&str] = &[
6488 "watermark_idx",
6489 "watermarkIdx",
6490 "expr",
6491 ];
6492
6493 #[allow(clippy::enum_variant_names)]
6494 enum GeneratedField {
6495 WatermarkIdx,
6496 Expr,
6497 }
6498 impl<'de> serde::Deserialize<'de> for GeneratedField {
6499 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6500 where
6501 D: serde::Deserializer<'de>,
6502 {
6503 struct GeneratedVisitor;
6504
6505 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6506 type Value = GeneratedField;
6507
6508 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6509 write!(formatter, "expected one of: {:?}", &FIELDS)
6510 }
6511
6512 #[allow(unused_variables)]
6513 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6514 where
6515 E: serde::de::Error,
6516 {
6517 match value {
6518 "watermarkIdx" | "watermark_idx" => Ok(GeneratedField::WatermarkIdx),
6519 "expr" => Ok(GeneratedField::Expr),
6520 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6521 }
6522 }
6523 }
6524 deserializer.deserialize_identifier(GeneratedVisitor)
6525 }
6526 }
6527 struct GeneratedVisitor;
6528 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6529 type Value = WatermarkDesc;
6530
6531 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6532 formatter.write_str("struct catalog.WatermarkDesc")
6533 }
6534
6535 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkDesc, V::Error>
6536 where
6537 V: serde::de::MapAccess<'de>,
6538 {
6539 let mut watermark_idx__ = None;
6540 let mut expr__ = None;
6541 while let Some(k) = map_.next_key()? {
6542 match k {
6543 GeneratedField::WatermarkIdx => {
6544 if watermark_idx__.is_some() {
6545 return Err(serde::de::Error::duplicate_field("watermarkIdx"));
6546 }
6547 watermark_idx__ =
6548 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6549 ;
6550 }
6551 GeneratedField::Expr => {
6552 if expr__.is_some() {
6553 return Err(serde::de::Error::duplicate_field("expr"));
6554 }
6555 expr__ = map_.next_value()?;
6556 }
6557 }
6558 }
6559 Ok(WatermarkDesc {
6560 watermark_idx: watermark_idx__.unwrap_or_default(),
6561 expr: expr__,
6562 })
6563 }
6564 }
6565 deserializer.deserialize_struct("catalog.WatermarkDesc", FIELDS, GeneratedVisitor)
6566 }
6567}
6568impl serde::Serialize for WebhookSourceInfo {
6569 #[allow(deprecated)]
6570 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6571 where
6572 S: serde::Serializer,
6573 {
6574 use serde::ser::SerializeStruct;
6575 let mut len = 0;
6576 if self.secret_ref.is_some() {
6577 len += 1;
6578 }
6579 if self.signature_expr.is_some() {
6580 len += 1;
6581 }
6582 if self.wait_for_persistence {
6583 len += 1;
6584 }
6585 if self.is_batched {
6586 len += 1;
6587 }
6588 let mut struct_ser = serializer.serialize_struct("catalog.WebhookSourceInfo", len)?;
6589 if let Some(v) = self.secret_ref.as_ref() {
6590 struct_ser.serialize_field("secretRef", v)?;
6591 }
6592 if let Some(v) = self.signature_expr.as_ref() {
6593 struct_ser.serialize_field("signatureExpr", v)?;
6594 }
6595 if self.wait_for_persistence {
6596 struct_ser.serialize_field("waitForPersistence", &self.wait_for_persistence)?;
6597 }
6598 if self.is_batched {
6599 struct_ser.serialize_field("isBatched", &self.is_batched)?;
6600 }
6601 struct_ser.end()
6602 }
6603}
6604impl<'de> serde::Deserialize<'de> for WebhookSourceInfo {
6605 #[allow(deprecated)]
6606 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6607 where
6608 D: serde::Deserializer<'de>,
6609 {
6610 const FIELDS: &[&str] = &[
6611 "secret_ref",
6612 "secretRef",
6613 "signature_expr",
6614 "signatureExpr",
6615 "wait_for_persistence",
6616 "waitForPersistence",
6617 "is_batched",
6618 "isBatched",
6619 ];
6620
6621 #[allow(clippy::enum_variant_names)]
6622 enum GeneratedField {
6623 SecretRef,
6624 SignatureExpr,
6625 WaitForPersistence,
6626 IsBatched,
6627 }
6628 impl<'de> serde::Deserialize<'de> for GeneratedField {
6629 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6630 where
6631 D: serde::Deserializer<'de>,
6632 {
6633 struct GeneratedVisitor;
6634
6635 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6636 type Value = GeneratedField;
6637
6638 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6639 write!(formatter, "expected one of: {:?}", &FIELDS)
6640 }
6641
6642 #[allow(unused_variables)]
6643 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6644 where
6645 E: serde::de::Error,
6646 {
6647 match value {
6648 "secretRef" | "secret_ref" => Ok(GeneratedField::SecretRef),
6649 "signatureExpr" | "signature_expr" => Ok(GeneratedField::SignatureExpr),
6650 "waitForPersistence" | "wait_for_persistence" => Ok(GeneratedField::WaitForPersistence),
6651 "isBatched" | "is_batched" => Ok(GeneratedField::IsBatched),
6652 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6653 }
6654 }
6655 }
6656 deserializer.deserialize_identifier(GeneratedVisitor)
6657 }
6658 }
6659 struct GeneratedVisitor;
6660 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6661 type Value = WebhookSourceInfo;
6662
6663 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6664 formatter.write_str("struct catalog.WebhookSourceInfo")
6665 }
6666
6667 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WebhookSourceInfo, V::Error>
6668 where
6669 V: serde::de::MapAccess<'de>,
6670 {
6671 let mut secret_ref__ = None;
6672 let mut signature_expr__ = None;
6673 let mut wait_for_persistence__ = None;
6674 let mut is_batched__ = None;
6675 while let Some(k) = map_.next_key()? {
6676 match k {
6677 GeneratedField::SecretRef => {
6678 if secret_ref__.is_some() {
6679 return Err(serde::de::Error::duplicate_field("secretRef"));
6680 }
6681 secret_ref__ = map_.next_value()?;
6682 }
6683 GeneratedField::SignatureExpr => {
6684 if signature_expr__.is_some() {
6685 return Err(serde::de::Error::duplicate_field("signatureExpr"));
6686 }
6687 signature_expr__ = map_.next_value()?;
6688 }
6689 GeneratedField::WaitForPersistence => {
6690 if wait_for_persistence__.is_some() {
6691 return Err(serde::de::Error::duplicate_field("waitForPersistence"));
6692 }
6693 wait_for_persistence__ = Some(map_.next_value()?);
6694 }
6695 GeneratedField::IsBatched => {
6696 if is_batched__.is_some() {
6697 return Err(serde::de::Error::duplicate_field("isBatched"));
6698 }
6699 is_batched__ = Some(map_.next_value()?);
6700 }
6701 }
6702 }
6703 Ok(WebhookSourceInfo {
6704 secret_ref: secret_ref__,
6705 signature_expr: signature_expr__,
6706 wait_for_persistence: wait_for_persistence__.unwrap_or_default(),
6707 is_batched: is_batched__.unwrap_or_default(),
6708 })
6709 }
6710 }
6711 deserializer.deserialize_struct("catalog.WebhookSourceInfo", FIELDS, GeneratedVisitor)
6712 }
6713}