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 RefreshState {
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 let variant = match self {
2797 Self::Unspecified => "REFRESH_STATE_UNSPECIFIED",
2798 Self::Idle => "REFRESH_STATE_IDLE",
2799 Self::Refreshing => "REFRESH_STATE_REFRESHING",
2800 Self::Finishing => "REFRESH_STATE_FINISHING",
2801 };
2802 serializer.serialize_str(variant)
2803 }
2804}
2805impl<'de> serde::Deserialize<'de> for RefreshState {
2806 #[allow(deprecated)]
2807 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2808 where
2809 D: serde::Deserializer<'de>,
2810 {
2811 const FIELDS: &[&str] = &[
2812 "REFRESH_STATE_UNSPECIFIED",
2813 "REFRESH_STATE_IDLE",
2814 "REFRESH_STATE_REFRESHING",
2815 "REFRESH_STATE_FINISHING",
2816 ];
2817
2818 struct GeneratedVisitor;
2819
2820 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2821 type Value = RefreshState;
2822
2823 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2824 write!(formatter, "expected one of: {:?}", &FIELDS)
2825 }
2826
2827 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2828 where
2829 E: serde::de::Error,
2830 {
2831 i32::try_from(v)
2832 .ok()
2833 .and_then(|x| x.try_into().ok())
2834 .ok_or_else(|| {
2835 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2836 })
2837 }
2838
2839 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2840 where
2841 E: serde::de::Error,
2842 {
2843 i32::try_from(v)
2844 .ok()
2845 .and_then(|x| x.try_into().ok())
2846 .ok_or_else(|| {
2847 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2848 })
2849 }
2850
2851 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2852 where
2853 E: serde::de::Error,
2854 {
2855 match value {
2856 "REFRESH_STATE_UNSPECIFIED" => Ok(RefreshState::Unspecified),
2857 "REFRESH_STATE_IDLE" => Ok(RefreshState::Idle),
2858 "REFRESH_STATE_REFRESHING" => Ok(RefreshState::Refreshing),
2859 "REFRESH_STATE_FINISHING" => Ok(RefreshState::Finishing),
2860 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2861 }
2862 }
2863 }
2864 deserializer.deserialize_any(GeneratedVisitor)
2865 }
2866}
2867impl serde::Serialize for Schema {
2868 #[allow(deprecated)]
2869 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2870 where
2871 S: serde::Serializer,
2872 {
2873 use serde::ser::SerializeStruct;
2874 let mut len = 0;
2875 if self.id != 0 {
2876 len += 1;
2877 }
2878 if self.database_id != 0 {
2879 len += 1;
2880 }
2881 if !self.name.is_empty() {
2882 len += 1;
2883 }
2884 if self.owner != 0 {
2885 len += 1;
2886 }
2887 let mut struct_ser = serializer.serialize_struct("catalog.Schema", len)?;
2888 if self.id != 0 {
2889 struct_ser.serialize_field("id", &self.id)?;
2890 }
2891 if self.database_id != 0 {
2892 struct_ser.serialize_field("databaseId", &self.database_id)?;
2893 }
2894 if !self.name.is_empty() {
2895 struct_ser.serialize_field("name", &self.name)?;
2896 }
2897 if self.owner != 0 {
2898 struct_ser.serialize_field("owner", &self.owner)?;
2899 }
2900 struct_ser.end()
2901 }
2902}
2903impl<'de> serde::Deserialize<'de> for Schema {
2904 #[allow(deprecated)]
2905 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2906 where
2907 D: serde::Deserializer<'de>,
2908 {
2909 const FIELDS: &[&str] = &[
2910 "id",
2911 "database_id",
2912 "databaseId",
2913 "name",
2914 "owner",
2915 ];
2916
2917 #[allow(clippy::enum_variant_names)]
2918 enum GeneratedField {
2919 Id,
2920 DatabaseId,
2921 Name,
2922 Owner,
2923 }
2924 impl<'de> serde::Deserialize<'de> for GeneratedField {
2925 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2926 where
2927 D: serde::Deserializer<'de>,
2928 {
2929 struct GeneratedVisitor;
2930
2931 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2932 type Value = GeneratedField;
2933
2934 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2935 write!(formatter, "expected one of: {:?}", &FIELDS)
2936 }
2937
2938 #[allow(unused_variables)]
2939 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2940 where
2941 E: serde::de::Error,
2942 {
2943 match value {
2944 "id" => Ok(GeneratedField::Id),
2945 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
2946 "name" => Ok(GeneratedField::Name),
2947 "owner" => Ok(GeneratedField::Owner),
2948 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2949 }
2950 }
2951 }
2952 deserializer.deserialize_identifier(GeneratedVisitor)
2953 }
2954 }
2955 struct GeneratedVisitor;
2956 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2957 type Value = Schema;
2958
2959 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2960 formatter.write_str("struct catalog.Schema")
2961 }
2962
2963 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Schema, V::Error>
2964 where
2965 V: serde::de::MapAccess<'de>,
2966 {
2967 let mut id__ = None;
2968 let mut database_id__ = None;
2969 let mut name__ = None;
2970 let mut owner__ = None;
2971 while let Some(k) = map_.next_key()? {
2972 match k {
2973 GeneratedField::Id => {
2974 if id__.is_some() {
2975 return Err(serde::de::Error::duplicate_field("id"));
2976 }
2977 id__ =
2978 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2979 ;
2980 }
2981 GeneratedField::DatabaseId => {
2982 if database_id__.is_some() {
2983 return Err(serde::de::Error::duplicate_field("databaseId"));
2984 }
2985 database_id__ =
2986 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2987 ;
2988 }
2989 GeneratedField::Name => {
2990 if name__.is_some() {
2991 return Err(serde::de::Error::duplicate_field("name"));
2992 }
2993 name__ = Some(map_.next_value()?);
2994 }
2995 GeneratedField::Owner => {
2996 if owner__.is_some() {
2997 return Err(serde::de::Error::duplicate_field("owner"));
2998 }
2999 owner__ =
3000 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3001 ;
3002 }
3003 }
3004 }
3005 Ok(Schema {
3006 id: id__.unwrap_or_default(),
3007 database_id: database_id__.unwrap_or_default(),
3008 name: name__.unwrap_or_default(),
3009 owner: owner__.unwrap_or_default(),
3010 })
3011 }
3012 }
3013 deserializer.deserialize_struct("catalog.Schema", FIELDS, GeneratedVisitor)
3014 }
3015}
3016impl serde::Serialize for SchemaRegistryNameStrategy {
3017 #[allow(deprecated)]
3018 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3019 where
3020 S: serde::Serializer,
3021 {
3022 let variant = match self {
3023 Self::Unspecified => "SCHEMA_REGISTRY_NAME_STRATEGY_UNSPECIFIED",
3024 Self::RecordNameStrategy => "SCHEMA_REGISTRY_NAME_STRATEGY_RECORD_NAME_STRATEGY",
3025 Self::TopicRecordNameStrategy => "SCHEMA_REGISTRY_NAME_STRATEGY_TOPIC_RECORD_NAME_STRATEGY",
3026 };
3027 serializer.serialize_str(variant)
3028 }
3029}
3030impl<'de> serde::Deserialize<'de> for SchemaRegistryNameStrategy {
3031 #[allow(deprecated)]
3032 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3033 where
3034 D: serde::Deserializer<'de>,
3035 {
3036 const FIELDS: &[&str] = &[
3037 "SCHEMA_REGISTRY_NAME_STRATEGY_UNSPECIFIED",
3038 "SCHEMA_REGISTRY_NAME_STRATEGY_RECORD_NAME_STRATEGY",
3039 "SCHEMA_REGISTRY_NAME_STRATEGY_TOPIC_RECORD_NAME_STRATEGY",
3040 ];
3041
3042 struct GeneratedVisitor;
3043
3044 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3045 type Value = SchemaRegistryNameStrategy;
3046
3047 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3048 write!(formatter, "expected one of: {:?}", &FIELDS)
3049 }
3050
3051 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3052 where
3053 E: serde::de::Error,
3054 {
3055 i32::try_from(v)
3056 .ok()
3057 .and_then(|x| x.try_into().ok())
3058 .ok_or_else(|| {
3059 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3060 })
3061 }
3062
3063 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3064 where
3065 E: serde::de::Error,
3066 {
3067 i32::try_from(v)
3068 .ok()
3069 .and_then(|x| x.try_into().ok())
3070 .ok_or_else(|| {
3071 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3072 })
3073 }
3074
3075 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3076 where
3077 E: serde::de::Error,
3078 {
3079 match value {
3080 "SCHEMA_REGISTRY_NAME_STRATEGY_UNSPECIFIED" => Ok(SchemaRegistryNameStrategy::Unspecified),
3081 "SCHEMA_REGISTRY_NAME_STRATEGY_RECORD_NAME_STRATEGY" => Ok(SchemaRegistryNameStrategy::RecordNameStrategy),
3082 "SCHEMA_REGISTRY_NAME_STRATEGY_TOPIC_RECORD_NAME_STRATEGY" => Ok(SchemaRegistryNameStrategy::TopicRecordNameStrategy),
3083 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3084 }
3085 }
3086 }
3087 deserializer.deserialize_any(GeneratedVisitor)
3088 }
3089}
3090impl serde::Serialize for Secret {
3091 #[allow(deprecated)]
3092 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3093 where
3094 S: serde::Serializer,
3095 {
3096 use serde::ser::SerializeStruct;
3097 let mut len = 0;
3098 if self.id != 0 {
3099 len += 1;
3100 }
3101 if !self.name.is_empty() {
3102 len += 1;
3103 }
3104 if self.database_id != 0 {
3105 len += 1;
3106 }
3107 if !self.value.is_empty() {
3108 len += 1;
3109 }
3110 if self.owner != 0 {
3111 len += 1;
3112 }
3113 if self.schema_id != 0 {
3114 len += 1;
3115 }
3116 let mut struct_ser = serializer.serialize_struct("catalog.Secret", len)?;
3117 if self.id != 0 {
3118 struct_ser.serialize_field("id", &self.id)?;
3119 }
3120 if !self.name.is_empty() {
3121 struct_ser.serialize_field("name", &self.name)?;
3122 }
3123 if self.database_id != 0 {
3124 struct_ser.serialize_field("databaseId", &self.database_id)?;
3125 }
3126 if !self.value.is_empty() {
3127 #[allow(clippy::needless_borrow)]
3128 #[allow(clippy::needless_borrows_for_generic_args)]
3129 struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
3130 }
3131 if self.owner != 0 {
3132 struct_ser.serialize_field("owner", &self.owner)?;
3133 }
3134 if self.schema_id != 0 {
3135 struct_ser.serialize_field("schemaId", &self.schema_id)?;
3136 }
3137 struct_ser.end()
3138 }
3139}
3140impl<'de> serde::Deserialize<'de> for Secret {
3141 #[allow(deprecated)]
3142 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3143 where
3144 D: serde::Deserializer<'de>,
3145 {
3146 const FIELDS: &[&str] = &[
3147 "id",
3148 "name",
3149 "database_id",
3150 "databaseId",
3151 "value",
3152 "owner",
3153 "schema_id",
3154 "schemaId",
3155 ];
3156
3157 #[allow(clippy::enum_variant_names)]
3158 enum GeneratedField {
3159 Id,
3160 Name,
3161 DatabaseId,
3162 Value,
3163 Owner,
3164 SchemaId,
3165 }
3166 impl<'de> serde::Deserialize<'de> for GeneratedField {
3167 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3168 where
3169 D: serde::Deserializer<'de>,
3170 {
3171 struct GeneratedVisitor;
3172
3173 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3174 type Value = GeneratedField;
3175
3176 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3177 write!(formatter, "expected one of: {:?}", &FIELDS)
3178 }
3179
3180 #[allow(unused_variables)]
3181 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3182 where
3183 E: serde::de::Error,
3184 {
3185 match value {
3186 "id" => Ok(GeneratedField::Id),
3187 "name" => Ok(GeneratedField::Name),
3188 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
3189 "value" => Ok(GeneratedField::Value),
3190 "owner" => Ok(GeneratedField::Owner),
3191 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
3192 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3193 }
3194 }
3195 }
3196 deserializer.deserialize_identifier(GeneratedVisitor)
3197 }
3198 }
3199 struct GeneratedVisitor;
3200 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3201 type Value = Secret;
3202
3203 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3204 formatter.write_str("struct catalog.Secret")
3205 }
3206
3207 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Secret, V::Error>
3208 where
3209 V: serde::de::MapAccess<'de>,
3210 {
3211 let mut id__ = None;
3212 let mut name__ = None;
3213 let mut database_id__ = None;
3214 let mut value__ = None;
3215 let mut owner__ = None;
3216 let mut schema_id__ = None;
3217 while let Some(k) = map_.next_key()? {
3218 match k {
3219 GeneratedField::Id => {
3220 if id__.is_some() {
3221 return Err(serde::de::Error::duplicate_field("id"));
3222 }
3223 id__ =
3224 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3225 ;
3226 }
3227 GeneratedField::Name => {
3228 if name__.is_some() {
3229 return Err(serde::de::Error::duplicate_field("name"));
3230 }
3231 name__ = Some(map_.next_value()?);
3232 }
3233 GeneratedField::DatabaseId => {
3234 if database_id__.is_some() {
3235 return Err(serde::de::Error::duplicate_field("databaseId"));
3236 }
3237 database_id__ =
3238 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3239 ;
3240 }
3241 GeneratedField::Value => {
3242 if value__.is_some() {
3243 return Err(serde::de::Error::duplicate_field("value"));
3244 }
3245 value__ =
3246 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
3247 ;
3248 }
3249 GeneratedField::Owner => {
3250 if owner__.is_some() {
3251 return Err(serde::de::Error::duplicate_field("owner"));
3252 }
3253 owner__ =
3254 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3255 ;
3256 }
3257 GeneratedField::SchemaId => {
3258 if schema_id__.is_some() {
3259 return Err(serde::de::Error::duplicate_field("schemaId"));
3260 }
3261 schema_id__ =
3262 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3263 ;
3264 }
3265 }
3266 }
3267 Ok(Secret {
3268 id: id__.unwrap_or_default(),
3269 name: name__.unwrap_or_default(),
3270 database_id: database_id__.unwrap_or_default(),
3271 value: value__.unwrap_or_default(),
3272 owner: owner__.unwrap_or_default(),
3273 schema_id: schema_id__.unwrap_or_default(),
3274 })
3275 }
3276 }
3277 deserializer.deserialize_struct("catalog.Secret", FIELDS, GeneratedVisitor)
3278 }
3279}
3280impl serde::Serialize for Sink {
3281 #[allow(deprecated)]
3282 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3283 where
3284 S: serde::Serializer,
3285 {
3286 use serde::ser::SerializeStruct;
3287 let mut len = 0;
3288 if self.id != 0 {
3289 len += 1;
3290 }
3291 if self.schema_id != 0 {
3292 len += 1;
3293 }
3294 if self.database_id != 0 {
3295 len += 1;
3296 }
3297 if !self.name.is_empty() {
3298 len += 1;
3299 }
3300 if !self.columns.is_empty() {
3301 len += 1;
3302 }
3303 if !self.plan_pk.is_empty() {
3304 len += 1;
3305 }
3306 if !self.distribution_key.is_empty() {
3307 len += 1;
3308 }
3309 if !self.downstream_pk.is_empty() {
3310 len += 1;
3311 }
3312 if self.sink_type != 0 {
3313 len += 1;
3314 }
3315 if self.owner != 0 {
3316 len += 1;
3317 }
3318 if !self.properties.is_empty() {
3319 len += 1;
3320 }
3321 if !self.definition.is_empty() {
3322 len += 1;
3323 }
3324 if self.connection_id.is_some() {
3325 len += 1;
3326 }
3327 if self.initialized_at_epoch.is_some() {
3328 len += 1;
3329 }
3330 if self.created_at_epoch.is_some() {
3331 len += 1;
3332 }
3333 if !self.db_name.is_empty() {
3334 len += 1;
3335 }
3336 if !self.sink_from_name.is_empty() {
3337 len += 1;
3338 }
3339 if self.stream_job_status != 0 {
3340 len += 1;
3341 }
3342 if self.format_desc.is_some() {
3343 len += 1;
3344 }
3345 if self.target_table.is_some() {
3346 len += 1;
3347 }
3348 if self.initialized_at_cluster_version.is_some() {
3349 len += 1;
3350 }
3351 if self.created_at_cluster_version.is_some() {
3352 len += 1;
3353 }
3354 if self.create_type != 0 {
3355 len += 1;
3356 }
3357 if !self.secret_refs.is_empty() {
3358 len += 1;
3359 }
3360 if !self.original_target_columns.is_empty() {
3361 len += 1;
3362 }
3363 if self.auto_refresh_schema_from_table.is_some() {
3364 len += 1;
3365 }
3366 let mut struct_ser = serializer.serialize_struct("catalog.Sink", len)?;
3367 if self.id != 0 {
3368 struct_ser.serialize_field("id", &self.id)?;
3369 }
3370 if self.schema_id != 0 {
3371 struct_ser.serialize_field("schemaId", &self.schema_id)?;
3372 }
3373 if self.database_id != 0 {
3374 struct_ser.serialize_field("databaseId", &self.database_id)?;
3375 }
3376 if !self.name.is_empty() {
3377 struct_ser.serialize_field("name", &self.name)?;
3378 }
3379 if !self.columns.is_empty() {
3380 struct_ser.serialize_field("columns", &self.columns)?;
3381 }
3382 if !self.plan_pk.is_empty() {
3383 struct_ser.serialize_field("planPk", &self.plan_pk)?;
3384 }
3385 if !self.distribution_key.is_empty() {
3386 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
3387 }
3388 if !self.downstream_pk.is_empty() {
3389 struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
3390 }
3391 if self.sink_type != 0 {
3392 let v = SinkType::try_from(self.sink_type)
3393 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
3394 struct_ser.serialize_field("sinkType", &v)?;
3395 }
3396 if self.owner != 0 {
3397 struct_ser.serialize_field("owner", &self.owner)?;
3398 }
3399 if !self.properties.is_empty() {
3400 struct_ser.serialize_field("properties", &self.properties)?;
3401 }
3402 if !self.definition.is_empty() {
3403 struct_ser.serialize_field("definition", &self.definition)?;
3404 }
3405 if let Some(v) = self.connection_id.as_ref() {
3406 struct_ser.serialize_field("connectionId", v)?;
3407 }
3408 if let Some(v) = self.initialized_at_epoch.as_ref() {
3409 #[allow(clippy::needless_borrow)]
3410 #[allow(clippy::needless_borrows_for_generic_args)]
3411 struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
3412 }
3413 if let Some(v) = self.created_at_epoch.as_ref() {
3414 #[allow(clippy::needless_borrow)]
3415 #[allow(clippy::needless_borrows_for_generic_args)]
3416 struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
3417 }
3418 if !self.db_name.is_empty() {
3419 struct_ser.serialize_field("dbName", &self.db_name)?;
3420 }
3421 if !self.sink_from_name.is_empty() {
3422 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
3423 }
3424 if self.stream_job_status != 0 {
3425 let v = StreamJobStatus::try_from(self.stream_job_status)
3426 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_job_status)))?;
3427 struct_ser.serialize_field("streamJobStatus", &v)?;
3428 }
3429 if let Some(v) = self.format_desc.as_ref() {
3430 struct_ser.serialize_field("formatDesc", v)?;
3431 }
3432 if let Some(v) = self.target_table.as_ref() {
3433 struct_ser.serialize_field("targetTable", v)?;
3434 }
3435 if let Some(v) = self.initialized_at_cluster_version.as_ref() {
3436 struct_ser.serialize_field("initializedAtClusterVersion", v)?;
3437 }
3438 if let Some(v) = self.created_at_cluster_version.as_ref() {
3439 struct_ser.serialize_field("createdAtClusterVersion", v)?;
3440 }
3441 if self.create_type != 0 {
3442 let v = CreateType::try_from(self.create_type)
3443 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.create_type)))?;
3444 struct_ser.serialize_field("createType", &v)?;
3445 }
3446 if !self.secret_refs.is_empty() {
3447 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
3448 }
3449 if !self.original_target_columns.is_empty() {
3450 struct_ser.serialize_field("originalTargetColumns", &self.original_target_columns)?;
3451 }
3452 if let Some(v) = self.auto_refresh_schema_from_table.as_ref() {
3453 struct_ser.serialize_field("autoRefreshSchemaFromTable", v)?;
3454 }
3455 struct_ser.end()
3456 }
3457}
3458impl<'de> serde::Deserialize<'de> for Sink {
3459 #[allow(deprecated)]
3460 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3461 where
3462 D: serde::Deserializer<'de>,
3463 {
3464 const FIELDS: &[&str] = &[
3465 "id",
3466 "schema_id",
3467 "schemaId",
3468 "database_id",
3469 "databaseId",
3470 "name",
3471 "columns",
3472 "plan_pk",
3473 "planPk",
3474 "distribution_key",
3475 "distributionKey",
3476 "downstream_pk",
3477 "downstreamPk",
3478 "sink_type",
3479 "sinkType",
3480 "owner",
3481 "properties",
3482 "definition",
3483 "connection_id",
3484 "connectionId",
3485 "initialized_at_epoch",
3486 "initializedAtEpoch",
3487 "created_at_epoch",
3488 "createdAtEpoch",
3489 "db_name",
3490 "dbName",
3491 "sink_from_name",
3492 "sinkFromName",
3493 "stream_job_status",
3494 "streamJobStatus",
3495 "format_desc",
3496 "formatDesc",
3497 "target_table",
3498 "targetTable",
3499 "initialized_at_cluster_version",
3500 "initializedAtClusterVersion",
3501 "created_at_cluster_version",
3502 "createdAtClusterVersion",
3503 "create_type",
3504 "createType",
3505 "secret_refs",
3506 "secretRefs",
3507 "original_target_columns",
3508 "originalTargetColumns",
3509 "auto_refresh_schema_from_table",
3510 "autoRefreshSchemaFromTable",
3511 ];
3512
3513 #[allow(clippy::enum_variant_names)]
3514 enum GeneratedField {
3515 Id,
3516 SchemaId,
3517 DatabaseId,
3518 Name,
3519 Columns,
3520 PlanPk,
3521 DistributionKey,
3522 DownstreamPk,
3523 SinkType,
3524 Owner,
3525 Properties,
3526 Definition,
3527 ConnectionId,
3528 InitializedAtEpoch,
3529 CreatedAtEpoch,
3530 DbName,
3531 SinkFromName,
3532 StreamJobStatus,
3533 FormatDesc,
3534 TargetTable,
3535 InitializedAtClusterVersion,
3536 CreatedAtClusterVersion,
3537 CreateType,
3538 SecretRefs,
3539 OriginalTargetColumns,
3540 AutoRefreshSchemaFromTable,
3541 }
3542 impl<'de> serde::Deserialize<'de> for GeneratedField {
3543 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3544 where
3545 D: serde::Deserializer<'de>,
3546 {
3547 struct GeneratedVisitor;
3548
3549 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3550 type Value = GeneratedField;
3551
3552 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3553 write!(formatter, "expected one of: {:?}", &FIELDS)
3554 }
3555
3556 #[allow(unused_variables)]
3557 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3558 where
3559 E: serde::de::Error,
3560 {
3561 match value {
3562 "id" => Ok(GeneratedField::Id),
3563 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
3564 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
3565 "name" => Ok(GeneratedField::Name),
3566 "columns" => Ok(GeneratedField::Columns),
3567 "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
3568 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
3569 "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
3570 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
3571 "owner" => Ok(GeneratedField::Owner),
3572 "properties" => Ok(GeneratedField::Properties),
3573 "definition" => Ok(GeneratedField::Definition),
3574 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
3575 "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
3576 "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
3577 "dbName" | "db_name" => Ok(GeneratedField::DbName),
3578 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
3579 "streamJobStatus" | "stream_job_status" => Ok(GeneratedField::StreamJobStatus),
3580 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
3581 "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
3582 "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
3583 "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
3584 "createType" | "create_type" => Ok(GeneratedField::CreateType),
3585 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
3586 "originalTargetColumns" | "original_target_columns" => Ok(GeneratedField::OriginalTargetColumns),
3587 "autoRefreshSchemaFromTable" | "auto_refresh_schema_from_table" => Ok(GeneratedField::AutoRefreshSchemaFromTable),
3588 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3589 }
3590 }
3591 }
3592 deserializer.deserialize_identifier(GeneratedVisitor)
3593 }
3594 }
3595 struct GeneratedVisitor;
3596 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3597 type Value = Sink;
3598
3599 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3600 formatter.write_str("struct catalog.Sink")
3601 }
3602
3603 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Sink, V::Error>
3604 where
3605 V: serde::de::MapAccess<'de>,
3606 {
3607 let mut id__ = None;
3608 let mut schema_id__ = None;
3609 let mut database_id__ = None;
3610 let mut name__ = None;
3611 let mut columns__ = None;
3612 let mut plan_pk__ = None;
3613 let mut distribution_key__ = None;
3614 let mut downstream_pk__ = None;
3615 let mut sink_type__ = None;
3616 let mut owner__ = None;
3617 let mut properties__ = None;
3618 let mut definition__ = None;
3619 let mut connection_id__ = None;
3620 let mut initialized_at_epoch__ = None;
3621 let mut created_at_epoch__ = None;
3622 let mut db_name__ = None;
3623 let mut sink_from_name__ = None;
3624 let mut stream_job_status__ = None;
3625 let mut format_desc__ = None;
3626 let mut target_table__ = None;
3627 let mut initialized_at_cluster_version__ = None;
3628 let mut created_at_cluster_version__ = None;
3629 let mut create_type__ = None;
3630 let mut secret_refs__ = None;
3631 let mut original_target_columns__ = None;
3632 let mut auto_refresh_schema_from_table__ = None;
3633 while let Some(k) = map_.next_key()? {
3634 match k {
3635 GeneratedField::Id => {
3636 if id__.is_some() {
3637 return Err(serde::de::Error::duplicate_field("id"));
3638 }
3639 id__ =
3640 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3641 ;
3642 }
3643 GeneratedField::SchemaId => {
3644 if schema_id__.is_some() {
3645 return Err(serde::de::Error::duplicate_field("schemaId"));
3646 }
3647 schema_id__ =
3648 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3649 ;
3650 }
3651 GeneratedField::DatabaseId => {
3652 if database_id__.is_some() {
3653 return Err(serde::de::Error::duplicate_field("databaseId"));
3654 }
3655 database_id__ =
3656 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3657 ;
3658 }
3659 GeneratedField::Name => {
3660 if name__.is_some() {
3661 return Err(serde::de::Error::duplicate_field("name"));
3662 }
3663 name__ = Some(map_.next_value()?);
3664 }
3665 GeneratedField::Columns => {
3666 if columns__.is_some() {
3667 return Err(serde::de::Error::duplicate_field("columns"));
3668 }
3669 columns__ = Some(map_.next_value()?);
3670 }
3671 GeneratedField::PlanPk => {
3672 if plan_pk__.is_some() {
3673 return Err(serde::de::Error::duplicate_field("planPk"));
3674 }
3675 plan_pk__ = Some(map_.next_value()?);
3676 }
3677 GeneratedField::DistributionKey => {
3678 if distribution_key__.is_some() {
3679 return Err(serde::de::Error::duplicate_field("distributionKey"));
3680 }
3681 distribution_key__ =
3682 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3683 .into_iter().map(|x| x.0).collect())
3684 ;
3685 }
3686 GeneratedField::DownstreamPk => {
3687 if downstream_pk__.is_some() {
3688 return Err(serde::de::Error::duplicate_field("downstreamPk"));
3689 }
3690 downstream_pk__ =
3691 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3692 .into_iter().map(|x| x.0).collect())
3693 ;
3694 }
3695 GeneratedField::SinkType => {
3696 if sink_type__.is_some() {
3697 return Err(serde::de::Error::duplicate_field("sinkType"));
3698 }
3699 sink_type__ = Some(map_.next_value::<SinkType>()? as i32);
3700 }
3701 GeneratedField::Owner => {
3702 if owner__.is_some() {
3703 return Err(serde::de::Error::duplicate_field("owner"));
3704 }
3705 owner__ =
3706 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3707 ;
3708 }
3709 GeneratedField::Properties => {
3710 if properties__.is_some() {
3711 return Err(serde::de::Error::duplicate_field("properties"));
3712 }
3713 properties__ = Some(
3714 map_.next_value::<std::collections::BTreeMap<_, _>>()?
3715 );
3716 }
3717 GeneratedField::Definition => {
3718 if definition__.is_some() {
3719 return Err(serde::de::Error::duplicate_field("definition"));
3720 }
3721 definition__ = Some(map_.next_value()?);
3722 }
3723 GeneratedField::ConnectionId => {
3724 if connection_id__.is_some() {
3725 return Err(serde::de::Error::duplicate_field("connectionId"));
3726 }
3727 connection_id__ =
3728 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3729 ;
3730 }
3731 GeneratedField::InitializedAtEpoch => {
3732 if initialized_at_epoch__.is_some() {
3733 return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
3734 }
3735 initialized_at_epoch__ =
3736 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3737 ;
3738 }
3739 GeneratedField::CreatedAtEpoch => {
3740 if created_at_epoch__.is_some() {
3741 return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
3742 }
3743 created_at_epoch__ =
3744 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3745 ;
3746 }
3747 GeneratedField::DbName => {
3748 if db_name__.is_some() {
3749 return Err(serde::de::Error::duplicate_field("dbName"));
3750 }
3751 db_name__ = Some(map_.next_value()?);
3752 }
3753 GeneratedField::SinkFromName => {
3754 if sink_from_name__.is_some() {
3755 return Err(serde::de::Error::duplicate_field("sinkFromName"));
3756 }
3757 sink_from_name__ = Some(map_.next_value()?);
3758 }
3759 GeneratedField::StreamJobStatus => {
3760 if stream_job_status__.is_some() {
3761 return Err(serde::de::Error::duplicate_field("streamJobStatus"));
3762 }
3763 stream_job_status__ = Some(map_.next_value::<StreamJobStatus>()? as i32);
3764 }
3765 GeneratedField::FormatDesc => {
3766 if format_desc__.is_some() {
3767 return Err(serde::de::Error::duplicate_field("formatDesc"));
3768 }
3769 format_desc__ = map_.next_value()?;
3770 }
3771 GeneratedField::TargetTable => {
3772 if target_table__.is_some() {
3773 return Err(serde::de::Error::duplicate_field("targetTable"));
3774 }
3775 target_table__ =
3776 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3777 ;
3778 }
3779 GeneratedField::InitializedAtClusterVersion => {
3780 if initialized_at_cluster_version__.is_some() {
3781 return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
3782 }
3783 initialized_at_cluster_version__ = map_.next_value()?;
3784 }
3785 GeneratedField::CreatedAtClusterVersion => {
3786 if created_at_cluster_version__.is_some() {
3787 return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
3788 }
3789 created_at_cluster_version__ = map_.next_value()?;
3790 }
3791 GeneratedField::CreateType => {
3792 if create_type__.is_some() {
3793 return Err(serde::de::Error::duplicate_field("createType"));
3794 }
3795 create_type__ = Some(map_.next_value::<CreateType>()? as i32);
3796 }
3797 GeneratedField::SecretRefs => {
3798 if secret_refs__.is_some() {
3799 return Err(serde::de::Error::duplicate_field("secretRefs"));
3800 }
3801 secret_refs__ = Some(
3802 map_.next_value::<std::collections::BTreeMap<_, _>>()?
3803 );
3804 }
3805 GeneratedField::OriginalTargetColumns => {
3806 if original_target_columns__.is_some() {
3807 return Err(serde::de::Error::duplicate_field("originalTargetColumns"));
3808 }
3809 original_target_columns__ = Some(map_.next_value()?);
3810 }
3811 GeneratedField::AutoRefreshSchemaFromTable => {
3812 if auto_refresh_schema_from_table__.is_some() {
3813 return Err(serde::de::Error::duplicate_field("autoRefreshSchemaFromTable"));
3814 }
3815 auto_refresh_schema_from_table__ =
3816 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3817 ;
3818 }
3819 }
3820 }
3821 Ok(Sink {
3822 id: id__.unwrap_or_default(),
3823 schema_id: schema_id__.unwrap_or_default(),
3824 database_id: database_id__.unwrap_or_default(),
3825 name: name__.unwrap_or_default(),
3826 columns: columns__.unwrap_or_default(),
3827 plan_pk: plan_pk__.unwrap_or_default(),
3828 distribution_key: distribution_key__.unwrap_or_default(),
3829 downstream_pk: downstream_pk__.unwrap_or_default(),
3830 sink_type: sink_type__.unwrap_or_default(),
3831 owner: owner__.unwrap_or_default(),
3832 properties: properties__.unwrap_or_default(),
3833 definition: definition__.unwrap_or_default(),
3834 connection_id: connection_id__,
3835 initialized_at_epoch: initialized_at_epoch__,
3836 created_at_epoch: created_at_epoch__,
3837 db_name: db_name__.unwrap_or_default(),
3838 sink_from_name: sink_from_name__.unwrap_or_default(),
3839 stream_job_status: stream_job_status__.unwrap_or_default(),
3840 format_desc: format_desc__,
3841 target_table: target_table__,
3842 initialized_at_cluster_version: initialized_at_cluster_version__,
3843 created_at_cluster_version: created_at_cluster_version__,
3844 create_type: create_type__.unwrap_or_default(),
3845 secret_refs: secret_refs__.unwrap_or_default(),
3846 original_target_columns: original_target_columns__.unwrap_or_default(),
3847 auto_refresh_schema_from_table: auto_refresh_schema_from_table__,
3848 })
3849 }
3850 }
3851 deserializer.deserialize_struct("catalog.Sink", FIELDS, GeneratedVisitor)
3852 }
3853}
3854impl serde::Serialize for SinkFormatDesc {
3855 #[allow(deprecated)]
3856 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3857 where
3858 S: serde::Serializer,
3859 {
3860 use serde::ser::SerializeStruct;
3861 let mut len = 0;
3862 if self.format != 0 {
3863 len += 1;
3864 }
3865 if self.encode != 0 {
3866 len += 1;
3867 }
3868 if !self.options.is_empty() {
3869 len += 1;
3870 }
3871 if self.key_encode.is_some() {
3872 len += 1;
3873 }
3874 if !self.secret_refs.is_empty() {
3875 len += 1;
3876 }
3877 if self.connection_id.is_some() {
3878 len += 1;
3879 }
3880 let mut struct_ser = serializer.serialize_struct("catalog.SinkFormatDesc", len)?;
3881 if self.format != 0 {
3882 let v = super::plan_common::FormatType::try_from(self.format)
3883 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?;
3884 struct_ser.serialize_field("format", &v)?;
3885 }
3886 if self.encode != 0 {
3887 let v = super::plan_common::EncodeType::try_from(self.encode)
3888 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.encode)))?;
3889 struct_ser.serialize_field("encode", &v)?;
3890 }
3891 if !self.options.is_empty() {
3892 struct_ser.serialize_field("options", &self.options)?;
3893 }
3894 if let Some(v) = self.key_encode.as_ref() {
3895 let v = super::plan_common::EncodeType::try_from(*v)
3896 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
3897 struct_ser.serialize_field("keyEncode", &v)?;
3898 }
3899 if !self.secret_refs.is_empty() {
3900 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
3901 }
3902 if let Some(v) = self.connection_id.as_ref() {
3903 struct_ser.serialize_field("connectionId", v)?;
3904 }
3905 struct_ser.end()
3906 }
3907}
3908impl<'de> serde::Deserialize<'de> for SinkFormatDesc {
3909 #[allow(deprecated)]
3910 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3911 where
3912 D: serde::Deserializer<'de>,
3913 {
3914 const FIELDS: &[&str] = &[
3915 "format",
3916 "encode",
3917 "options",
3918 "key_encode",
3919 "keyEncode",
3920 "secret_refs",
3921 "secretRefs",
3922 "connection_id",
3923 "connectionId",
3924 ];
3925
3926 #[allow(clippy::enum_variant_names)]
3927 enum GeneratedField {
3928 Format,
3929 Encode,
3930 Options,
3931 KeyEncode,
3932 SecretRefs,
3933 ConnectionId,
3934 }
3935 impl<'de> serde::Deserialize<'de> for GeneratedField {
3936 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3937 where
3938 D: serde::Deserializer<'de>,
3939 {
3940 struct GeneratedVisitor;
3941
3942 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3943 type Value = GeneratedField;
3944
3945 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3946 write!(formatter, "expected one of: {:?}", &FIELDS)
3947 }
3948
3949 #[allow(unused_variables)]
3950 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3951 where
3952 E: serde::de::Error,
3953 {
3954 match value {
3955 "format" => Ok(GeneratedField::Format),
3956 "encode" => Ok(GeneratedField::Encode),
3957 "options" => Ok(GeneratedField::Options),
3958 "keyEncode" | "key_encode" => Ok(GeneratedField::KeyEncode),
3959 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
3960 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
3961 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3962 }
3963 }
3964 }
3965 deserializer.deserialize_identifier(GeneratedVisitor)
3966 }
3967 }
3968 struct GeneratedVisitor;
3969 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3970 type Value = SinkFormatDesc;
3971
3972 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3973 formatter.write_str("struct catalog.SinkFormatDesc")
3974 }
3975
3976 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkFormatDesc, V::Error>
3977 where
3978 V: serde::de::MapAccess<'de>,
3979 {
3980 let mut format__ = None;
3981 let mut encode__ = None;
3982 let mut options__ = None;
3983 let mut key_encode__ = None;
3984 let mut secret_refs__ = None;
3985 let mut connection_id__ = None;
3986 while let Some(k) = map_.next_key()? {
3987 match k {
3988 GeneratedField::Format => {
3989 if format__.is_some() {
3990 return Err(serde::de::Error::duplicate_field("format"));
3991 }
3992 format__ = Some(map_.next_value::<super::plan_common::FormatType>()? as i32);
3993 }
3994 GeneratedField::Encode => {
3995 if encode__.is_some() {
3996 return Err(serde::de::Error::duplicate_field("encode"));
3997 }
3998 encode__ = Some(map_.next_value::<super::plan_common::EncodeType>()? as i32);
3999 }
4000 GeneratedField::Options => {
4001 if options__.is_some() {
4002 return Err(serde::de::Error::duplicate_field("options"));
4003 }
4004 options__ = Some(
4005 map_.next_value::<std::collections::BTreeMap<_, _>>()?
4006 );
4007 }
4008 GeneratedField::KeyEncode => {
4009 if key_encode__.is_some() {
4010 return Err(serde::de::Error::duplicate_field("keyEncode"));
4011 }
4012 key_encode__ = map_.next_value::<::std::option::Option<super::plan_common::EncodeType>>()?.map(|x| x as i32);
4013 }
4014 GeneratedField::SecretRefs => {
4015 if secret_refs__.is_some() {
4016 return Err(serde::de::Error::duplicate_field("secretRefs"));
4017 }
4018 secret_refs__ = Some(
4019 map_.next_value::<std::collections::BTreeMap<_, _>>()?
4020 );
4021 }
4022 GeneratedField::ConnectionId => {
4023 if connection_id__.is_some() {
4024 return Err(serde::de::Error::duplicate_field("connectionId"));
4025 }
4026 connection_id__ =
4027 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4028 ;
4029 }
4030 }
4031 }
4032 Ok(SinkFormatDesc {
4033 format: format__.unwrap_or_default(),
4034 encode: encode__.unwrap_or_default(),
4035 options: options__.unwrap_or_default(),
4036 key_encode: key_encode__,
4037 secret_refs: secret_refs__.unwrap_or_default(),
4038 connection_id: connection_id__,
4039 })
4040 }
4041 }
4042 deserializer.deserialize_struct("catalog.SinkFormatDesc", FIELDS, GeneratedVisitor)
4043 }
4044}
4045impl serde::Serialize for SinkType {
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 let variant = match self {
4052 Self::Unspecified => "SINK_TYPE_UNSPECIFIED",
4053 Self::AppendOnly => "SINK_TYPE_APPEND_ONLY",
4054 Self::ForceAppendOnly => "SINK_TYPE_FORCE_APPEND_ONLY",
4055 Self::Upsert => "SINK_TYPE_UPSERT",
4056 Self::Retract => "SINK_TYPE_RETRACT",
4057 };
4058 serializer.serialize_str(variant)
4059 }
4060}
4061impl<'de> serde::Deserialize<'de> for SinkType {
4062 #[allow(deprecated)]
4063 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4064 where
4065 D: serde::Deserializer<'de>,
4066 {
4067 const FIELDS: &[&str] = &[
4068 "SINK_TYPE_UNSPECIFIED",
4069 "SINK_TYPE_APPEND_ONLY",
4070 "SINK_TYPE_FORCE_APPEND_ONLY",
4071 "SINK_TYPE_UPSERT",
4072 "SINK_TYPE_RETRACT",
4073 ];
4074
4075 struct GeneratedVisitor;
4076
4077 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4078 type Value = SinkType;
4079
4080 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4081 write!(formatter, "expected one of: {:?}", &FIELDS)
4082 }
4083
4084 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
4085 where
4086 E: serde::de::Error,
4087 {
4088 i32::try_from(v)
4089 .ok()
4090 .and_then(|x| x.try_into().ok())
4091 .ok_or_else(|| {
4092 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
4093 })
4094 }
4095
4096 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
4097 where
4098 E: serde::de::Error,
4099 {
4100 i32::try_from(v)
4101 .ok()
4102 .and_then(|x| x.try_into().ok())
4103 .ok_or_else(|| {
4104 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
4105 })
4106 }
4107
4108 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
4109 where
4110 E: serde::de::Error,
4111 {
4112 match value {
4113 "SINK_TYPE_UNSPECIFIED" => Ok(SinkType::Unspecified),
4114 "SINK_TYPE_APPEND_ONLY" => Ok(SinkType::AppendOnly),
4115 "SINK_TYPE_FORCE_APPEND_ONLY" => Ok(SinkType::ForceAppendOnly),
4116 "SINK_TYPE_UPSERT" => Ok(SinkType::Upsert),
4117 "SINK_TYPE_RETRACT" => Ok(SinkType::Retract),
4118 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
4119 }
4120 }
4121 }
4122 deserializer.deserialize_any(GeneratedVisitor)
4123 }
4124}
4125impl serde::Serialize for Source {
4126 #[allow(deprecated)]
4127 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4128 where
4129 S: serde::Serializer,
4130 {
4131 use serde::ser::SerializeStruct;
4132 let mut len = 0;
4133 if self.id != 0 {
4134 len += 1;
4135 }
4136 if self.schema_id != 0 {
4137 len += 1;
4138 }
4139 if self.database_id != 0 {
4140 len += 1;
4141 }
4142 if !self.name.is_empty() {
4143 len += 1;
4144 }
4145 if self.row_id_index.is_some() {
4146 len += 1;
4147 }
4148 if !self.columns.is_empty() {
4149 len += 1;
4150 }
4151 if !self.pk_column_ids.is_empty() {
4152 len += 1;
4153 }
4154 if !self.with_properties.is_empty() {
4155 len += 1;
4156 }
4157 if self.owner != 0 {
4158 len += 1;
4159 }
4160 if self.info.is_some() {
4161 len += 1;
4162 }
4163 if !self.watermark_descs.is_empty() {
4164 len += 1;
4165 }
4166 if !self.definition.is_empty() {
4167 len += 1;
4168 }
4169 if self.connection_id.is_some() {
4170 len += 1;
4171 }
4172 if self.initialized_at_epoch.is_some() {
4173 len += 1;
4174 }
4175 if self.created_at_epoch.is_some() {
4176 len += 1;
4177 }
4178 if self.initialized_at_cluster_version.is_some() {
4179 len += 1;
4180 }
4181 if self.created_at_cluster_version.is_some() {
4182 len += 1;
4183 }
4184 if !self.secret_refs.is_empty() {
4185 len += 1;
4186 }
4187 if self.version != 0 {
4188 len += 1;
4189 }
4190 if self.rate_limit.is_some() {
4191 len += 1;
4192 }
4193 if self.optional_associated_table_id.is_some() {
4194 len += 1;
4195 }
4196 let mut struct_ser = serializer.serialize_struct("catalog.Source", len)?;
4197 if self.id != 0 {
4198 struct_ser.serialize_field("id", &self.id)?;
4199 }
4200 if self.schema_id != 0 {
4201 struct_ser.serialize_field("schemaId", &self.schema_id)?;
4202 }
4203 if self.database_id != 0 {
4204 struct_ser.serialize_field("databaseId", &self.database_id)?;
4205 }
4206 if !self.name.is_empty() {
4207 struct_ser.serialize_field("name", &self.name)?;
4208 }
4209 if let Some(v) = self.row_id_index.as_ref() {
4210 struct_ser.serialize_field("rowIdIndex", v)?;
4211 }
4212 if !self.columns.is_empty() {
4213 struct_ser.serialize_field("columns", &self.columns)?;
4214 }
4215 if !self.pk_column_ids.is_empty() {
4216 struct_ser.serialize_field("pkColumnIds", &self.pk_column_ids)?;
4217 }
4218 if !self.with_properties.is_empty() {
4219 struct_ser.serialize_field("withProperties", &self.with_properties)?;
4220 }
4221 if self.owner != 0 {
4222 struct_ser.serialize_field("owner", &self.owner)?;
4223 }
4224 if let Some(v) = self.info.as_ref() {
4225 struct_ser.serialize_field("info", v)?;
4226 }
4227 if !self.watermark_descs.is_empty() {
4228 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
4229 }
4230 if !self.definition.is_empty() {
4231 struct_ser.serialize_field("definition", &self.definition)?;
4232 }
4233 if let Some(v) = self.connection_id.as_ref() {
4234 struct_ser.serialize_field("connectionId", v)?;
4235 }
4236 if let Some(v) = self.initialized_at_epoch.as_ref() {
4237 #[allow(clippy::needless_borrow)]
4238 #[allow(clippy::needless_borrows_for_generic_args)]
4239 struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
4240 }
4241 if let Some(v) = self.created_at_epoch.as_ref() {
4242 #[allow(clippy::needless_borrow)]
4243 #[allow(clippy::needless_borrows_for_generic_args)]
4244 struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
4245 }
4246 if let Some(v) = self.initialized_at_cluster_version.as_ref() {
4247 struct_ser.serialize_field("initializedAtClusterVersion", v)?;
4248 }
4249 if let Some(v) = self.created_at_cluster_version.as_ref() {
4250 struct_ser.serialize_field("createdAtClusterVersion", v)?;
4251 }
4252 if !self.secret_refs.is_empty() {
4253 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
4254 }
4255 if self.version != 0 {
4256 #[allow(clippy::needless_borrow)]
4257 #[allow(clippy::needless_borrows_for_generic_args)]
4258 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
4259 }
4260 if let Some(v) = self.rate_limit.as_ref() {
4261 struct_ser.serialize_field("rateLimit", v)?;
4262 }
4263 if let Some(v) = self.optional_associated_table_id.as_ref() {
4264 match v {
4265 source::OptionalAssociatedTableId::AssociatedTableId(v) => {
4266 struct_ser.serialize_field("associatedTableId", v)?;
4267 }
4268 }
4269 }
4270 struct_ser.end()
4271 }
4272}
4273impl<'de> serde::Deserialize<'de> for Source {
4274 #[allow(deprecated)]
4275 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4276 where
4277 D: serde::Deserializer<'de>,
4278 {
4279 const FIELDS: &[&str] = &[
4280 "id",
4281 "schema_id",
4282 "schemaId",
4283 "database_id",
4284 "databaseId",
4285 "name",
4286 "row_id_index",
4287 "rowIdIndex",
4288 "columns",
4289 "pk_column_ids",
4290 "pkColumnIds",
4291 "with_properties",
4292 "withProperties",
4293 "owner",
4294 "info",
4295 "watermark_descs",
4296 "watermarkDescs",
4297 "definition",
4298 "connection_id",
4299 "connectionId",
4300 "initialized_at_epoch",
4301 "initializedAtEpoch",
4302 "created_at_epoch",
4303 "createdAtEpoch",
4304 "initialized_at_cluster_version",
4305 "initializedAtClusterVersion",
4306 "created_at_cluster_version",
4307 "createdAtClusterVersion",
4308 "secret_refs",
4309 "secretRefs",
4310 "version",
4311 "rate_limit",
4312 "rateLimit",
4313 "associated_table_id",
4314 "associatedTableId",
4315 ];
4316
4317 #[allow(clippy::enum_variant_names)]
4318 enum GeneratedField {
4319 Id,
4320 SchemaId,
4321 DatabaseId,
4322 Name,
4323 RowIdIndex,
4324 Columns,
4325 PkColumnIds,
4326 WithProperties,
4327 Owner,
4328 Info,
4329 WatermarkDescs,
4330 Definition,
4331 ConnectionId,
4332 InitializedAtEpoch,
4333 CreatedAtEpoch,
4334 InitializedAtClusterVersion,
4335 CreatedAtClusterVersion,
4336 SecretRefs,
4337 Version,
4338 RateLimit,
4339 AssociatedTableId,
4340 }
4341 impl<'de> serde::Deserialize<'de> for GeneratedField {
4342 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4343 where
4344 D: serde::Deserializer<'de>,
4345 {
4346 struct GeneratedVisitor;
4347
4348 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4349 type Value = GeneratedField;
4350
4351 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4352 write!(formatter, "expected one of: {:?}", &FIELDS)
4353 }
4354
4355 #[allow(unused_variables)]
4356 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4357 where
4358 E: serde::de::Error,
4359 {
4360 match value {
4361 "id" => Ok(GeneratedField::Id),
4362 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
4363 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4364 "name" => Ok(GeneratedField::Name),
4365 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
4366 "columns" => Ok(GeneratedField::Columns),
4367 "pkColumnIds" | "pk_column_ids" => Ok(GeneratedField::PkColumnIds),
4368 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
4369 "owner" => Ok(GeneratedField::Owner),
4370 "info" => Ok(GeneratedField::Info),
4371 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
4372 "definition" => Ok(GeneratedField::Definition),
4373 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
4374 "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
4375 "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
4376 "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
4377 "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
4378 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
4379 "version" => Ok(GeneratedField::Version),
4380 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
4381 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
4382 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4383 }
4384 }
4385 }
4386 deserializer.deserialize_identifier(GeneratedVisitor)
4387 }
4388 }
4389 struct GeneratedVisitor;
4390 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4391 type Value = Source;
4392
4393 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4394 formatter.write_str("struct catalog.Source")
4395 }
4396
4397 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Source, V::Error>
4398 where
4399 V: serde::de::MapAccess<'de>,
4400 {
4401 let mut id__ = None;
4402 let mut schema_id__ = None;
4403 let mut database_id__ = None;
4404 let mut name__ = None;
4405 let mut row_id_index__ = None;
4406 let mut columns__ = None;
4407 let mut pk_column_ids__ = None;
4408 let mut with_properties__ = None;
4409 let mut owner__ = None;
4410 let mut info__ = None;
4411 let mut watermark_descs__ = None;
4412 let mut definition__ = None;
4413 let mut connection_id__ = None;
4414 let mut initialized_at_epoch__ = None;
4415 let mut created_at_epoch__ = None;
4416 let mut initialized_at_cluster_version__ = None;
4417 let mut created_at_cluster_version__ = None;
4418 let mut secret_refs__ = None;
4419 let mut version__ = None;
4420 let mut rate_limit__ = None;
4421 let mut optional_associated_table_id__ = None;
4422 while let Some(k) = map_.next_key()? {
4423 match k {
4424 GeneratedField::Id => {
4425 if id__.is_some() {
4426 return Err(serde::de::Error::duplicate_field("id"));
4427 }
4428 id__ =
4429 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4430 ;
4431 }
4432 GeneratedField::SchemaId => {
4433 if schema_id__.is_some() {
4434 return Err(serde::de::Error::duplicate_field("schemaId"));
4435 }
4436 schema_id__ =
4437 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4438 ;
4439 }
4440 GeneratedField::DatabaseId => {
4441 if database_id__.is_some() {
4442 return Err(serde::de::Error::duplicate_field("databaseId"));
4443 }
4444 database_id__ =
4445 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4446 ;
4447 }
4448 GeneratedField::Name => {
4449 if name__.is_some() {
4450 return Err(serde::de::Error::duplicate_field("name"));
4451 }
4452 name__ = Some(map_.next_value()?);
4453 }
4454 GeneratedField::RowIdIndex => {
4455 if row_id_index__.is_some() {
4456 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
4457 }
4458 row_id_index__ =
4459 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4460 ;
4461 }
4462 GeneratedField::Columns => {
4463 if columns__.is_some() {
4464 return Err(serde::de::Error::duplicate_field("columns"));
4465 }
4466 columns__ = Some(map_.next_value()?);
4467 }
4468 GeneratedField::PkColumnIds => {
4469 if pk_column_ids__.is_some() {
4470 return Err(serde::de::Error::duplicate_field("pkColumnIds"));
4471 }
4472 pk_column_ids__ =
4473 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4474 .into_iter().map(|x| x.0).collect())
4475 ;
4476 }
4477 GeneratedField::WithProperties => {
4478 if with_properties__.is_some() {
4479 return Err(serde::de::Error::duplicate_field("withProperties"));
4480 }
4481 with_properties__ = Some(
4482 map_.next_value::<std::collections::BTreeMap<_, _>>()?
4483 );
4484 }
4485 GeneratedField::Owner => {
4486 if owner__.is_some() {
4487 return Err(serde::de::Error::duplicate_field("owner"));
4488 }
4489 owner__ =
4490 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4491 ;
4492 }
4493 GeneratedField::Info => {
4494 if info__.is_some() {
4495 return Err(serde::de::Error::duplicate_field("info"));
4496 }
4497 info__ = map_.next_value()?;
4498 }
4499 GeneratedField::WatermarkDescs => {
4500 if watermark_descs__.is_some() {
4501 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
4502 }
4503 watermark_descs__ = Some(map_.next_value()?);
4504 }
4505 GeneratedField::Definition => {
4506 if definition__.is_some() {
4507 return Err(serde::de::Error::duplicate_field("definition"));
4508 }
4509 definition__ = Some(map_.next_value()?);
4510 }
4511 GeneratedField::ConnectionId => {
4512 if connection_id__.is_some() {
4513 return Err(serde::de::Error::duplicate_field("connectionId"));
4514 }
4515 connection_id__ =
4516 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4517 ;
4518 }
4519 GeneratedField::InitializedAtEpoch => {
4520 if initialized_at_epoch__.is_some() {
4521 return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
4522 }
4523 initialized_at_epoch__ =
4524 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4525 ;
4526 }
4527 GeneratedField::CreatedAtEpoch => {
4528 if created_at_epoch__.is_some() {
4529 return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
4530 }
4531 created_at_epoch__ =
4532 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4533 ;
4534 }
4535 GeneratedField::InitializedAtClusterVersion => {
4536 if initialized_at_cluster_version__.is_some() {
4537 return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
4538 }
4539 initialized_at_cluster_version__ = map_.next_value()?;
4540 }
4541 GeneratedField::CreatedAtClusterVersion => {
4542 if created_at_cluster_version__.is_some() {
4543 return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
4544 }
4545 created_at_cluster_version__ = map_.next_value()?;
4546 }
4547 GeneratedField::SecretRefs => {
4548 if secret_refs__.is_some() {
4549 return Err(serde::de::Error::duplicate_field("secretRefs"));
4550 }
4551 secret_refs__ = Some(
4552 map_.next_value::<std::collections::BTreeMap<_, _>>()?
4553 );
4554 }
4555 GeneratedField::Version => {
4556 if version__.is_some() {
4557 return Err(serde::de::Error::duplicate_field("version"));
4558 }
4559 version__ =
4560 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4561 ;
4562 }
4563 GeneratedField::RateLimit => {
4564 if rate_limit__.is_some() {
4565 return Err(serde::de::Error::duplicate_field("rateLimit"));
4566 }
4567 rate_limit__ =
4568 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4569 ;
4570 }
4571 GeneratedField::AssociatedTableId => {
4572 if optional_associated_table_id__.is_some() {
4573 return Err(serde::de::Error::duplicate_field("associatedTableId"));
4574 }
4575 optional_associated_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| source::OptionalAssociatedTableId::AssociatedTableId(x.0));
4576 }
4577 }
4578 }
4579 Ok(Source {
4580 id: id__.unwrap_or_default(),
4581 schema_id: schema_id__.unwrap_or_default(),
4582 database_id: database_id__.unwrap_or_default(),
4583 name: name__.unwrap_or_default(),
4584 row_id_index: row_id_index__,
4585 columns: columns__.unwrap_or_default(),
4586 pk_column_ids: pk_column_ids__.unwrap_or_default(),
4587 with_properties: with_properties__.unwrap_or_default(),
4588 owner: owner__.unwrap_or_default(),
4589 info: info__,
4590 watermark_descs: watermark_descs__.unwrap_or_default(),
4591 definition: definition__.unwrap_or_default(),
4592 connection_id: connection_id__,
4593 initialized_at_epoch: initialized_at_epoch__,
4594 created_at_epoch: created_at_epoch__,
4595 initialized_at_cluster_version: initialized_at_cluster_version__,
4596 created_at_cluster_version: created_at_cluster_version__,
4597 secret_refs: secret_refs__.unwrap_or_default(),
4598 version: version__.unwrap_or_default(),
4599 rate_limit: rate_limit__,
4600 optional_associated_table_id: optional_associated_table_id__,
4601 })
4602 }
4603 }
4604 deserializer.deserialize_struct("catalog.Source", FIELDS, GeneratedVisitor)
4605 }
4606}
4607impl serde::Serialize for StreamJobStatus {
4608 #[allow(deprecated)]
4609 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4610 where
4611 S: serde::Serializer,
4612 {
4613 let variant = match self {
4614 Self::Unspecified => "STREAM_JOB_STATUS_UNSPECIFIED",
4615 Self::Creating => "STREAM_JOB_STATUS_CREATING",
4616 Self::Created => "STREAM_JOB_STATUS_CREATED",
4617 };
4618 serializer.serialize_str(variant)
4619 }
4620}
4621impl<'de> serde::Deserialize<'de> for StreamJobStatus {
4622 #[allow(deprecated)]
4623 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4624 where
4625 D: serde::Deserializer<'de>,
4626 {
4627 const FIELDS: &[&str] = &[
4628 "STREAM_JOB_STATUS_UNSPECIFIED",
4629 "STREAM_JOB_STATUS_CREATING",
4630 "STREAM_JOB_STATUS_CREATED",
4631 ];
4632
4633 struct GeneratedVisitor;
4634
4635 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4636 type Value = StreamJobStatus;
4637
4638 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4639 write!(formatter, "expected one of: {:?}", &FIELDS)
4640 }
4641
4642 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
4643 where
4644 E: serde::de::Error,
4645 {
4646 i32::try_from(v)
4647 .ok()
4648 .and_then(|x| x.try_into().ok())
4649 .ok_or_else(|| {
4650 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
4651 })
4652 }
4653
4654 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
4655 where
4656 E: serde::de::Error,
4657 {
4658 i32::try_from(v)
4659 .ok()
4660 .and_then(|x| x.try_into().ok())
4661 .ok_or_else(|| {
4662 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
4663 })
4664 }
4665
4666 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
4667 where
4668 E: serde::de::Error,
4669 {
4670 match value {
4671 "STREAM_JOB_STATUS_UNSPECIFIED" => Ok(StreamJobStatus::Unspecified),
4672 "STREAM_JOB_STATUS_CREATING" => Ok(StreamJobStatus::Creating),
4673 "STREAM_JOB_STATUS_CREATED" => Ok(StreamJobStatus::Created),
4674 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
4675 }
4676 }
4677 }
4678 deserializer.deserialize_any(GeneratedVisitor)
4679 }
4680}
4681impl serde::Serialize for StreamSourceInfo {
4682 #[allow(deprecated)]
4683 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4684 where
4685 S: serde::Serializer,
4686 {
4687 use serde::ser::SerializeStruct;
4688 let mut len = 0;
4689 if self.row_format != 0 {
4690 len += 1;
4691 }
4692 if !self.row_schema_location.is_empty() {
4693 len += 1;
4694 }
4695 if self.use_schema_registry {
4696 len += 1;
4697 }
4698 if !self.proto_message_name.is_empty() {
4699 len += 1;
4700 }
4701 if self.csv_delimiter != 0 {
4702 len += 1;
4703 }
4704 if self.csv_has_header {
4705 len += 1;
4706 }
4707 if self.format != 0 {
4708 len += 1;
4709 }
4710 if self.row_encode != 0 {
4711 len += 1;
4712 }
4713 if self.name_strategy != 0 {
4714 len += 1;
4715 }
4716 if self.key_message_name.is_some() {
4717 len += 1;
4718 }
4719 if self.external_table.is_some() {
4720 len += 1;
4721 }
4722 if self.cdc_source_job {
4723 len += 1;
4724 }
4725 if self.is_distributed {
4726 len += 1;
4727 }
4728 if !self.format_encode_options.is_empty() {
4729 len += 1;
4730 }
4731 if !self.format_encode_secret_refs.is_empty() {
4732 len += 1;
4733 }
4734 if self.connection_id.is_some() {
4735 len += 1;
4736 }
4737 let mut struct_ser = serializer.serialize_struct("catalog.StreamSourceInfo", len)?;
4738 if self.row_format != 0 {
4739 let v = super::plan_common::RowFormatType::try_from(self.row_format)
4740 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.row_format)))?;
4741 struct_ser.serialize_field("rowFormat", &v)?;
4742 }
4743 if !self.row_schema_location.is_empty() {
4744 struct_ser.serialize_field("rowSchemaLocation", &self.row_schema_location)?;
4745 }
4746 if self.use_schema_registry {
4747 struct_ser.serialize_field("useSchemaRegistry", &self.use_schema_registry)?;
4748 }
4749 if !self.proto_message_name.is_empty() {
4750 struct_ser.serialize_field("protoMessageName", &self.proto_message_name)?;
4751 }
4752 if self.csv_delimiter != 0 {
4753 struct_ser.serialize_field("csvDelimiter", &self.csv_delimiter)?;
4754 }
4755 if self.csv_has_header {
4756 struct_ser.serialize_field("csvHasHeader", &self.csv_has_header)?;
4757 }
4758 if self.format != 0 {
4759 let v = super::plan_common::FormatType::try_from(self.format)
4760 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?;
4761 struct_ser.serialize_field("format", &v)?;
4762 }
4763 if self.row_encode != 0 {
4764 let v = super::plan_common::EncodeType::try_from(self.row_encode)
4765 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.row_encode)))?;
4766 struct_ser.serialize_field("rowEncode", &v)?;
4767 }
4768 if self.name_strategy != 0 {
4769 let v = SchemaRegistryNameStrategy::try_from(self.name_strategy)
4770 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.name_strategy)))?;
4771 struct_ser.serialize_field("nameStrategy", &v)?;
4772 }
4773 if let Some(v) = self.key_message_name.as_ref() {
4774 struct_ser.serialize_field("keyMessageName", v)?;
4775 }
4776 if let Some(v) = self.external_table.as_ref() {
4777 struct_ser.serialize_field("externalTable", v)?;
4778 }
4779 if self.cdc_source_job {
4780 struct_ser.serialize_field("cdcSourceJob", &self.cdc_source_job)?;
4781 }
4782 if self.is_distributed {
4783 struct_ser.serialize_field("isDistributed", &self.is_distributed)?;
4784 }
4785 if !self.format_encode_options.is_empty() {
4786 struct_ser.serialize_field("formatEncodeOptions", &self.format_encode_options)?;
4787 }
4788 if !self.format_encode_secret_refs.is_empty() {
4789 struct_ser.serialize_field("formatEncodeSecretRefs", &self.format_encode_secret_refs)?;
4790 }
4791 if let Some(v) = self.connection_id.as_ref() {
4792 struct_ser.serialize_field("connectionId", v)?;
4793 }
4794 struct_ser.end()
4795 }
4796}
4797impl<'de> serde::Deserialize<'de> for StreamSourceInfo {
4798 #[allow(deprecated)]
4799 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4800 where
4801 D: serde::Deserializer<'de>,
4802 {
4803 const FIELDS: &[&str] = &[
4804 "row_format",
4805 "rowFormat",
4806 "row_schema_location",
4807 "rowSchemaLocation",
4808 "use_schema_registry",
4809 "useSchemaRegistry",
4810 "proto_message_name",
4811 "protoMessageName",
4812 "csv_delimiter",
4813 "csvDelimiter",
4814 "csv_has_header",
4815 "csvHasHeader",
4816 "format",
4817 "row_encode",
4818 "rowEncode",
4819 "name_strategy",
4820 "nameStrategy",
4821 "key_message_name",
4822 "keyMessageName",
4823 "external_table",
4824 "externalTable",
4825 "cdc_source_job",
4826 "cdcSourceJob",
4827 "is_distributed",
4828 "isDistributed",
4829 "format_encode_options",
4830 "formatEncodeOptions",
4831 "format_encode_secret_refs",
4832 "formatEncodeSecretRefs",
4833 "connection_id",
4834 "connectionId",
4835 ];
4836
4837 #[allow(clippy::enum_variant_names)]
4838 enum GeneratedField {
4839 RowFormat,
4840 RowSchemaLocation,
4841 UseSchemaRegistry,
4842 ProtoMessageName,
4843 CsvDelimiter,
4844 CsvHasHeader,
4845 Format,
4846 RowEncode,
4847 NameStrategy,
4848 KeyMessageName,
4849 ExternalTable,
4850 CdcSourceJob,
4851 IsDistributed,
4852 FormatEncodeOptions,
4853 FormatEncodeSecretRefs,
4854 ConnectionId,
4855 }
4856 impl<'de> serde::Deserialize<'de> for GeneratedField {
4857 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4858 where
4859 D: serde::Deserializer<'de>,
4860 {
4861 struct GeneratedVisitor;
4862
4863 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4864 type Value = GeneratedField;
4865
4866 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4867 write!(formatter, "expected one of: {:?}", &FIELDS)
4868 }
4869
4870 #[allow(unused_variables)]
4871 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4872 where
4873 E: serde::de::Error,
4874 {
4875 match value {
4876 "rowFormat" | "row_format" => Ok(GeneratedField::RowFormat),
4877 "rowSchemaLocation" | "row_schema_location" => Ok(GeneratedField::RowSchemaLocation),
4878 "useSchemaRegistry" | "use_schema_registry" => Ok(GeneratedField::UseSchemaRegistry),
4879 "protoMessageName" | "proto_message_name" => Ok(GeneratedField::ProtoMessageName),
4880 "csvDelimiter" | "csv_delimiter" => Ok(GeneratedField::CsvDelimiter),
4881 "csvHasHeader" | "csv_has_header" => Ok(GeneratedField::CsvHasHeader),
4882 "format" => Ok(GeneratedField::Format),
4883 "rowEncode" | "row_encode" => Ok(GeneratedField::RowEncode),
4884 "nameStrategy" | "name_strategy" => Ok(GeneratedField::NameStrategy),
4885 "keyMessageName" | "key_message_name" => Ok(GeneratedField::KeyMessageName),
4886 "externalTable" | "external_table" => Ok(GeneratedField::ExternalTable),
4887 "cdcSourceJob" | "cdc_source_job" => Ok(GeneratedField::CdcSourceJob),
4888 "isDistributed" | "is_distributed" => Ok(GeneratedField::IsDistributed),
4889 "formatEncodeOptions" | "format_encode_options" => Ok(GeneratedField::FormatEncodeOptions),
4890 "formatEncodeSecretRefs" | "format_encode_secret_refs" => Ok(GeneratedField::FormatEncodeSecretRefs),
4891 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
4892 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4893 }
4894 }
4895 }
4896 deserializer.deserialize_identifier(GeneratedVisitor)
4897 }
4898 }
4899 struct GeneratedVisitor;
4900 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4901 type Value = StreamSourceInfo;
4902
4903 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4904 formatter.write_str("struct catalog.StreamSourceInfo")
4905 }
4906
4907 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSourceInfo, V::Error>
4908 where
4909 V: serde::de::MapAccess<'de>,
4910 {
4911 let mut row_format__ = None;
4912 let mut row_schema_location__ = None;
4913 let mut use_schema_registry__ = None;
4914 let mut proto_message_name__ = None;
4915 let mut csv_delimiter__ = None;
4916 let mut csv_has_header__ = None;
4917 let mut format__ = None;
4918 let mut row_encode__ = None;
4919 let mut name_strategy__ = None;
4920 let mut key_message_name__ = None;
4921 let mut external_table__ = None;
4922 let mut cdc_source_job__ = None;
4923 let mut is_distributed__ = None;
4924 let mut format_encode_options__ = None;
4925 let mut format_encode_secret_refs__ = None;
4926 let mut connection_id__ = None;
4927 while let Some(k) = map_.next_key()? {
4928 match k {
4929 GeneratedField::RowFormat => {
4930 if row_format__.is_some() {
4931 return Err(serde::de::Error::duplicate_field("rowFormat"));
4932 }
4933 row_format__ = Some(map_.next_value::<super::plan_common::RowFormatType>()? as i32);
4934 }
4935 GeneratedField::RowSchemaLocation => {
4936 if row_schema_location__.is_some() {
4937 return Err(serde::de::Error::duplicate_field("rowSchemaLocation"));
4938 }
4939 row_schema_location__ = Some(map_.next_value()?);
4940 }
4941 GeneratedField::UseSchemaRegistry => {
4942 if use_schema_registry__.is_some() {
4943 return Err(serde::de::Error::duplicate_field("useSchemaRegistry"));
4944 }
4945 use_schema_registry__ = Some(map_.next_value()?);
4946 }
4947 GeneratedField::ProtoMessageName => {
4948 if proto_message_name__.is_some() {
4949 return Err(serde::de::Error::duplicate_field("protoMessageName"));
4950 }
4951 proto_message_name__ = Some(map_.next_value()?);
4952 }
4953 GeneratedField::CsvDelimiter => {
4954 if csv_delimiter__.is_some() {
4955 return Err(serde::de::Error::duplicate_field("csvDelimiter"));
4956 }
4957 csv_delimiter__ =
4958 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4959 ;
4960 }
4961 GeneratedField::CsvHasHeader => {
4962 if csv_has_header__.is_some() {
4963 return Err(serde::de::Error::duplicate_field("csvHasHeader"));
4964 }
4965 csv_has_header__ = Some(map_.next_value()?);
4966 }
4967 GeneratedField::Format => {
4968 if format__.is_some() {
4969 return Err(serde::de::Error::duplicate_field("format"));
4970 }
4971 format__ = Some(map_.next_value::<super::plan_common::FormatType>()? as i32);
4972 }
4973 GeneratedField::RowEncode => {
4974 if row_encode__.is_some() {
4975 return Err(serde::de::Error::duplicate_field("rowEncode"));
4976 }
4977 row_encode__ = Some(map_.next_value::<super::plan_common::EncodeType>()? as i32);
4978 }
4979 GeneratedField::NameStrategy => {
4980 if name_strategy__.is_some() {
4981 return Err(serde::de::Error::duplicate_field("nameStrategy"));
4982 }
4983 name_strategy__ = Some(map_.next_value::<SchemaRegistryNameStrategy>()? as i32);
4984 }
4985 GeneratedField::KeyMessageName => {
4986 if key_message_name__.is_some() {
4987 return Err(serde::de::Error::duplicate_field("keyMessageName"));
4988 }
4989 key_message_name__ = map_.next_value()?;
4990 }
4991 GeneratedField::ExternalTable => {
4992 if external_table__.is_some() {
4993 return Err(serde::de::Error::duplicate_field("externalTable"));
4994 }
4995 external_table__ = map_.next_value()?;
4996 }
4997 GeneratedField::CdcSourceJob => {
4998 if cdc_source_job__.is_some() {
4999 return Err(serde::de::Error::duplicate_field("cdcSourceJob"));
5000 }
5001 cdc_source_job__ = Some(map_.next_value()?);
5002 }
5003 GeneratedField::IsDistributed => {
5004 if is_distributed__.is_some() {
5005 return Err(serde::de::Error::duplicate_field("isDistributed"));
5006 }
5007 is_distributed__ = Some(map_.next_value()?);
5008 }
5009 GeneratedField::FormatEncodeOptions => {
5010 if format_encode_options__.is_some() {
5011 return Err(serde::de::Error::duplicate_field("formatEncodeOptions"));
5012 }
5013 format_encode_options__ = Some(
5014 map_.next_value::<std::collections::BTreeMap<_, _>>()?
5015 );
5016 }
5017 GeneratedField::FormatEncodeSecretRefs => {
5018 if format_encode_secret_refs__.is_some() {
5019 return Err(serde::de::Error::duplicate_field("formatEncodeSecretRefs"));
5020 }
5021 format_encode_secret_refs__ = Some(
5022 map_.next_value::<std::collections::BTreeMap<_, _>>()?
5023 );
5024 }
5025 GeneratedField::ConnectionId => {
5026 if connection_id__.is_some() {
5027 return Err(serde::de::Error::duplicate_field("connectionId"));
5028 }
5029 connection_id__ =
5030 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5031 ;
5032 }
5033 }
5034 }
5035 Ok(StreamSourceInfo {
5036 row_format: row_format__.unwrap_or_default(),
5037 row_schema_location: row_schema_location__.unwrap_or_default(),
5038 use_schema_registry: use_schema_registry__.unwrap_or_default(),
5039 proto_message_name: proto_message_name__.unwrap_or_default(),
5040 csv_delimiter: csv_delimiter__.unwrap_or_default(),
5041 csv_has_header: csv_has_header__.unwrap_or_default(),
5042 format: format__.unwrap_or_default(),
5043 row_encode: row_encode__.unwrap_or_default(),
5044 name_strategy: name_strategy__.unwrap_or_default(),
5045 key_message_name: key_message_name__,
5046 external_table: external_table__,
5047 cdc_source_job: cdc_source_job__.unwrap_or_default(),
5048 is_distributed: is_distributed__.unwrap_or_default(),
5049 format_encode_options: format_encode_options__.unwrap_or_default(),
5050 format_encode_secret_refs: format_encode_secret_refs__.unwrap_or_default(),
5051 connection_id: connection_id__,
5052 })
5053 }
5054 }
5055 deserializer.deserialize_struct("catalog.StreamSourceInfo", FIELDS, GeneratedVisitor)
5056 }
5057}
5058impl serde::Serialize for Subscription {
5059 #[allow(deprecated)]
5060 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5061 where
5062 S: serde::Serializer,
5063 {
5064 use serde::ser::SerializeStruct;
5065 let mut len = 0;
5066 if self.id != 0 {
5067 len += 1;
5068 }
5069 if !self.name.is_empty() {
5070 len += 1;
5071 }
5072 if !self.definition.is_empty() {
5073 len += 1;
5074 }
5075 if self.retention_seconds != 0 {
5076 len += 1;
5077 }
5078 if self.database_id != 0 {
5079 len += 1;
5080 }
5081 if self.schema_id != 0 {
5082 len += 1;
5083 }
5084 if self.dependent_table_id != 0 {
5085 len += 1;
5086 }
5087 if self.initialized_at_epoch.is_some() {
5088 len += 1;
5089 }
5090 if self.created_at_epoch.is_some() {
5091 len += 1;
5092 }
5093 if self.owner != 0 {
5094 len += 1;
5095 }
5096 if self.initialized_at_cluster_version.is_some() {
5097 len += 1;
5098 }
5099 if self.created_at_cluster_version.is_some() {
5100 len += 1;
5101 }
5102 if self.subscription_state != 0 {
5103 len += 1;
5104 }
5105 let mut struct_ser = serializer.serialize_struct("catalog.Subscription", len)?;
5106 if self.id != 0 {
5107 struct_ser.serialize_field("id", &self.id)?;
5108 }
5109 if !self.name.is_empty() {
5110 struct_ser.serialize_field("name", &self.name)?;
5111 }
5112 if !self.definition.is_empty() {
5113 struct_ser.serialize_field("definition", &self.definition)?;
5114 }
5115 if self.retention_seconds != 0 {
5116 #[allow(clippy::needless_borrow)]
5117 #[allow(clippy::needless_borrows_for_generic_args)]
5118 struct_ser.serialize_field("retentionSeconds", ToString::to_string(&self.retention_seconds).as_str())?;
5119 }
5120 if self.database_id != 0 {
5121 struct_ser.serialize_field("databaseId", &self.database_id)?;
5122 }
5123 if self.schema_id != 0 {
5124 struct_ser.serialize_field("schemaId", &self.schema_id)?;
5125 }
5126 if self.dependent_table_id != 0 {
5127 struct_ser.serialize_field("dependentTableId", &self.dependent_table_id)?;
5128 }
5129 if let Some(v) = self.initialized_at_epoch.as_ref() {
5130 #[allow(clippy::needless_borrow)]
5131 #[allow(clippy::needless_borrows_for_generic_args)]
5132 struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
5133 }
5134 if let Some(v) = self.created_at_epoch.as_ref() {
5135 #[allow(clippy::needless_borrow)]
5136 #[allow(clippy::needless_borrows_for_generic_args)]
5137 struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
5138 }
5139 if self.owner != 0 {
5140 struct_ser.serialize_field("owner", &self.owner)?;
5141 }
5142 if let Some(v) = self.initialized_at_cluster_version.as_ref() {
5143 struct_ser.serialize_field("initializedAtClusterVersion", v)?;
5144 }
5145 if let Some(v) = self.created_at_cluster_version.as_ref() {
5146 struct_ser.serialize_field("createdAtClusterVersion", v)?;
5147 }
5148 if self.subscription_state != 0 {
5149 let v = subscription::SubscriptionState::try_from(self.subscription_state)
5150 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscription_state)))?;
5151 struct_ser.serialize_field("subscriptionState", &v)?;
5152 }
5153 struct_ser.end()
5154 }
5155}
5156impl<'de> serde::Deserialize<'de> for Subscription {
5157 #[allow(deprecated)]
5158 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5159 where
5160 D: serde::Deserializer<'de>,
5161 {
5162 const FIELDS: &[&str] = &[
5163 "id",
5164 "name",
5165 "definition",
5166 "retention_seconds",
5167 "retentionSeconds",
5168 "database_id",
5169 "databaseId",
5170 "schema_id",
5171 "schemaId",
5172 "dependent_table_id",
5173 "dependentTableId",
5174 "initialized_at_epoch",
5175 "initializedAtEpoch",
5176 "created_at_epoch",
5177 "createdAtEpoch",
5178 "owner",
5179 "initialized_at_cluster_version",
5180 "initializedAtClusterVersion",
5181 "created_at_cluster_version",
5182 "createdAtClusterVersion",
5183 "subscription_state",
5184 "subscriptionState",
5185 ];
5186
5187 #[allow(clippy::enum_variant_names)]
5188 enum GeneratedField {
5189 Id,
5190 Name,
5191 Definition,
5192 RetentionSeconds,
5193 DatabaseId,
5194 SchemaId,
5195 DependentTableId,
5196 InitializedAtEpoch,
5197 CreatedAtEpoch,
5198 Owner,
5199 InitializedAtClusterVersion,
5200 CreatedAtClusterVersion,
5201 SubscriptionState,
5202 }
5203 impl<'de> serde::Deserialize<'de> for GeneratedField {
5204 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5205 where
5206 D: serde::Deserializer<'de>,
5207 {
5208 struct GeneratedVisitor;
5209
5210 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5211 type Value = GeneratedField;
5212
5213 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5214 write!(formatter, "expected one of: {:?}", &FIELDS)
5215 }
5216
5217 #[allow(unused_variables)]
5218 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5219 where
5220 E: serde::de::Error,
5221 {
5222 match value {
5223 "id" => Ok(GeneratedField::Id),
5224 "name" => Ok(GeneratedField::Name),
5225 "definition" => Ok(GeneratedField::Definition),
5226 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
5227 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
5228 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
5229 "dependentTableId" | "dependent_table_id" => Ok(GeneratedField::DependentTableId),
5230 "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
5231 "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
5232 "owner" => Ok(GeneratedField::Owner),
5233 "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
5234 "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
5235 "subscriptionState" | "subscription_state" => Ok(GeneratedField::SubscriptionState),
5236 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5237 }
5238 }
5239 }
5240 deserializer.deserialize_identifier(GeneratedVisitor)
5241 }
5242 }
5243 struct GeneratedVisitor;
5244 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5245 type Value = Subscription;
5246
5247 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5248 formatter.write_str("struct catalog.Subscription")
5249 }
5250
5251 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Subscription, V::Error>
5252 where
5253 V: serde::de::MapAccess<'de>,
5254 {
5255 let mut id__ = None;
5256 let mut name__ = None;
5257 let mut definition__ = None;
5258 let mut retention_seconds__ = None;
5259 let mut database_id__ = None;
5260 let mut schema_id__ = None;
5261 let mut dependent_table_id__ = None;
5262 let mut initialized_at_epoch__ = None;
5263 let mut created_at_epoch__ = None;
5264 let mut owner__ = None;
5265 let mut initialized_at_cluster_version__ = None;
5266 let mut created_at_cluster_version__ = None;
5267 let mut subscription_state__ = None;
5268 while let Some(k) = map_.next_key()? {
5269 match k {
5270 GeneratedField::Id => {
5271 if id__.is_some() {
5272 return Err(serde::de::Error::duplicate_field("id"));
5273 }
5274 id__ =
5275 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5276 ;
5277 }
5278 GeneratedField::Name => {
5279 if name__.is_some() {
5280 return Err(serde::de::Error::duplicate_field("name"));
5281 }
5282 name__ = Some(map_.next_value()?);
5283 }
5284 GeneratedField::Definition => {
5285 if definition__.is_some() {
5286 return Err(serde::de::Error::duplicate_field("definition"));
5287 }
5288 definition__ = Some(map_.next_value()?);
5289 }
5290 GeneratedField::RetentionSeconds => {
5291 if retention_seconds__.is_some() {
5292 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
5293 }
5294 retention_seconds__ =
5295 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5296 ;
5297 }
5298 GeneratedField::DatabaseId => {
5299 if database_id__.is_some() {
5300 return Err(serde::de::Error::duplicate_field("databaseId"));
5301 }
5302 database_id__ =
5303 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5304 ;
5305 }
5306 GeneratedField::SchemaId => {
5307 if schema_id__.is_some() {
5308 return Err(serde::de::Error::duplicate_field("schemaId"));
5309 }
5310 schema_id__ =
5311 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5312 ;
5313 }
5314 GeneratedField::DependentTableId => {
5315 if dependent_table_id__.is_some() {
5316 return Err(serde::de::Error::duplicate_field("dependentTableId"));
5317 }
5318 dependent_table_id__ =
5319 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5320 ;
5321 }
5322 GeneratedField::InitializedAtEpoch => {
5323 if initialized_at_epoch__.is_some() {
5324 return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
5325 }
5326 initialized_at_epoch__ =
5327 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5328 ;
5329 }
5330 GeneratedField::CreatedAtEpoch => {
5331 if created_at_epoch__.is_some() {
5332 return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
5333 }
5334 created_at_epoch__ =
5335 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5336 ;
5337 }
5338 GeneratedField::Owner => {
5339 if owner__.is_some() {
5340 return Err(serde::de::Error::duplicate_field("owner"));
5341 }
5342 owner__ =
5343 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5344 ;
5345 }
5346 GeneratedField::InitializedAtClusterVersion => {
5347 if initialized_at_cluster_version__.is_some() {
5348 return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
5349 }
5350 initialized_at_cluster_version__ = map_.next_value()?;
5351 }
5352 GeneratedField::CreatedAtClusterVersion => {
5353 if created_at_cluster_version__.is_some() {
5354 return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
5355 }
5356 created_at_cluster_version__ = map_.next_value()?;
5357 }
5358 GeneratedField::SubscriptionState => {
5359 if subscription_state__.is_some() {
5360 return Err(serde::de::Error::duplicate_field("subscriptionState"));
5361 }
5362 subscription_state__ = Some(map_.next_value::<subscription::SubscriptionState>()? as i32);
5363 }
5364 }
5365 }
5366 Ok(Subscription {
5367 id: id__.unwrap_or_default(),
5368 name: name__.unwrap_or_default(),
5369 definition: definition__.unwrap_or_default(),
5370 retention_seconds: retention_seconds__.unwrap_or_default(),
5371 database_id: database_id__.unwrap_or_default(),
5372 schema_id: schema_id__.unwrap_or_default(),
5373 dependent_table_id: dependent_table_id__.unwrap_or_default(),
5374 initialized_at_epoch: initialized_at_epoch__,
5375 created_at_epoch: created_at_epoch__,
5376 owner: owner__.unwrap_or_default(),
5377 initialized_at_cluster_version: initialized_at_cluster_version__,
5378 created_at_cluster_version: created_at_cluster_version__,
5379 subscription_state: subscription_state__.unwrap_or_default(),
5380 })
5381 }
5382 }
5383 deserializer.deserialize_struct("catalog.Subscription", FIELDS, GeneratedVisitor)
5384 }
5385}
5386impl serde::Serialize for subscription::SubscriptionState {
5387 #[allow(deprecated)]
5388 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5389 where
5390 S: serde::Serializer,
5391 {
5392 let variant = match self {
5393 Self::Unspecified => "UNSPECIFIED",
5394 Self::Init => "INIT",
5395 Self::Created => "CREATED",
5396 };
5397 serializer.serialize_str(variant)
5398 }
5399}
5400impl<'de> serde::Deserialize<'de> for subscription::SubscriptionState {
5401 #[allow(deprecated)]
5402 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5403 where
5404 D: serde::Deserializer<'de>,
5405 {
5406 const FIELDS: &[&str] = &[
5407 "UNSPECIFIED",
5408 "INIT",
5409 "CREATED",
5410 ];
5411
5412 struct GeneratedVisitor;
5413
5414 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5415 type Value = subscription::SubscriptionState;
5416
5417 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5418 write!(formatter, "expected one of: {:?}", &FIELDS)
5419 }
5420
5421 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
5422 where
5423 E: serde::de::Error,
5424 {
5425 i32::try_from(v)
5426 .ok()
5427 .and_then(|x| x.try_into().ok())
5428 .ok_or_else(|| {
5429 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
5430 })
5431 }
5432
5433 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
5434 where
5435 E: serde::de::Error,
5436 {
5437 i32::try_from(v)
5438 .ok()
5439 .and_then(|x| x.try_into().ok())
5440 .ok_or_else(|| {
5441 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
5442 })
5443 }
5444
5445 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
5446 where
5447 E: serde::de::Error,
5448 {
5449 match value {
5450 "UNSPECIFIED" => Ok(subscription::SubscriptionState::Unspecified),
5451 "INIT" => Ok(subscription::SubscriptionState::Init),
5452 "CREATED" => Ok(subscription::SubscriptionState::Created),
5453 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
5454 }
5455 }
5456 }
5457 deserializer.deserialize_any(GeneratedVisitor)
5458 }
5459}
5460impl serde::Serialize for Table {
5461 #[allow(deprecated)]
5462 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5463 where
5464 S: serde::Serializer,
5465 {
5466 use serde::ser::SerializeStruct;
5467 let mut len = 0;
5468 if self.id != 0 {
5469 len += 1;
5470 }
5471 if self.schema_id != 0 {
5472 len += 1;
5473 }
5474 if self.database_id != 0 {
5475 len += 1;
5476 }
5477 if !self.name.is_empty() {
5478 len += 1;
5479 }
5480 if !self.columns.is_empty() {
5481 len += 1;
5482 }
5483 if !self.pk.is_empty() {
5484 len += 1;
5485 }
5486 if self.table_type != 0 {
5487 len += 1;
5488 }
5489 if !self.distribution_key.is_empty() {
5490 len += 1;
5491 }
5492 if !self.stream_key.is_empty() {
5493 len += 1;
5494 }
5495 if self.append_only {
5496 len += 1;
5497 }
5498 if self.owner != 0 {
5499 len += 1;
5500 }
5501 if self.fragment_id != 0 {
5502 len += 1;
5503 }
5504 if self.vnode_col_index.is_some() {
5505 len += 1;
5506 }
5507 if self.row_id_index.is_some() {
5508 len += 1;
5509 }
5510 if !self.value_indices.is_empty() {
5511 len += 1;
5512 }
5513 if !self.definition.is_empty() {
5514 len += 1;
5515 }
5516 if self.handle_pk_conflict_behavior != 0 {
5517 len += 1;
5518 }
5519 if self.read_prefix_len_hint != 0 {
5520 len += 1;
5521 }
5522 if !self.watermark_indices.is_empty() {
5523 len += 1;
5524 }
5525 if !self.dist_key_in_pk.is_empty() {
5526 len += 1;
5527 }
5528 if self.dml_fragment_id.is_some() {
5529 len += 1;
5530 }
5531 if self.cardinality.is_some() {
5532 len += 1;
5533 }
5534 if self.initialized_at_epoch.is_some() {
5535 len += 1;
5536 }
5537 if self.created_at_epoch.is_some() {
5538 len += 1;
5539 }
5540 if self.cleaned_by_watermark {
5541 len += 1;
5542 }
5543 if self.stream_job_status != 0 {
5544 len += 1;
5545 }
5546 if self.create_type != 0 {
5547 len += 1;
5548 }
5549 if self.description.is_some() {
5550 len += 1;
5551 }
5552 if !self.incoming_sinks.is_empty() {
5553 len += 1;
5554 }
5555 if self.initialized_at_cluster_version.is_some() {
5556 len += 1;
5557 }
5558 if self.created_at_cluster_version.is_some() {
5559 len += 1;
5560 }
5561 if self.retention_seconds.is_some() {
5562 len += 1;
5563 }
5564 if !self.version_column_indices.is_empty() {
5565 len += 1;
5566 }
5567 if self.cdc_table_id.is_some() {
5568 len += 1;
5569 }
5570 if self.maybe_vnode_count.is_some() {
5571 len += 1;
5572 }
5573 if self.webhook_info.is_some() {
5574 len += 1;
5575 }
5576 if self.job_id.is_some() {
5577 len += 1;
5578 }
5579 if self.engine.is_some() {
5580 len += 1;
5581 }
5582 if self.clean_watermark_index_in_pk.is_some() {
5583 len += 1;
5584 }
5585 if self.refreshable {
5586 len += 1;
5587 }
5588 if self.vector_index_info.is_some() {
5589 len += 1;
5590 }
5591 if self.cdc_table_type.is_some() {
5592 len += 1;
5593 }
5594 if self.refresh_state.is_some() {
5595 len += 1;
5596 }
5597 if self.version.is_some() {
5598 len += 1;
5599 }
5600 if self.optional_associated_source_id.is_some() {
5601 len += 1;
5602 }
5603 let mut struct_ser = serializer.serialize_struct("catalog.Table", len)?;
5604 if self.id != 0 {
5605 struct_ser.serialize_field("id", &self.id)?;
5606 }
5607 if self.schema_id != 0 {
5608 struct_ser.serialize_field("schemaId", &self.schema_id)?;
5609 }
5610 if self.database_id != 0 {
5611 struct_ser.serialize_field("databaseId", &self.database_id)?;
5612 }
5613 if !self.name.is_empty() {
5614 struct_ser.serialize_field("name", &self.name)?;
5615 }
5616 if !self.columns.is_empty() {
5617 struct_ser.serialize_field("columns", &self.columns)?;
5618 }
5619 if !self.pk.is_empty() {
5620 struct_ser.serialize_field("pk", &self.pk)?;
5621 }
5622 if self.table_type != 0 {
5623 let v = table::TableType::try_from(self.table_type)
5624 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.table_type)))?;
5625 struct_ser.serialize_field("tableType", &v)?;
5626 }
5627 if !self.distribution_key.is_empty() {
5628 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
5629 }
5630 if !self.stream_key.is_empty() {
5631 struct_ser.serialize_field("streamKey", &self.stream_key)?;
5632 }
5633 if self.append_only {
5634 struct_ser.serialize_field("appendOnly", &self.append_only)?;
5635 }
5636 if self.owner != 0 {
5637 struct_ser.serialize_field("owner", &self.owner)?;
5638 }
5639 if self.fragment_id != 0 {
5640 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5641 }
5642 if let Some(v) = self.vnode_col_index.as_ref() {
5643 struct_ser.serialize_field("vnodeColIndex", v)?;
5644 }
5645 if let Some(v) = self.row_id_index.as_ref() {
5646 struct_ser.serialize_field("rowIdIndex", v)?;
5647 }
5648 if !self.value_indices.is_empty() {
5649 struct_ser.serialize_field("valueIndices", &self.value_indices)?;
5650 }
5651 if !self.definition.is_empty() {
5652 struct_ser.serialize_field("definition", &self.definition)?;
5653 }
5654 if self.handle_pk_conflict_behavior != 0 {
5655 let v = HandleConflictBehavior::try_from(self.handle_pk_conflict_behavior)
5656 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.handle_pk_conflict_behavior)))?;
5657 struct_ser.serialize_field("handlePkConflictBehavior", &v)?;
5658 }
5659 if self.read_prefix_len_hint != 0 {
5660 struct_ser.serialize_field("readPrefixLenHint", &self.read_prefix_len_hint)?;
5661 }
5662 if !self.watermark_indices.is_empty() {
5663 struct_ser.serialize_field("watermarkIndices", &self.watermark_indices)?;
5664 }
5665 if !self.dist_key_in_pk.is_empty() {
5666 struct_ser.serialize_field("distKeyInPk", &self.dist_key_in_pk)?;
5667 }
5668 if let Some(v) = self.dml_fragment_id.as_ref() {
5669 struct_ser.serialize_field("dmlFragmentId", v)?;
5670 }
5671 if let Some(v) = self.cardinality.as_ref() {
5672 struct_ser.serialize_field("cardinality", v)?;
5673 }
5674 if let Some(v) = self.initialized_at_epoch.as_ref() {
5675 #[allow(clippy::needless_borrow)]
5676 #[allow(clippy::needless_borrows_for_generic_args)]
5677 struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
5678 }
5679 if let Some(v) = self.created_at_epoch.as_ref() {
5680 #[allow(clippy::needless_borrow)]
5681 #[allow(clippy::needless_borrows_for_generic_args)]
5682 struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
5683 }
5684 if self.cleaned_by_watermark {
5685 struct_ser.serialize_field("cleanedByWatermark", &self.cleaned_by_watermark)?;
5686 }
5687 if self.stream_job_status != 0 {
5688 let v = StreamJobStatus::try_from(self.stream_job_status)
5689 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_job_status)))?;
5690 struct_ser.serialize_field("streamJobStatus", &v)?;
5691 }
5692 if self.create_type != 0 {
5693 let v = CreateType::try_from(self.create_type)
5694 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.create_type)))?;
5695 struct_ser.serialize_field("createType", &v)?;
5696 }
5697 if let Some(v) = self.description.as_ref() {
5698 struct_ser.serialize_field("description", v)?;
5699 }
5700 if !self.incoming_sinks.is_empty() {
5701 struct_ser.serialize_field("incomingSinks", &self.incoming_sinks)?;
5702 }
5703 if let Some(v) = self.initialized_at_cluster_version.as_ref() {
5704 struct_ser.serialize_field("initializedAtClusterVersion", v)?;
5705 }
5706 if let Some(v) = self.created_at_cluster_version.as_ref() {
5707 struct_ser.serialize_field("createdAtClusterVersion", v)?;
5708 }
5709 if let Some(v) = self.retention_seconds.as_ref() {
5710 struct_ser.serialize_field("retentionSeconds", v)?;
5711 }
5712 if !self.version_column_indices.is_empty() {
5713 struct_ser.serialize_field("versionColumnIndices", &self.version_column_indices)?;
5714 }
5715 if let Some(v) = self.cdc_table_id.as_ref() {
5716 struct_ser.serialize_field("cdcTableId", v)?;
5717 }
5718 if let Some(v) = self.maybe_vnode_count.as_ref() {
5719 struct_ser.serialize_field("maybeVnodeCount", v)?;
5720 }
5721 if let Some(v) = self.webhook_info.as_ref() {
5722 struct_ser.serialize_field("webhookInfo", v)?;
5723 }
5724 if let Some(v) = self.job_id.as_ref() {
5725 struct_ser.serialize_field("jobId", v)?;
5726 }
5727 if let Some(v) = self.engine.as_ref() {
5728 let v = table::Engine::try_from(*v)
5729 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
5730 struct_ser.serialize_field("engine", &v)?;
5731 }
5732 if let Some(v) = self.clean_watermark_index_in_pk.as_ref() {
5733 struct_ser.serialize_field("cleanWatermarkIndexInPk", v)?;
5734 }
5735 if self.refreshable {
5736 struct_ser.serialize_field("refreshable", &self.refreshable)?;
5737 }
5738 if let Some(v) = self.vector_index_info.as_ref() {
5739 struct_ser.serialize_field("vectorIndexInfo", v)?;
5740 }
5741 if let Some(v) = self.cdc_table_type.as_ref() {
5742 let v = table::CdcTableType::try_from(*v)
5743 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
5744 struct_ser.serialize_field("cdcTableType", &v)?;
5745 }
5746 if let Some(v) = self.refresh_state.as_ref() {
5747 let v = RefreshState::try_from(*v)
5748 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
5749 struct_ser.serialize_field("refreshState", &v)?;
5750 }
5751 if let Some(v) = self.version.as_ref() {
5752 struct_ser.serialize_field("version", v)?;
5753 }
5754 if let Some(v) = self.optional_associated_source_id.as_ref() {
5755 match v {
5756 table::OptionalAssociatedSourceId::AssociatedSourceId(v) => {
5757 struct_ser.serialize_field("associatedSourceId", v)?;
5758 }
5759 }
5760 }
5761 struct_ser.end()
5762 }
5763}
5764impl<'de> serde::Deserialize<'de> for Table {
5765 #[allow(deprecated)]
5766 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5767 where
5768 D: serde::Deserializer<'de>,
5769 {
5770 const FIELDS: &[&str] = &[
5771 "id",
5772 "schema_id",
5773 "schemaId",
5774 "database_id",
5775 "databaseId",
5776 "name",
5777 "columns",
5778 "pk",
5779 "table_type",
5780 "tableType",
5781 "distribution_key",
5782 "distributionKey",
5783 "stream_key",
5784 "streamKey",
5785 "append_only",
5786 "appendOnly",
5787 "owner",
5788 "fragment_id",
5789 "fragmentId",
5790 "vnode_col_index",
5791 "vnodeColIndex",
5792 "row_id_index",
5793 "rowIdIndex",
5794 "value_indices",
5795 "valueIndices",
5796 "definition",
5797 "handle_pk_conflict_behavior",
5798 "handlePkConflictBehavior",
5799 "read_prefix_len_hint",
5800 "readPrefixLenHint",
5801 "watermark_indices",
5802 "watermarkIndices",
5803 "dist_key_in_pk",
5804 "distKeyInPk",
5805 "dml_fragment_id",
5806 "dmlFragmentId",
5807 "cardinality",
5808 "initialized_at_epoch",
5809 "initializedAtEpoch",
5810 "created_at_epoch",
5811 "createdAtEpoch",
5812 "cleaned_by_watermark",
5813 "cleanedByWatermark",
5814 "stream_job_status",
5815 "streamJobStatus",
5816 "create_type",
5817 "createType",
5818 "description",
5819 "incoming_sinks",
5820 "incomingSinks",
5821 "initialized_at_cluster_version",
5822 "initializedAtClusterVersion",
5823 "created_at_cluster_version",
5824 "createdAtClusterVersion",
5825 "retention_seconds",
5826 "retentionSeconds",
5827 "version_column_indices",
5828 "versionColumnIndices",
5829 "cdc_table_id",
5830 "cdcTableId",
5831 "maybe_vnode_count",
5832 "maybeVnodeCount",
5833 "webhook_info",
5834 "webhookInfo",
5835 "job_id",
5836 "jobId",
5837 "engine",
5838 "clean_watermark_index_in_pk",
5839 "cleanWatermarkIndexInPk",
5840 "refreshable",
5841 "vector_index_info",
5842 "vectorIndexInfo",
5843 "cdc_table_type",
5844 "cdcTableType",
5845 "refresh_state",
5846 "refreshState",
5847 "version",
5848 "associated_source_id",
5849 "associatedSourceId",
5850 ];
5851
5852 #[allow(clippy::enum_variant_names)]
5853 enum GeneratedField {
5854 Id,
5855 SchemaId,
5856 DatabaseId,
5857 Name,
5858 Columns,
5859 Pk,
5860 TableType,
5861 DistributionKey,
5862 StreamKey,
5863 AppendOnly,
5864 Owner,
5865 FragmentId,
5866 VnodeColIndex,
5867 RowIdIndex,
5868 ValueIndices,
5869 Definition,
5870 HandlePkConflictBehavior,
5871 ReadPrefixLenHint,
5872 WatermarkIndices,
5873 DistKeyInPk,
5874 DmlFragmentId,
5875 Cardinality,
5876 InitializedAtEpoch,
5877 CreatedAtEpoch,
5878 CleanedByWatermark,
5879 StreamJobStatus,
5880 CreateType,
5881 Description,
5882 IncomingSinks,
5883 InitializedAtClusterVersion,
5884 CreatedAtClusterVersion,
5885 RetentionSeconds,
5886 VersionColumnIndices,
5887 CdcTableId,
5888 MaybeVnodeCount,
5889 WebhookInfo,
5890 JobId,
5891 Engine,
5892 CleanWatermarkIndexInPk,
5893 Refreshable,
5894 VectorIndexInfo,
5895 CdcTableType,
5896 RefreshState,
5897 Version,
5898 AssociatedSourceId,
5899 }
5900 impl<'de> serde::Deserialize<'de> for GeneratedField {
5901 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5902 where
5903 D: serde::Deserializer<'de>,
5904 {
5905 struct GeneratedVisitor;
5906
5907 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5908 type Value = GeneratedField;
5909
5910 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5911 write!(formatter, "expected one of: {:?}", &FIELDS)
5912 }
5913
5914 #[allow(unused_variables)]
5915 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5916 where
5917 E: serde::de::Error,
5918 {
5919 match value {
5920 "id" => Ok(GeneratedField::Id),
5921 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
5922 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
5923 "name" => Ok(GeneratedField::Name),
5924 "columns" => Ok(GeneratedField::Columns),
5925 "pk" => Ok(GeneratedField::Pk),
5926 "tableType" | "table_type" => Ok(GeneratedField::TableType),
5927 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
5928 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
5929 "appendOnly" | "append_only" => Ok(GeneratedField::AppendOnly),
5930 "owner" => Ok(GeneratedField::Owner),
5931 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5932 "vnodeColIndex" | "vnode_col_index" => Ok(GeneratedField::VnodeColIndex),
5933 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
5934 "valueIndices" | "value_indices" => Ok(GeneratedField::ValueIndices),
5935 "definition" => Ok(GeneratedField::Definition),
5936 "handlePkConflictBehavior" | "handle_pk_conflict_behavior" => Ok(GeneratedField::HandlePkConflictBehavior),
5937 "readPrefixLenHint" | "read_prefix_len_hint" => Ok(GeneratedField::ReadPrefixLenHint),
5938 "watermarkIndices" | "watermark_indices" => Ok(GeneratedField::WatermarkIndices),
5939 "distKeyInPk" | "dist_key_in_pk" => Ok(GeneratedField::DistKeyInPk),
5940 "dmlFragmentId" | "dml_fragment_id" => Ok(GeneratedField::DmlFragmentId),
5941 "cardinality" => Ok(GeneratedField::Cardinality),
5942 "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
5943 "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
5944 "cleanedByWatermark" | "cleaned_by_watermark" => Ok(GeneratedField::CleanedByWatermark),
5945 "streamJobStatus" | "stream_job_status" => Ok(GeneratedField::StreamJobStatus),
5946 "createType" | "create_type" => Ok(GeneratedField::CreateType),
5947 "description" => Ok(GeneratedField::Description),
5948 "incomingSinks" | "incoming_sinks" => Ok(GeneratedField::IncomingSinks),
5949 "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
5950 "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
5951 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
5952 "versionColumnIndices" | "version_column_indices" => Ok(GeneratedField::VersionColumnIndices),
5953 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
5954 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
5955 "webhookInfo" | "webhook_info" => Ok(GeneratedField::WebhookInfo),
5956 "jobId" | "job_id" => Ok(GeneratedField::JobId),
5957 "engine" => Ok(GeneratedField::Engine),
5958 "cleanWatermarkIndexInPk" | "clean_watermark_index_in_pk" => Ok(GeneratedField::CleanWatermarkIndexInPk),
5959 "refreshable" => Ok(GeneratedField::Refreshable),
5960 "vectorIndexInfo" | "vector_index_info" => Ok(GeneratedField::VectorIndexInfo),
5961 "cdcTableType" | "cdc_table_type" => Ok(GeneratedField::CdcTableType),
5962 "refreshState" | "refresh_state" => Ok(GeneratedField::RefreshState),
5963 "version" => Ok(GeneratedField::Version),
5964 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
5965 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5966 }
5967 }
5968 }
5969 deserializer.deserialize_identifier(GeneratedVisitor)
5970 }
5971 }
5972 struct GeneratedVisitor;
5973 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5974 type Value = Table;
5975
5976 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5977 formatter.write_str("struct catalog.Table")
5978 }
5979
5980 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Table, V::Error>
5981 where
5982 V: serde::de::MapAccess<'de>,
5983 {
5984 let mut id__ = None;
5985 let mut schema_id__ = None;
5986 let mut database_id__ = None;
5987 let mut name__ = None;
5988 let mut columns__ = None;
5989 let mut pk__ = None;
5990 let mut table_type__ = None;
5991 let mut distribution_key__ = None;
5992 let mut stream_key__ = None;
5993 let mut append_only__ = None;
5994 let mut owner__ = None;
5995 let mut fragment_id__ = None;
5996 let mut vnode_col_index__ = None;
5997 let mut row_id_index__ = None;
5998 let mut value_indices__ = None;
5999 let mut definition__ = None;
6000 let mut handle_pk_conflict_behavior__ = None;
6001 let mut read_prefix_len_hint__ = None;
6002 let mut watermark_indices__ = None;
6003 let mut dist_key_in_pk__ = None;
6004 let mut dml_fragment_id__ = None;
6005 let mut cardinality__ = None;
6006 let mut initialized_at_epoch__ = None;
6007 let mut created_at_epoch__ = None;
6008 let mut cleaned_by_watermark__ = None;
6009 let mut stream_job_status__ = None;
6010 let mut create_type__ = None;
6011 let mut description__ = None;
6012 let mut incoming_sinks__ = None;
6013 let mut initialized_at_cluster_version__ = None;
6014 let mut created_at_cluster_version__ = None;
6015 let mut retention_seconds__ = None;
6016 let mut version_column_indices__ = None;
6017 let mut cdc_table_id__ = None;
6018 let mut maybe_vnode_count__ = None;
6019 let mut webhook_info__ = None;
6020 let mut job_id__ = None;
6021 let mut engine__ = None;
6022 let mut clean_watermark_index_in_pk__ = None;
6023 let mut refreshable__ = None;
6024 let mut vector_index_info__ = None;
6025 let mut cdc_table_type__ = None;
6026 let mut refresh_state__ = None;
6027 let mut version__ = None;
6028 let mut optional_associated_source_id__ = None;
6029 while let Some(k) = map_.next_key()? {
6030 match k {
6031 GeneratedField::Id => {
6032 if id__.is_some() {
6033 return Err(serde::de::Error::duplicate_field("id"));
6034 }
6035 id__ =
6036 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6037 ;
6038 }
6039 GeneratedField::SchemaId => {
6040 if schema_id__.is_some() {
6041 return Err(serde::de::Error::duplicate_field("schemaId"));
6042 }
6043 schema_id__ =
6044 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6045 ;
6046 }
6047 GeneratedField::DatabaseId => {
6048 if database_id__.is_some() {
6049 return Err(serde::de::Error::duplicate_field("databaseId"));
6050 }
6051 database_id__ =
6052 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6053 ;
6054 }
6055 GeneratedField::Name => {
6056 if name__.is_some() {
6057 return Err(serde::de::Error::duplicate_field("name"));
6058 }
6059 name__ = Some(map_.next_value()?);
6060 }
6061 GeneratedField::Columns => {
6062 if columns__.is_some() {
6063 return Err(serde::de::Error::duplicate_field("columns"));
6064 }
6065 columns__ = Some(map_.next_value()?);
6066 }
6067 GeneratedField::Pk => {
6068 if pk__.is_some() {
6069 return Err(serde::de::Error::duplicate_field("pk"));
6070 }
6071 pk__ = Some(map_.next_value()?);
6072 }
6073 GeneratedField::TableType => {
6074 if table_type__.is_some() {
6075 return Err(serde::de::Error::duplicate_field("tableType"));
6076 }
6077 table_type__ = Some(map_.next_value::<table::TableType>()? as i32);
6078 }
6079 GeneratedField::DistributionKey => {
6080 if distribution_key__.is_some() {
6081 return Err(serde::de::Error::duplicate_field("distributionKey"));
6082 }
6083 distribution_key__ =
6084 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6085 .into_iter().map(|x| x.0).collect())
6086 ;
6087 }
6088 GeneratedField::StreamKey => {
6089 if stream_key__.is_some() {
6090 return Err(serde::de::Error::duplicate_field("streamKey"));
6091 }
6092 stream_key__ =
6093 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6094 .into_iter().map(|x| x.0).collect())
6095 ;
6096 }
6097 GeneratedField::AppendOnly => {
6098 if append_only__.is_some() {
6099 return Err(serde::de::Error::duplicate_field("appendOnly"));
6100 }
6101 append_only__ = Some(map_.next_value()?);
6102 }
6103 GeneratedField::Owner => {
6104 if owner__.is_some() {
6105 return Err(serde::de::Error::duplicate_field("owner"));
6106 }
6107 owner__ =
6108 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6109 ;
6110 }
6111 GeneratedField::FragmentId => {
6112 if fragment_id__.is_some() {
6113 return Err(serde::de::Error::duplicate_field("fragmentId"));
6114 }
6115 fragment_id__ =
6116 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6117 ;
6118 }
6119 GeneratedField::VnodeColIndex => {
6120 if vnode_col_index__.is_some() {
6121 return Err(serde::de::Error::duplicate_field("vnodeColIndex"));
6122 }
6123 vnode_col_index__ =
6124 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6125 ;
6126 }
6127 GeneratedField::RowIdIndex => {
6128 if row_id_index__.is_some() {
6129 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
6130 }
6131 row_id_index__ =
6132 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6133 ;
6134 }
6135 GeneratedField::ValueIndices => {
6136 if value_indices__.is_some() {
6137 return Err(serde::de::Error::duplicate_field("valueIndices"));
6138 }
6139 value_indices__ =
6140 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6141 .into_iter().map(|x| x.0).collect())
6142 ;
6143 }
6144 GeneratedField::Definition => {
6145 if definition__.is_some() {
6146 return Err(serde::de::Error::duplicate_field("definition"));
6147 }
6148 definition__ = Some(map_.next_value()?);
6149 }
6150 GeneratedField::HandlePkConflictBehavior => {
6151 if handle_pk_conflict_behavior__.is_some() {
6152 return Err(serde::de::Error::duplicate_field("handlePkConflictBehavior"));
6153 }
6154 handle_pk_conflict_behavior__ = Some(map_.next_value::<HandleConflictBehavior>()? as i32);
6155 }
6156 GeneratedField::ReadPrefixLenHint => {
6157 if read_prefix_len_hint__.is_some() {
6158 return Err(serde::de::Error::duplicate_field("readPrefixLenHint"));
6159 }
6160 read_prefix_len_hint__ =
6161 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6162 ;
6163 }
6164 GeneratedField::WatermarkIndices => {
6165 if watermark_indices__.is_some() {
6166 return Err(serde::de::Error::duplicate_field("watermarkIndices"));
6167 }
6168 watermark_indices__ =
6169 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6170 .into_iter().map(|x| x.0).collect())
6171 ;
6172 }
6173 GeneratedField::DistKeyInPk => {
6174 if dist_key_in_pk__.is_some() {
6175 return Err(serde::de::Error::duplicate_field("distKeyInPk"));
6176 }
6177 dist_key_in_pk__ =
6178 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6179 .into_iter().map(|x| x.0).collect())
6180 ;
6181 }
6182 GeneratedField::DmlFragmentId => {
6183 if dml_fragment_id__.is_some() {
6184 return Err(serde::de::Error::duplicate_field("dmlFragmentId"));
6185 }
6186 dml_fragment_id__ =
6187 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6188 ;
6189 }
6190 GeneratedField::Cardinality => {
6191 if cardinality__.is_some() {
6192 return Err(serde::de::Error::duplicate_field("cardinality"));
6193 }
6194 cardinality__ = map_.next_value()?;
6195 }
6196 GeneratedField::InitializedAtEpoch => {
6197 if initialized_at_epoch__.is_some() {
6198 return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
6199 }
6200 initialized_at_epoch__ =
6201 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6202 ;
6203 }
6204 GeneratedField::CreatedAtEpoch => {
6205 if created_at_epoch__.is_some() {
6206 return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
6207 }
6208 created_at_epoch__ =
6209 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6210 ;
6211 }
6212 GeneratedField::CleanedByWatermark => {
6213 if cleaned_by_watermark__.is_some() {
6214 return Err(serde::de::Error::duplicate_field("cleanedByWatermark"));
6215 }
6216 cleaned_by_watermark__ = Some(map_.next_value()?);
6217 }
6218 GeneratedField::StreamJobStatus => {
6219 if stream_job_status__.is_some() {
6220 return Err(serde::de::Error::duplicate_field("streamJobStatus"));
6221 }
6222 stream_job_status__ = Some(map_.next_value::<StreamJobStatus>()? as i32);
6223 }
6224 GeneratedField::CreateType => {
6225 if create_type__.is_some() {
6226 return Err(serde::de::Error::duplicate_field("createType"));
6227 }
6228 create_type__ = Some(map_.next_value::<CreateType>()? as i32);
6229 }
6230 GeneratedField::Description => {
6231 if description__.is_some() {
6232 return Err(serde::de::Error::duplicate_field("description"));
6233 }
6234 description__ = map_.next_value()?;
6235 }
6236 GeneratedField::IncomingSinks => {
6237 if incoming_sinks__.is_some() {
6238 return Err(serde::de::Error::duplicate_field("incomingSinks"));
6239 }
6240 incoming_sinks__ =
6241 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6242 .into_iter().map(|x| x.0).collect())
6243 ;
6244 }
6245 GeneratedField::InitializedAtClusterVersion => {
6246 if initialized_at_cluster_version__.is_some() {
6247 return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
6248 }
6249 initialized_at_cluster_version__ = map_.next_value()?;
6250 }
6251 GeneratedField::CreatedAtClusterVersion => {
6252 if created_at_cluster_version__.is_some() {
6253 return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
6254 }
6255 created_at_cluster_version__ = map_.next_value()?;
6256 }
6257 GeneratedField::RetentionSeconds => {
6258 if retention_seconds__.is_some() {
6259 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
6260 }
6261 retention_seconds__ =
6262 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6263 ;
6264 }
6265 GeneratedField::VersionColumnIndices => {
6266 if version_column_indices__.is_some() {
6267 return Err(serde::de::Error::duplicate_field("versionColumnIndices"));
6268 }
6269 version_column_indices__ =
6270 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6271 .into_iter().map(|x| x.0).collect())
6272 ;
6273 }
6274 GeneratedField::CdcTableId => {
6275 if cdc_table_id__.is_some() {
6276 return Err(serde::de::Error::duplicate_field("cdcTableId"));
6277 }
6278 cdc_table_id__ = map_.next_value()?;
6279 }
6280 GeneratedField::MaybeVnodeCount => {
6281 if maybe_vnode_count__.is_some() {
6282 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
6283 }
6284 maybe_vnode_count__ =
6285 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6286 ;
6287 }
6288 GeneratedField::WebhookInfo => {
6289 if webhook_info__.is_some() {
6290 return Err(serde::de::Error::duplicate_field("webhookInfo"));
6291 }
6292 webhook_info__ = map_.next_value()?;
6293 }
6294 GeneratedField::JobId => {
6295 if job_id__.is_some() {
6296 return Err(serde::de::Error::duplicate_field("jobId"));
6297 }
6298 job_id__ =
6299 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6300 ;
6301 }
6302 GeneratedField::Engine => {
6303 if engine__.is_some() {
6304 return Err(serde::de::Error::duplicate_field("engine"));
6305 }
6306 engine__ = map_.next_value::<::std::option::Option<table::Engine>>()?.map(|x| x as i32);
6307 }
6308 GeneratedField::CleanWatermarkIndexInPk => {
6309 if clean_watermark_index_in_pk__.is_some() {
6310 return Err(serde::de::Error::duplicate_field("cleanWatermarkIndexInPk"));
6311 }
6312 clean_watermark_index_in_pk__ =
6313 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6314 ;
6315 }
6316 GeneratedField::Refreshable => {
6317 if refreshable__.is_some() {
6318 return Err(serde::de::Error::duplicate_field("refreshable"));
6319 }
6320 refreshable__ = Some(map_.next_value()?);
6321 }
6322 GeneratedField::VectorIndexInfo => {
6323 if vector_index_info__.is_some() {
6324 return Err(serde::de::Error::duplicate_field("vectorIndexInfo"));
6325 }
6326 vector_index_info__ = map_.next_value()?;
6327 }
6328 GeneratedField::CdcTableType => {
6329 if cdc_table_type__.is_some() {
6330 return Err(serde::de::Error::duplicate_field("cdcTableType"));
6331 }
6332 cdc_table_type__ = map_.next_value::<::std::option::Option<table::CdcTableType>>()?.map(|x| x as i32);
6333 }
6334 GeneratedField::RefreshState => {
6335 if refresh_state__.is_some() {
6336 return Err(serde::de::Error::duplicate_field("refreshState"));
6337 }
6338 refresh_state__ = map_.next_value::<::std::option::Option<RefreshState>>()?.map(|x| x as i32);
6339 }
6340 GeneratedField::Version => {
6341 if version__.is_some() {
6342 return Err(serde::de::Error::duplicate_field("version"));
6343 }
6344 version__ = map_.next_value()?;
6345 }
6346 GeneratedField::AssociatedSourceId => {
6347 if optional_associated_source_id__.is_some() {
6348 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
6349 }
6350 optional_associated_source_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| table::OptionalAssociatedSourceId::AssociatedSourceId(x.0));
6351 }
6352 }
6353 }
6354 Ok(Table {
6355 id: id__.unwrap_or_default(),
6356 schema_id: schema_id__.unwrap_or_default(),
6357 database_id: database_id__.unwrap_or_default(),
6358 name: name__.unwrap_or_default(),
6359 columns: columns__.unwrap_or_default(),
6360 pk: pk__.unwrap_or_default(),
6361 table_type: table_type__.unwrap_or_default(),
6362 distribution_key: distribution_key__.unwrap_or_default(),
6363 stream_key: stream_key__.unwrap_or_default(),
6364 append_only: append_only__.unwrap_or_default(),
6365 owner: owner__.unwrap_or_default(),
6366 fragment_id: fragment_id__.unwrap_or_default(),
6367 vnode_col_index: vnode_col_index__,
6368 row_id_index: row_id_index__,
6369 value_indices: value_indices__.unwrap_or_default(),
6370 definition: definition__.unwrap_or_default(),
6371 handle_pk_conflict_behavior: handle_pk_conflict_behavior__.unwrap_or_default(),
6372 read_prefix_len_hint: read_prefix_len_hint__.unwrap_or_default(),
6373 watermark_indices: watermark_indices__.unwrap_or_default(),
6374 dist_key_in_pk: dist_key_in_pk__.unwrap_or_default(),
6375 dml_fragment_id: dml_fragment_id__,
6376 cardinality: cardinality__,
6377 initialized_at_epoch: initialized_at_epoch__,
6378 created_at_epoch: created_at_epoch__,
6379 cleaned_by_watermark: cleaned_by_watermark__.unwrap_or_default(),
6380 stream_job_status: stream_job_status__.unwrap_or_default(),
6381 create_type: create_type__.unwrap_or_default(),
6382 description: description__,
6383 incoming_sinks: incoming_sinks__.unwrap_or_default(),
6384 initialized_at_cluster_version: initialized_at_cluster_version__,
6385 created_at_cluster_version: created_at_cluster_version__,
6386 retention_seconds: retention_seconds__,
6387 version_column_indices: version_column_indices__.unwrap_or_default(),
6388 cdc_table_id: cdc_table_id__,
6389 maybe_vnode_count: maybe_vnode_count__,
6390 webhook_info: webhook_info__,
6391 job_id: job_id__,
6392 engine: engine__,
6393 clean_watermark_index_in_pk: clean_watermark_index_in_pk__,
6394 refreshable: refreshable__.unwrap_or_default(),
6395 vector_index_info: vector_index_info__,
6396 cdc_table_type: cdc_table_type__,
6397 refresh_state: refresh_state__,
6398 version: version__,
6399 optional_associated_source_id: optional_associated_source_id__,
6400 })
6401 }
6402 }
6403 deserializer.deserialize_struct("catalog.Table", FIELDS, GeneratedVisitor)
6404 }
6405}
6406impl serde::Serialize for table::CdcTableType {
6407 #[allow(deprecated)]
6408 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6409 where
6410 S: serde::Serializer,
6411 {
6412 let variant = match self {
6413 Self::Unspecified => "CDC_TABLE_TYPE_UNSPECIFIED",
6414 Self::Postgres => "CDC_TABLE_TYPE_POSTGRES",
6415 Self::Mysql => "CDC_TABLE_TYPE_MYSQL",
6416 Self::Sqlserver => "CDC_TABLE_TYPE_SQLSERVER",
6417 Self::Mongo => "CDC_TABLE_TYPE_MONGO",
6418 Self::Citus => "CDC_TABLE_TYPE_CITUS",
6419 };
6420 serializer.serialize_str(variant)
6421 }
6422}
6423impl<'de> serde::Deserialize<'de> for table::CdcTableType {
6424 #[allow(deprecated)]
6425 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6426 where
6427 D: serde::Deserializer<'de>,
6428 {
6429 const FIELDS: &[&str] = &[
6430 "CDC_TABLE_TYPE_UNSPECIFIED",
6431 "CDC_TABLE_TYPE_POSTGRES",
6432 "CDC_TABLE_TYPE_MYSQL",
6433 "CDC_TABLE_TYPE_SQLSERVER",
6434 "CDC_TABLE_TYPE_MONGO",
6435 "CDC_TABLE_TYPE_CITUS",
6436 ];
6437
6438 struct GeneratedVisitor;
6439
6440 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6441 type Value = table::CdcTableType;
6442
6443 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6444 write!(formatter, "expected one of: {:?}", &FIELDS)
6445 }
6446
6447 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6448 where
6449 E: serde::de::Error,
6450 {
6451 i32::try_from(v)
6452 .ok()
6453 .and_then(|x| x.try_into().ok())
6454 .ok_or_else(|| {
6455 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6456 })
6457 }
6458
6459 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6460 where
6461 E: serde::de::Error,
6462 {
6463 i32::try_from(v)
6464 .ok()
6465 .and_then(|x| x.try_into().ok())
6466 .ok_or_else(|| {
6467 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6468 })
6469 }
6470
6471 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6472 where
6473 E: serde::de::Error,
6474 {
6475 match value {
6476 "CDC_TABLE_TYPE_UNSPECIFIED" => Ok(table::CdcTableType::Unspecified),
6477 "CDC_TABLE_TYPE_POSTGRES" => Ok(table::CdcTableType::Postgres),
6478 "CDC_TABLE_TYPE_MYSQL" => Ok(table::CdcTableType::Mysql),
6479 "CDC_TABLE_TYPE_SQLSERVER" => Ok(table::CdcTableType::Sqlserver),
6480 "CDC_TABLE_TYPE_MONGO" => Ok(table::CdcTableType::Mongo),
6481 "CDC_TABLE_TYPE_CITUS" => Ok(table::CdcTableType::Citus),
6482 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6483 }
6484 }
6485 }
6486 deserializer.deserialize_any(GeneratedVisitor)
6487 }
6488}
6489impl serde::Serialize for table::Engine {
6490 #[allow(deprecated)]
6491 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6492 where
6493 S: serde::Serializer,
6494 {
6495 let variant = match self {
6496 Self::Unspecified => "ENGINE_UNSPECIFIED",
6497 Self::Hummock => "HUMMOCK",
6498 Self::Iceberg => "ICEBERG",
6499 };
6500 serializer.serialize_str(variant)
6501 }
6502}
6503impl<'de> serde::Deserialize<'de> for table::Engine {
6504 #[allow(deprecated)]
6505 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6506 where
6507 D: serde::Deserializer<'de>,
6508 {
6509 const FIELDS: &[&str] = &[
6510 "ENGINE_UNSPECIFIED",
6511 "HUMMOCK",
6512 "ICEBERG",
6513 ];
6514
6515 struct GeneratedVisitor;
6516
6517 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6518 type Value = table::Engine;
6519
6520 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6521 write!(formatter, "expected one of: {:?}", &FIELDS)
6522 }
6523
6524 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6525 where
6526 E: serde::de::Error,
6527 {
6528 i32::try_from(v)
6529 .ok()
6530 .and_then(|x| x.try_into().ok())
6531 .ok_or_else(|| {
6532 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6533 })
6534 }
6535
6536 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6537 where
6538 E: serde::de::Error,
6539 {
6540 i32::try_from(v)
6541 .ok()
6542 .and_then(|x| x.try_into().ok())
6543 .ok_or_else(|| {
6544 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6545 })
6546 }
6547
6548 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6549 where
6550 E: serde::de::Error,
6551 {
6552 match value {
6553 "ENGINE_UNSPECIFIED" => Ok(table::Engine::Unspecified),
6554 "HUMMOCK" => Ok(table::Engine::Hummock),
6555 "ICEBERG" => Ok(table::Engine::Iceberg),
6556 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6557 }
6558 }
6559 }
6560 deserializer.deserialize_any(GeneratedVisitor)
6561 }
6562}
6563impl serde::Serialize for table::TableType {
6564 #[allow(deprecated)]
6565 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6566 where
6567 S: serde::Serializer,
6568 {
6569 let variant = match self {
6570 Self::Unspecified => "UNSPECIFIED",
6571 Self::Table => "TABLE",
6572 Self::MaterializedView => "MATERIALIZED_VIEW",
6573 Self::Index => "INDEX",
6574 Self::Internal => "INTERNAL",
6575 Self::VectorIndex => "VECTOR_INDEX",
6576 };
6577 serializer.serialize_str(variant)
6578 }
6579}
6580impl<'de> serde::Deserialize<'de> for table::TableType {
6581 #[allow(deprecated)]
6582 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6583 where
6584 D: serde::Deserializer<'de>,
6585 {
6586 const FIELDS: &[&str] = &[
6587 "UNSPECIFIED",
6588 "TABLE",
6589 "MATERIALIZED_VIEW",
6590 "INDEX",
6591 "INTERNAL",
6592 "VECTOR_INDEX",
6593 ];
6594
6595 struct GeneratedVisitor;
6596
6597 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6598 type Value = table::TableType;
6599
6600 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6601 write!(formatter, "expected one of: {:?}", &FIELDS)
6602 }
6603
6604 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6605 where
6606 E: serde::de::Error,
6607 {
6608 i32::try_from(v)
6609 .ok()
6610 .and_then(|x| x.try_into().ok())
6611 .ok_or_else(|| {
6612 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6613 })
6614 }
6615
6616 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6617 where
6618 E: serde::de::Error,
6619 {
6620 i32::try_from(v)
6621 .ok()
6622 .and_then(|x| x.try_into().ok())
6623 .ok_or_else(|| {
6624 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6625 })
6626 }
6627
6628 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6629 where
6630 E: serde::de::Error,
6631 {
6632 match value {
6633 "UNSPECIFIED" => Ok(table::TableType::Unspecified),
6634 "TABLE" => Ok(table::TableType::Table),
6635 "MATERIALIZED_VIEW" => Ok(table::TableType::MaterializedView),
6636 "INDEX" => Ok(table::TableType::Index),
6637 "INTERNAL" => Ok(table::TableType::Internal),
6638 "VECTOR_INDEX" => Ok(table::TableType::VectorIndex),
6639 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6640 }
6641 }
6642 }
6643 deserializer.deserialize_any(GeneratedVisitor)
6644 }
6645}
6646impl serde::Serialize for table::TableVersion {
6647 #[allow(deprecated)]
6648 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6649 where
6650 S: serde::Serializer,
6651 {
6652 use serde::ser::SerializeStruct;
6653 let mut len = 0;
6654 if self.version != 0 {
6655 len += 1;
6656 }
6657 if self.next_column_id != 0 {
6658 len += 1;
6659 }
6660 let mut struct_ser = serializer.serialize_struct("catalog.Table.TableVersion", len)?;
6661 if self.version != 0 {
6662 #[allow(clippy::needless_borrow)]
6663 #[allow(clippy::needless_borrows_for_generic_args)]
6664 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
6665 }
6666 if self.next_column_id != 0 {
6667 struct_ser.serialize_field("nextColumnId", &self.next_column_id)?;
6668 }
6669 struct_ser.end()
6670 }
6671}
6672impl<'de> serde::Deserialize<'de> for table::TableVersion {
6673 #[allow(deprecated)]
6674 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6675 where
6676 D: serde::Deserializer<'de>,
6677 {
6678 const FIELDS: &[&str] = &[
6679 "version",
6680 "next_column_id",
6681 "nextColumnId",
6682 ];
6683
6684 #[allow(clippy::enum_variant_names)]
6685 enum GeneratedField {
6686 Version,
6687 NextColumnId,
6688 }
6689 impl<'de> serde::Deserialize<'de> for GeneratedField {
6690 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6691 where
6692 D: serde::Deserializer<'de>,
6693 {
6694 struct GeneratedVisitor;
6695
6696 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6697 type Value = GeneratedField;
6698
6699 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6700 write!(formatter, "expected one of: {:?}", &FIELDS)
6701 }
6702
6703 #[allow(unused_variables)]
6704 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6705 where
6706 E: serde::de::Error,
6707 {
6708 match value {
6709 "version" => Ok(GeneratedField::Version),
6710 "nextColumnId" | "next_column_id" => Ok(GeneratedField::NextColumnId),
6711 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6712 }
6713 }
6714 }
6715 deserializer.deserialize_identifier(GeneratedVisitor)
6716 }
6717 }
6718 struct GeneratedVisitor;
6719 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6720 type Value = table::TableVersion;
6721
6722 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6723 formatter.write_str("struct catalog.Table.TableVersion")
6724 }
6725
6726 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table::TableVersion, V::Error>
6727 where
6728 V: serde::de::MapAccess<'de>,
6729 {
6730 let mut version__ = None;
6731 let mut next_column_id__ = None;
6732 while let Some(k) = map_.next_key()? {
6733 match k {
6734 GeneratedField::Version => {
6735 if version__.is_some() {
6736 return Err(serde::de::Error::duplicate_field("version"));
6737 }
6738 version__ =
6739 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6740 ;
6741 }
6742 GeneratedField::NextColumnId => {
6743 if next_column_id__.is_some() {
6744 return Err(serde::de::Error::duplicate_field("nextColumnId"));
6745 }
6746 next_column_id__ =
6747 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6748 ;
6749 }
6750 }
6751 }
6752 Ok(table::TableVersion {
6753 version: version__.unwrap_or_default(),
6754 next_column_id: next_column_id__.unwrap_or_default(),
6755 })
6756 }
6757 }
6758 deserializer.deserialize_struct("catalog.Table.TableVersion", FIELDS, GeneratedVisitor)
6759 }
6760}
6761impl serde::Serialize for VectorIndexInfo {
6762 #[allow(deprecated)]
6763 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6764 where
6765 S: serde::Serializer,
6766 {
6767 use serde::ser::SerializeStruct;
6768 let mut len = 0;
6769 if self.dimension != 0 {
6770 len += 1;
6771 }
6772 if self.distance_type != 0 {
6773 len += 1;
6774 }
6775 if self.config.is_some() {
6776 len += 1;
6777 }
6778 let mut struct_ser = serializer.serialize_struct("catalog.VectorIndexInfo", len)?;
6779 if self.dimension != 0 {
6780 struct_ser.serialize_field("dimension", &self.dimension)?;
6781 }
6782 if self.distance_type != 0 {
6783 let v = super::common::DistanceType::try_from(self.distance_type)
6784 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distance_type)))?;
6785 struct_ser.serialize_field("distanceType", &v)?;
6786 }
6787 if let Some(v) = self.config.as_ref() {
6788 match v {
6789 vector_index_info::Config::Flat(v) => {
6790 struct_ser.serialize_field("flat", v)?;
6791 }
6792 vector_index_info::Config::HnswFlat(v) => {
6793 struct_ser.serialize_field("hnswFlat", v)?;
6794 }
6795 }
6796 }
6797 struct_ser.end()
6798 }
6799}
6800impl<'de> serde::Deserialize<'de> for VectorIndexInfo {
6801 #[allow(deprecated)]
6802 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6803 where
6804 D: serde::Deserializer<'de>,
6805 {
6806 const FIELDS: &[&str] = &[
6807 "dimension",
6808 "distance_type",
6809 "distanceType",
6810 "flat",
6811 "hnsw_flat",
6812 "hnswFlat",
6813 ];
6814
6815 #[allow(clippy::enum_variant_names)]
6816 enum GeneratedField {
6817 Dimension,
6818 DistanceType,
6819 Flat,
6820 HnswFlat,
6821 }
6822 impl<'de> serde::Deserialize<'de> for GeneratedField {
6823 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6824 where
6825 D: serde::Deserializer<'de>,
6826 {
6827 struct GeneratedVisitor;
6828
6829 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6830 type Value = GeneratedField;
6831
6832 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6833 write!(formatter, "expected one of: {:?}", &FIELDS)
6834 }
6835
6836 #[allow(unused_variables)]
6837 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6838 where
6839 E: serde::de::Error,
6840 {
6841 match value {
6842 "dimension" => Ok(GeneratedField::Dimension),
6843 "distanceType" | "distance_type" => Ok(GeneratedField::DistanceType),
6844 "flat" => Ok(GeneratedField::Flat),
6845 "hnswFlat" | "hnsw_flat" => Ok(GeneratedField::HnswFlat),
6846 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6847 }
6848 }
6849 }
6850 deserializer.deserialize_identifier(GeneratedVisitor)
6851 }
6852 }
6853 struct GeneratedVisitor;
6854 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6855 type Value = VectorIndexInfo;
6856
6857 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6858 formatter.write_str("struct catalog.VectorIndexInfo")
6859 }
6860
6861 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexInfo, V::Error>
6862 where
6863 V: serde::de::MapAccess<'de>,
6864 {
6865 let mut dimension__ = None;
6866 let mut distance_type__ = None;
6867 let mut config__ = None;
6868 while let Some(k) = map_.next_key()? {
6869 match k {
6870 GeneratedField::Dimension => {
6871 if dimension__.is_some() {
6872 return Err(serde::de::Error::duplicate_field("dimension"));
6873 }
6874 dimension__ =
6875 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6876 ;
6877 }
6878 GeneratedField::DistanceType => {
6879 if distance_type__.is_some() {
6880 return Err(serde::de::Error::duplicate_field("distanceType"));
6881 }
6882 distance_type__ = Some(map_.next_value::<super::common::DistanceType>()? as i32);
6883 }
6884 GeneratedField::Flat => {
6885 if config__.is_some() {
6886 return Err(serde::de::Error::duplicate_field("flat"));
6887 }
6888 config__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_info::Config::Flat)
6889;
6890 }
6891 GeneratedField::HnswFlat => {
6892 if config__.is_some() {
6893 return Err(serde::de::Error::duplicate_field("hnswFlat"));
6894 }
6895 config__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_info::Config::HnswFlat)
6896;
6897 }
6898 }
6899 }
6900 Ok(VectorIndexInfo {
6901 dimension: dimension__.unwrap_or_default(),
6902 distance_type: distance_type__.unwrap_or_default(),
6903 config: config__,
6904 })
6905 }
6906 }
6907 deserializer.deserialize_struct("catalog.VectorIndexInfo", FIELDS, GeneratedVisitor)
6908 }
6909}
6910impl serde::Serialize for View {
6911 #[allow(deprecated)]
6912 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6913 where
6914 S: serde::Serializer,
6915 {
6916 use serde::ser::SerializeStruct;
6917 let mut len = 0;
6918 if self.id != 0 {
6919 len += 1;
6920 }
6921 if self.schema_id != 0 {
6922 len += 1;
6923 }
6924 if self.database_id != 0 {
6925 len += 1;
6926 }
6927 if !self.name.is_empty() {
6928 len += 1;
6929 }
6930 if self.owner != 0 {
6931 len += 1;
6932 }
6933 if !self.properties.is_empty() {
6934 len += 1;
6935 }
6936 if !self.sql.is_empty() {
6937 len += 1;
6938 }
6939 if !self.columns.is_empty() {
6940 len += 1;
6941 }
6942 let mut struct_ser = serializer.serialize_struct("catalog.View", len)?;
6943 if self.id != 0 {
6944 struct_ser.serialize_field("id", &self.id)?;
6945 }
6946 if self.schema_id != 0 {
6947 struct_ser.serialize_field("schemaId", &self.schema_id)?;
6948 }
6949 if self.database_id != 0 {
6950 struct_ser.serialize_field("databaseId", &self.database_id)?;
6951 }
6952 if !self.name.is_empty() {
6953 struct_ser.serialize_field("name", &self.name)?;
6954 }
6955 if self.owner != 0 {
6956 struct_ser.serialize_field("owner", &self.owner)?;
6957 }
6958 if !self.properties.is_empty() {
6959 struct_ser.serialize_field("properties", &self.properties)?;
6960 }
6961 if !self.sql.is_empty() {
6962 struct_ser.serialize_field("sql", &self.sql)?;
6963 }
6964 if !self.columns.is_empty() {
6965 struct_ser.serialize_field("columns", &self.columns)?;
6966 }
6967 struct_ser.end()
6968 }
6969}
6970impl<'de> serde::Deserialize<'de> for View {
6971 #[allow(deprecated)]
6972 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6973 where
6974 D: serde::Deserializer<'de>,
6975 {
6976 const FIELDS: &[&str] = &[
6977 "id",
6978 "schema_id",
6979 "schemaId",
6980 "database_id",
6981 "databaseId",
6982 "name",
6983 "owner",
6984 "properties",
6985 "sql",
6986 "columns",
6987 ];
6988
6989 #[allow(clippy::enum_variant_names)]
6990 enum GeneratedField {
6991 Id,
6992 SchemaId,
6993 DatabaseId,
6994 Name,
6995 Owner,
6996 Properties,
6997 Sql,
6998 Columns,
6999 }
7000 impl<'de> serde::Deserialize<'de> for GeneratedField {
7001 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7002 where
7003 D: serde::Deserializer<'de>,
7004 {
7005 struct GeneratedVisitor;
7006
7007 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7008 type Value = GeneratedField;
7009
7010 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7011 write!(formatter, "expected one of: {:?}", &FIELDS)
7012 }
7013
7014 #[allow(unused_variables)]
7015 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7016 where
7017 E: serde::de::Error,
7018 {
7019 match value {
7020 "id" => Ok(GeneratedField::Id),
7021 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
7022 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
7023 "name" => Ok(GeneratedField::Name),
7024 "owner" => Ok(GeneratedField::Owner),
7025 "properties" => Ok(GeneratedField::Properties),
7026 "sql" => Ok(GeneratedField::Sql),
7027 "columns" => Ok(GeneratedField::Columns),
7028 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7029 }
7030 }
7031 }
7032 deserializer.deserialize_identifier(GeneratedVisitor)
7033 }
7034 }
7035 struct GeneratedVisitor;
7036 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7037 type Value = View;
7038
7039 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7040 formatter.write_str("struct catalog.View")
7041 }
7042
7043 fn visit_map<V>(self, mut map_: V) -> std::result::Result<View, V::Error>
7044 where
7045 V: serde::de::MapAccess<'de>,
7046 {
7047 let mut id__ = None;
7048 let mut schema_id__ = None;
7049 let mut database_id__ = None;
7050 let mut name__ = None;
7051 let mut owner__ = None;
7052 let mut properties__ = None;
7053 let mut sql__ = None;
7054 let mut columns__ = None;
7055 while let Some(k) = map_.next_key()? {
7056 match k {
7057 GeneratedField::Id => {
7058 if id__.is_some() {
7059 return Err(serde::de::Error::duplicate_field("id"));
7060 }
7061 id__ =
7062 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7063 ;
7064 }
7065 GeneratedField::SchemaId => {
7066 if schema_id__.is_some() {
7067 return Err(serde::de::Error::duplicate_field("schemaId"));
7068 }
7069 schema_id__ =
7070 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7071 ;
7072 }
7073 GeneratedField::DatabaseId => {
7074 if database_id__.is_some() {
7075 return Err(serde::de::Error::duplicate_field("databaseId"));
7076 }
7077 database_id__ =
7078 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7079 ;
7080 }
7081 GeneratedField::Name => {
7082 if name__.is_some() {
7083 return Err(serde::de::Error::duplicate_field("name"));
7084 }
7085 name__ = Some(map_.next_value()?);
7086 }
7087 GeneratedField::Owner => {
7088 if owner__.is_some() {
7089 return Err(serde::de::Error::duplicate_field("owner"));
7090 }
7091 owner__ =
7092 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7093 ;
7094 }
7095 GeneratedField::Properties => {
7096 if properties__.is_some() {
7097 return Err(serde::de::Error::duplicate_field("properties"));
7098 }
7099 properties__ = Some(
7100 map_.next_value::<std::collections::BTreeMap<_, _>>()?
7101 );
7102 }
7103 GeneratedField::Sql => {
7104 if sql__.is_some() {
7105 return Err(serde::de::Error::duplicate_field("sql"));
7106 }
7107 sql__ = Some(map_.next_value()?);
7108 }
7109 GeneratedField::Columns => {
7110 if columns__.is_some() {
7111 return Err(serde::de::Error::duplicate_field("columns"));
7112 }
7113 columns__ = Some(map_.next_value()?);
7114 }
7115 }
7116 }
7117 Ok(View {
7118 id: id__.unwrap_or_default(),
7119 schema_id: schema_id__.unwrap_or_default(),
7120 database_id: database_id__.unwrap_or_default(),
7121 name: name__.unwrap_or_default(),
7122 owner: owner__.unwrap_or_default(),
7123 properties: properties__.unwrap_or_default(),
7124 sql: sql__.unwrap_or_default(),
7125 columns: columns__.unwrap_or_default(),
7126 })
7127 }
7128 }
7129 deserializer.deserialize_struct("catalog.View", FIELDS, GeneratedVisitor)
7130 }
7131}
7132impl serde::Serialize for WatermarkDesc {
7133 #[allow(deprecated)]
7134 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7135 where
7136 S: serde::Serializer,
7137 {
7138 use serde::ser::SerializeStruct;
7139 let mut len = 0;
7140 if self.watermark_idx != 0 {
7141 len += 1;
7142 }
7143 if self.expr.is_some() {
7144 len += 1;
7145 }
7146 let mut struct_ser = serializer.serialize_struct("catalog.WatermarkDesc", len)?;
7147 if self.watermark_idx != 0 {
7148 struct_ser.serialize_field("watermarkIdx", &self.watermark_idx)?;
7149 }
7150 if let Some(v) = self.expr.as_ref() {
7151 struct_ser.serialize_field("expr", v)?;
7152 }
7153 struct_ser.end()
7154 }
7155}
7156impl<'de> serde::Deserialize<'de> for WatermarkDesc {
7157 #[allow(deprecated)]
7158 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7159 where
7160 D: serde::Deserializer<'de>,
7161 {
7162 const FIELDS: &[&str] = &[
7163 "watermark_idx",
7164 "watermarkIdx",
7165 "expr",
7166 ];
7167
7168 #[allow(clippy::enum_variant_names)]
7169 enum GeneratedField {
7170 WatermarkIdx,
7171 Expr,
7172 }
7173 impl<'de> serde::Deserialize<'de> for GeneratedField {
7174 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7175 where
7176 D: serde::Deserializer<'de>,
7177 {
7178 struct GeneratedVisitor;
7179
7180 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7181 type Value = GeneratedField;
7182
7183 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7184 write!(formatter, "expected one of: {:?}", &FIELDS)
7185 }
7186
7187 #[allow(unused_variables)]
7188 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7189 where
7190 E: serde::de::Error,
7191 {
7192 match value {
7193 "watermarkIdx" | "watermark_idx" => Ok(GeneratedField::WatermarkIdx),
7194 "expr" => Ok(GeneratedField::Expr),
7195 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7196 }
7197 }
7198 }
7199 deserializer.deserialize_identifier(GeneratedVisitor)
7200 }
7201 }
7202 struct GeneratedVisitor;
7203 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7204 type Value = WatermarkDesc;
7205
7206 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7207 formatter.write_str("struct catalog.WatermarkDesc")
7208 }
7209
7210 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkDesc, V::Error>
7211 where
7212 V: serde::de::MapAccess<'de>,
7213 {
7214 let mut watermark_idx__ = None;
7215 let mut expr__ = None;
7216 while let Some(k) = map_.next_key()? {
7217 match k {
7218 GeneratedField::WatermarkIdx => {
7219 if watermark_idx__.is_some() {
7220 return Err(serde::de::Error::duplicate_field("watermarkIdx"));
7221 }
7222 watermark_idx__ =
7223 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7224 ;
7225 }
7226 GeneratedField::Expr => {
7227 if expr__.is_some() {
7228 return Err(serde::de::Error::duplicate_field("expr"));
7229 }
7230 expr__ = map_.next_value()?;
7231 }
7232 }
7233 }
7234 Ok(WatermarkDesc {
7235 watermark_idx: watermark_idx__.unwrap_or_default(),
7236 expr: expr__,
7237 })
7238 }
7239 }
7240 deserializer.deserialize_struct("catalog.WatermarkDesc", FIELDS, GeneratedVisitor)
7241 }
7242}
7243impl serde::Serialize for WebhookSourceInfo {
7244 #[allow(deprecated)]
7245 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7246 where
7247 S: serde::Serializer,
7248 {
7249 use serde::ser::SerializeStruct;
7250 let mut len = 0;
7251 if self.secret_ref.is_some() {
7252 len += 1;
7253 }
7254 if self.signature_expr.is_some() {
7255 len += 1;
7256 }
7257 if self.wait_for_persistence {
7258 len += 1;
7259 }
7260 if self.is_batched {
7261 len += 1;
7262 }
7263 let mut struct_ser = serializer.serialize_struct("catalog.WebhookSourceInfo", len)?;
7264 if let Some(v) = self.secret_ref.as_ref() {
7265 struct_ser.serialize_field("secretRef", v)?;
7266 }
7267 if let Some(v) = self.signature_expr.as_ref() {
7268 struct_ser.serialize_field("signatureExpr", v)?;
7269 }
7270 if self.wait_for_persistence {
7271 struct_ser.serialize_field("waitForPersistence", &self.wait_for_persistence)?;
7272 }
7273 if self.is_batched {
7274 struct_ser.serialize_field("isBatched", &self.is_batched)?;
7275 }
7276 struct_ser.end()
7277 }
7278}
7279impl<'de> serde::Deserialize<'de> for WebhookSourceInfo {
7280 #[allow(deprecated)]
7281 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7282 where
7283 D: serde::Deserializer<'de>,
7284 {
7285 const FIELDS: &[&str] = &[
7286 "secret_ref",
7287 "secretRef",
7288 "signature_expr",
7289 "signatureExpr",
7290 "wait_for_persistence",
7291 "waitForPersistence",
7292 "is_batched",
7293 "isBatched",
7294 ];
7295
7296 #[allow(clippy::enum_variant_names)]
7297 enum GeneratedField {
7298 SecretRef,
7299 SignatureExpr,
7300 WaitForPersistence,
7301 IsBatched,
7302 }
7303 impl<'de> serde::Deserialize<'de> for GeneratedField {
7304 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7305 where
7306 D: serde::Deserializer<'de>,
7307 {
7308 struct GeneratedVisitor;
7309
7310 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7311 type Value = GeneratedField;
7312
7313 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7314 write!(formatter, "expected one of: {:?}", &FIELDS)
7315 }
7316
7317 #[allow(unused_variables)]
7318 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7319 where
7320 E: serde::de::Error,
7321 {
7322 match value {
7323 "secretRef" | "secret_ref" => Ok(GeneratedField::SecretRef),
7324 "signatureExpr" | "signature_expr" => Ok(GeneratedField::SignatureExpr),
7325 "waitForPersistence" | "wait_for_persistence" => Ok(GeneratedField::WaitForPersistence),
7326 "isBatched" | "is_batched" => Ok(GeneratedField::IsBatched),
7327 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7328 }
7329 }
7330 }
7331 deserializer.deserialize_identifier(GeneratedVisitor)
7332 }
7333 }
7334 struct GeneratedVisitor;
7335 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7336 type Value = WebhookSourceInfo;
7337
7338 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7339 formatter.write_str("struct catalog.WebhookSourceInfo")
7340 }
7341
7342 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WebhookSourceInfo, V::Error>
7343 where
7344 V: serde::de::MapAccess<'de>,
7345 {
7346 let mut secret_ref__ = None;
7347 let mut signature_expr__ = None;
7348 let mut wait_for_persistence__ = None;
7349 let mut is_batched__ = None;
7350 while let Some(k) = map_.next_key()? {
7351 match k {
7352 GeneratedField::SecretRef => {
7353 if secret_ref__.is_some() {
7354 return Err(serde::de::Error::duplicate_field("secretRef"));
7355 }
7356 secret_ref__ = map_.next_value()?;
7357 }
7358 GeneratedField::SignatureExpr => {
7359 if signature_expr__.is_some() {
7360 return Err(serde::de::Error::duplicate_field("signatureExpr"));
7361 }
7362 signature_expr__ = map_.next_value()?;
7363 }
7364 GeneratedField::WaitForPersistence => {
7365 if wait_for_persistence__.is_some() {
7366 return Err(serde::de::Error::duplicate_field("waitForPersistence"));
7367 }
7368 wait_for_persistence__ = Some(map_.next_value()?);
7369 }
7370 GeneratedField::IsBatched => {
7371 if is_batched__.is_some() {
7372 return Err(serde::de::Error::duplicate_field("isBatched"));
7373 }
7374 is_batched__ = Some(map_.next_value()?);
7375 }
7376 }
7377 }
7378 Ok(WebhookSourceInfo {
7379 secret_ref: secret_ref__,
7380 signature_expr: signature_expr__,
7381 wait_for_persistence: wait_for_persistence__.unwrap_or_default(),
7382 is_batched: is_batched__.unwrap_or_default(),
7383 })
7384 }
7385 }
7386 deserializer.deserialize_struct("catalog.WebhookSourceInfo", FIELDS, GeneratedVisitor)
7387 }
7388}