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