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