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