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