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