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 };
4057 serializer.serialize_str(variant)
4058 }
4059}
4060impl<'de> serde::Deserialize<'de> for SinkType {
4061 #[allow(deprecated)]
4062 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4063 where
4064 D: serde::Deserializer<'de>,
4065 {
4066 const FIELDS: &[&str] = &[
4067 "SINK_TYPE_UNSPECIFIED",
4068 "SINK_TYPE_APPEND_ONLY",
4069 "SINK_TYPE_FORCE_APPEND_ONLY",
4070 "SINK_TYPE_UPSERT",
4071 ];
4072
4073 struct GeneratedVisitor;
4074
4075 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4076 type Value = SinkType;
4077
4078 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4079 write!(formatter, "expected one of: {:?}", &FIELDS)
4080 }
4081
4082 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
4083 where
4084 E: serde::de::Error,
4085 {
4086 i32::try_from(v)
4087 .ok()
4088 .and_then(|x| x.try_into().ok())
4089 .ok_or_else(|| {
4090 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
4091 })
4092 }
4093
4094 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
4095 where
4096 E: serde::de::Error,
4097 {
4098 i32::try_from(v)
4099 .ok()
4100 .and_then(|x| x.try_into().ok())
4101 .ok_or_else(|| {
4102 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
4103 })
4104 }
4105
4106 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
4107 where
4108 E: serde::de::Error,
4109 {
4110 match value {
4111 "SINK_TYPE_UNSPECIFIED" => Ok(SinkType::Unspecified),
4112 "SINK_TYPE_APPEND_ONLY" => Ok(SinkType::AppendOnly),
4113 "SINK_TYPE_FORCE_APPEND_ONLY" => Ok(SinkType::ForceAppendOnly),
4114 "SINK_TYPE_UPSERT" => Ok(SinkType::Upsert),
4115 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
4116 }
4117 }
4118 }
4119 deserializer.deserialize_any(GeneratedVisitor)
4120 }
4121}
4122impl serde::Serialize for Source {
4123 #[allow(deprecated)]
4124 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4125 where
4126 S: serde::Serializer,
4127 {
4128 use serde::ser::SerializeStruct;
4129 let mut len = 0;
4130 if self.id != 0 {
4131 len += 1;
4132 }
4133 if self.schema_id != 0 {
4134 len += 1;
4135 }
4136 if self.database_id != 0 {
4137 len += 1;
4138 }
4139 if !self.name.is_empty() {
4140 len += 1;
4141 }
4142 if self.row_id_index.is_some() {
4143 len += 1;
4144 }
4145 if !self.columns.is_empty() {
4146 len += 1;
4147 }
4148 if !self.pk_column_ids.is_empty() {
4149 len += 1;
4150 }
4151 if !self.with_properties.is_empty() {
4152 len += 1;
4153 }
4154 if self.owner != 0 {
4155 len += 1;
4156 }
4157 if self.info.is_some() {
4158 len += 1;
4159 }
4160 if !self.watermark_descs.is_empty() {
4161 len += 1;
4162 }
4163 if !self.definition.is_empty() {
4164 len += 1;
4165 }
4166 if self.connection_id.is_some() {
4167 len += 1;
4168 }
4169 if self.initialized_at_epoch.is_some() {
4170 len += 1;
4171 }
4172 if self.created_at_epoch.is_some() {
4173 len += 1;
4174 }
4175 if self.initialized_at_cluster_version.is_some() {
4176 len += 1;
4177 }
4178 if self.created_at_cluster_version.is_some() {
4179 len += 1;
4180 }
4181 if !self.secret_refs.is_empty() {
4182 len += 1;
4183 }
4184 if self.version != 0 {
4185 len += 1;
4186 }
4187 if self.rate_limit.is_some() {
4188 len += 1;
4189 }
4190 if self.optional_associated_table_id.is_some() {
4191 len += 1;
4192 }
4193 let mut struct_ser = serializer.serialize_struct("catalog.Source", len)?;
4194 if self.id != 0 {
4195 struct_ser.serialize_field("id", &self.id)?;
4196 }
4197 if self.schema_id != 0 {
4198 struct_ser.serialize_field("schemaId", &self.schema_id)?;
4199 }
4200 if self.database_id != 0 {
4201 struct_ser.serialize_field("databaseId", &self.database_id)?;
4202 }
4203 if !self.name.is_empty() {
4204 struct_ser.serialize_field("name", &self.name)?;
4205 }
4206 if let Some(v) = self.row_id_index.as_ref() {
4207 struct_ser.serialize_field("rowIdIndex", v)?;
4208 }
4209 if !self.columns.is_empty() {
4210 struct_ser.serialize_field("columns", &self.columns)?;
4211 }
4212 if !self.pk_column_ids.is_empty() {
4213 struct_ser.serialize_field("pkColumnIds", &self.pk_column_ids)?;
4214 }
4215 if !self.with_properties.is_empty() {
4216 struct_ser.serialize_field("withProperties", &self.with_properties)?;
4217 }
4218 if self.owner != 0 {
4219 struct_ser.serialize_field("owner", &self.owner)?;
4220 }
4221 if let Some(v) = self.info.as_ref() {
4222 struct_ser.serialize_field("info", v)?;
4223 }
4224 if !self.watermark_descs.is_empty() {
4225 struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
4226 }
4227 if !self.definition.is_empty() {
4228 struct_ser.serialize_field("definition", &self.definition)?;
4229 }
4230 if let Some(v) = self.connection_id.as_ref() {
4231 struct_ser.serialize_field("connectionId", v)?;
4232 }
4233 if let Some(v) = self.initialized_at_epoch.as_ref() {
4234 #[allow(clippy::needless_borrow)]
4235 #[allow(clippy::needless_borrows_for_generic_args)]
4236 struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
4237 }
4238 if let Some(v) = self.created_at_epoch.as_ref() {
4239 #[allow(clippy::needless_borrow)]
4240 #[allow(clippy::needless_borrows_for_generic_args)]
4241 struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
4242 }
4243 if let Some(v) = self.initialized_at_cluster_version.as_ref() {
4244 struct_ser.serialize_field("initializedAtClusterVersion", v)?;
4245 }
4246 if let Some(v) = self.created_at_cluster_version.as_ref() {
4247 struct_ser.serialize_field("createdAtClusterVersion", v)?;
4248 }
4249 if !self.secret_refs.is_empty() {
4250 struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
4251 }
4252 if self.version != 0 {
4253 #[allow(clippy::needless_borrow)]
4254 #[allow(clippy::needless_borrows_for_generic_args)]
4255 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
4256 }
4257 if let Some(v) = self.rate_limit.as_ref() {
4258 struct_ser.serialize_field("rateLimit", v)?;
4259 }
4260 if let Some(v) = self.optional_associated_table_id.as_ref() {
4261 match v {
4262 source::OptionalAssociatedTableId::AssociatedTableId(v) => {
4263 struct_ser.serialize_field("associatedTableId", v)?;
4264 }
4265 }
4266 }
4267 struct_ser.end()
4268 }
4269}
4270impl<'de> serde::Deserialize<'de> for Source {
4271 #[allow(deprecated)]
4272 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4273 where
4274 D: serde::Deserializer<'de>,
4275 {
4276 const FIELDS: &[&str] = &[
4277 "id",
4278 "schema_id",
4279 "schemaId",
4280 "database_id",
4281 "databaseId",
4282 "name",
4283 "row_id_index",
4284 "rowIdIndex",
4285 "columns",
4286 "pk_column_ids",
4287 "pkColumnIds",
4288 "with_properties",
4289 "withProperties",
4290 "owner",
4291 "info",
4292 "watermark_descs",
4293 "watermarkDescs",
4294 "definition",
4295 "connection_id",
4296 "connectionId",
4297 "initialized_at_epoch",
4298 "initializedAtEpoch",
4299 "created_at_epoch",
4300 "createdAtEpoch",
4301 "initialized_at_cluster_version",
4302 "initializedAtClusterVersion",
4303 "created_at_cluster_version",
4304 "createdAtClusterVersion",
4305 "secret_refs",
4306 "secretRefs",
4307 "version",
4308 "rate_limit",
4309 "rateLimit",
4310 "associated_table_id",
4311 "associatedTableId",
4312 ];
4313
4314 #[allow(clippy::enum_variant_names)]
4315 enum GeneratedField {
4316 Id,
4317 SchemaId,
4318 DatabaseId,
4319 Name,
4320 RowIdIndex,
4321 Columns,
4322 PkColumnIds,
4323 WithProperties,
4324 Owner,
4325 Info,
4326 WatermarkDescs,
4327 Definition,
4328 ConnectionId,
4329 InitializedAtEpoch,
4330 CreatedAtEpoch,
4331 InitializedAtClusterVersion,
4332 CreatedAtClusterVersion,
4333 SecretRefs,
4334 Version,
4335 RateLimit,
4336 AssociatedTableId,
4337 }
4338 impl<'de> serde::Deserialize<'de> for GeneratedField {
4339 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4340 where
4341 D: serde::Deserializer<'de>,
4342 {
4343 struct GeneratedVisitor;
4344
4345 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4346 type Value = GeneratedField;
4347
4348 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4349 write!(formatter, "expected one of: {:?}", &FIELDS)
4350 }
4351
4352 #[allow(unused_variables)]
4353 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4354 where
4355 E: serde::de::Error,
4356 {
4357 match value {
4358 "id" => Ok(GeneratedField::Id),
4359 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
4360 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4361 "name" => Ok(GeneratedField::Name),
4362 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
4363 "columns" => Ok(GeneratedField::Columns),
4364 "pkColumnIds" | "pk_column_ids" => Ok(GeneratedField::PkColumnIds),
4365 "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
4366 "owner" => Ok(GeneratedField::Owner),
4367 "info" => Ok(GeneratedField::Info),
4368 "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
4369 "definition" => Ok(GeneratedField::Definition),
4370 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
4371 "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
4372 "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
4373 "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
4374 "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
4375 "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
4376 "version" => Ok(GeneratedField::Version),
4377 "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
4378 "associatedTableId" | "associated_table_id" => Ok(GeneratedField::AssociatedTableId),
4379 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4380 }
4381 }
4382 }
4383 deserializer.deserialize_identifier(GeneratedVisitor)
4384 }
4385 }
4386 struct GeneratedVisitor;
4387 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4388 type Value = Source;
4389
4390 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4391 formatter.write_str("struct catalog.Source")
4392 }
4393
4394 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Source, V::Error>
4395 where
4396 V: serde::de::MapAccess<'de>,
4397 {
4398 let mut id__ = None;
4399 let mut schema_id__ = None;
4400 let mut database_id__ = None;
4401 let mut name__ = None;
4402 let mut row_id_index__ = None;
4403 let mut columns__ = None;
4404 let mut pk_column_ids__ = None;
4405 let mut with_properties__ = None;
4406 let mut owner__ = None;
4407 let mut info__ = None;
4408 let mut watermark_descs__ = None;
4409 let mut definition__ = None;
4410 let mut connection_id__ = None;
4411 let mut initialized_at_epoch__ = None;
4412 let mut created_at_epoch__ = None;
4413 let mut initialized_at_cluster_version__ = None;
4414 let mut created_at_cluster_version__ = None;
4415 let mut secret_refs__ = None;
4416 let mut version__ = None;
4417 let mut rate_limit__ = None;
4418 let mut optional_associated_table_id__ = None;
4419 while let Some(k) = map_.next_key()? {
4420 match k {
4421 GeneratedField::Id => {
4422 if id__.is_some() {
4423 return Err(serde::de::Error::duplicate_field("id"));
4424 }
4425 id__ =
4426 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4427 ;
4428 }
4429 GeneratedField::SchemaId => {
4430 if schema_id__.is_some() {
4431 return Err(serde::de::Error::duplicate_field("schemaId"));
4432 }
4433 schema_id__ =
4434 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4435 ;
4436 }
4437 GeneratedField::DatabaseId => {
4438 if database_id__.is_some() {
4439 return Err(serde::de::Error::duplicate_field("databaseId"));
4440 }
4441 database_id__ =
4442 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4443 ;
4444 }
4445 GeneratedField::Name => {
4446 if name__.is_some() {
4447 return Err(serde::de::Error::duplicate_field("name"));
4448 }
4449 name__ = Some(map_.next_value()?);
4450 }
4451 GeneratedField::RowIdIndex => {
4452 if row_id_index__.is_some() {
4453 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
4454 }
4455 row_id_index__ =
4456 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4457 ;
4458 }
4459 GeneratedField::Columns => {
4460 if columns__.is_some() {
4461 return Err(serde::de::Error::duplicate_field("columns"));
4462 }
4463 columns__ = Some(map_.next_value()?);
4464 }
4465 GeneratedField::PkColumnIds => {
4466 if pk_column_ids__.is_some() {
4467 return Err(serde::de::Error::duplicate_field("pkColumnIds"));
4468 }
4469 pk_column_ids__ =
4470 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4471 .into_iter().map(|x| x.0).collect())
4472 ;
4473 }
4474 GeneratedField::WithProperties => {
4475 if with_properties__.is_some() {
4476 return Err(serde::de::Error::duplicate_field("withProperties"));
4477 }
4478 with_properties__ = Some(
4479 map_.next_value::<std::collections::BTreeMap<_, _>>()?
4480 );
4481 }
4482 GeneratedField::Owner => {
4483 if owner__.is_some() {
4484 return Err(serde::de::Error::duplicate_field("owner"));
4485 }
4486 owner__ =
4487 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4488 ;
4489 }
4490 GeneratedField::Info => {
4491 if info__.is_some() {
4492 return Err(serde::de::Error::duplicate_field("info"));
4493 }
4494 info__ = map_.next_value()?;
4495 }
4496 GeneratedField::WatermarkDescs => {
4497 if watermark_descs__.is_some() {
4498 return Err(serde::de::Error::duplicate_field("watermarkDescs"));
4499 }
4500 watermark_descs__ = Some(map_.next_value()?);
4501 }
4502 GeneratedField::Definition => {
4503 if definition__.is_some() {
4504 return Err(serde::de::Error::duplicate_field("definition"));
4505 }
4506 definition__ = Some(map_.next_value()?);
4507 }
4508 GeneratedField::ConnectionId => {
4509 if connection_id__.is_some() {
4510 return Err(serde::de::Error::duplicate_field("connectionId"));
4511 }
4512 connection_id__ =
4513 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4514 ;
4515 }
4516 GeneratedField::InitializedAtEpoch => {
4517 if initialized_at_epoch__.is_some() {
4518 return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
4519 }
4520 initialized_at_epoch__ =
4521 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4522 ;
4523 }
4524 GeneratedField::CreatedAtEpoch => {
4525 if created_at_epoch__.is_some() {
4526 return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
4527 }
4528 created_at_epoch__ =
4529 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4530 ;
4531 }
4532 GeneratedField::InitializedAtClusterVersion => {
4533 if initialized_at_cluster_version__.is_some() {
4534 return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
4535 }
4536 initialized_at_cluster_version__ = map_.next_value()?;
4537 }
4538 GeneratedField::CreatedAtClusterVersion => {
4539 if created_at_cluster_version__.is_some() {
4540 return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
4541 }
4542 created_at_cluster_version__ = map_.next_value()?;
4543 }
4544 GeneratedField::SecretRefs => {
4545 if secret_refs__.is_some() {
4546 return Err(serde::de::Error::duplicate_field("secretRefs"));
4547 }
4548 secret_refs__ = Some(
4549 map_.next_value::<std::collections::BTreeMap<_, _>>()?
4550 );
4551 }
4552 GeneratedField::Version => {
4553 if version__.is_some() {
4554 return Err(serde::de::Error::duplicate_field("version"));
4555 }
4556 version__ =
4557 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4558 ;
4559 }
4560 GeneratedField::RateLimit => {
4561 if rate_limit__.is_some() {
4562 return Err(serde::de::Error::duplicate_field("rateLimit"));
4563 }
4564 rate_limit__ =
4565 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4566 ;
4567 }
4568 GeneratedField::AssociatedTableId => {
4569 if optional_associated_table_id__.is_some() {
4570 return Err(serde::de::Error::duplicate_field("associatedTableId"));
4571 }
4572 optional_associated_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| source::OptionalAssociatedTableId::AssociatedTableId(x.0));
4573 }
4574 }
4575 }
4576 Ok(Source {
4577 id: id__.unwrap_or_default(),
4578 schema_id: schema_id__.unwrap_or_default(),
4579 database_id: database_id__.unwrap_or_default(),
4580 name: name__.unwrap_or_default(),
4581 row_id_index: row_id_index__,
4582 columns: columns__.unwrap_or_default(),
4583 pk_column_ids: pk_column_ids__.unwrap_or_default(),
4584 with_properties: with_properties__.unwrap_or_default(),
4585 owner: owner__.unwrap_or_default(),
4586 info: info__,
4587 watermark_descs: watermark_descs__.unwrap_or_default(),
4588 definition: definition__.unwrap_or_default(),
4589 connection_id: connection_id__,
4590 initialized_at_epoch: initialized_at_epoch__,
4591 created_at_epoch: created_at_epoch__,
4592 initialized_at_cluster_version: initialized_at_cluster_version__,
4593 created_at_cluster_version: created_at_cluster_version__,
4594 secret_refs: secret_refs__.unwrap_or_default(),
4595 version: version__.unwrap_or_default(),
4596 rate_limit: rate_limit__,
4597 optional_associated_table_id: optional_associated_table_id__,
4598 })
4599 }
4600 }
4601 deserializer.deserialize_struct("catalog.Source", FIELDS, GeneratedVisitor)
4602 }
4603}
4604impl serde::Serialize for StreamJobStatus {
4605 #[allow(deprecated)]
4606 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4607 where
4608 S: serde::Serializer,
4609 {
4610 let variant = match self {
4611 Self::Unspecified => "STREAM_JOB_STATUS_UNSPECIFIED",
4612 Self::Creating => "STREAM_JOB_STATUS_CREATING",
4613 Self::Created => "STREAM_JOB_STATUS_CREATED",
4614 };
4615 serializer.serialize_str(variant)
4616 }
4617}
4618impl<'de> serde::Deserialize<'de> for StreamJobStatus {
4619 #[allow(deprecated)]
4620 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4621 where
4622 D: serde::Deserializer<'de>,
4623 {
4624 const FIELDS: &[&str] = &[
4625 "STREAM_JOB_STATUS_UNSPECIFIED",
4626 "STREAM_JOB_STATUS_CREATING",
4627 "STREAM_JOB_STATUS_CREATED",
4628 ];
4629
4630 struct GeneratedVisitor;
4631
4632 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4633 type Value = StreamJobStatus;
4634
4635 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4636 write!(formatter, "expected one of: {:?}", &FIELDS)
4637 }
4638
4639 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
4640 where
4641 E: serde::de::Error,
4642 {
4643 i32::try_from(v)
4644 .ok()
4645 .and_then(|x| x.try_into().ok())
4646 .ok_or_else(|| {
4647 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
4648 })
4649 }
4650
4651 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
4652 where
4653 E: serde::de::Error,
4654 {
4655 i32::try_from(v)
4656 .ok()
4657 .and_then(|x| x.try_into().ok())
4658 .ok_or_else(|| {
4659 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
4660 })
4661 }
4662
4663 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
4664 where
4665 E: serde::de::Error,
4666 {
4667 match value {
4668 "STREAM_JOB_STATUS_UNSPECIFIED" => Ok(StreamJobStatus::Unspecified),
4669 "STREAM_JOB_STATUS_CREATING" => Ok(StreamJobStatus::Creating),
4670 "STREAM_JOB_STATUS_CREATED" => Ok(StreamJobStatus::Created),
4671 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
4672 }
4673 }
4674 }
4675 deserializer.deserialize_any(GeneratedVisitor)
4676 }
4677}
4678impl serde::Serialize for StreamSourceInfo {
4679 #[allow(deprecated)]
4680 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4681 where
4682 S: serde::Serializer,
4683 {
4684 use serde::ser::SerializeStruct;
4685 let mut len = 0;
4686 if self.row_format != 0 {
4687 len += 1;
4688 }
4689 if !self.row_schema_location.is_empty() {
4690 len += 1;
4691 }
4692 if self.use_schema_registry {
4693 len += 1;
4694 }
4695 if !self.proto_message_name.is_empty() {
4696 len += 1;
4697 }
4698 if self.csv_delimiter != 0 {
4699 len += 1;
4700 }
4701 if self.csv_has_header {
4702 len += 1;
4703 }
4704 if self.format != 0 {
4705 len += 1;
4706 }
4707 if self.row_encode != 0 {
4708 len += 1;
4709 }
4710 if self.name_strategy != 0 {
4711 len += 1;
4712 }
4713 if self.key_message_name.is_some() {
4714 len += 1;
4715 }
4716 if self.external_table.is_some() {
4717 len += 1;
4718 }
4719 if self.cdc_source_job {
4720 len += 1;
4721 }
4722 if self.is_distributed {
4723 len += 1;
4724 }
4725 if !self.format_encode_options.is_empty() {
4726 len += 1;
4727 }
4728 if !self.format_encode_secret_refs.is_empty() {
4729 len += 1;
4730 }
4731 if self.connection_id.is_some() {
4732 len += 1;
4733 }
4734 let mut struct_ser = serializer.serialize_struct("catalog.StreamSourceInfo", len)?;
4735 if self.row_format != 0 {
4736 let v = super::plan_common::RowFormatType::try_from(self.row_format)
4737 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.row_format)))?;
4738 struct_ser.serialize_field("rowFormat", &v)?;
4739 }
4740 if !self.row_schema_location.is_empty() {
4741 struct_ser.serialize_field("rowSchemaLocation", &self.row_schema_location)?;
4742 }
4743 if self.use_schema_registry {
4744 struct_ser.serialize_field("useSchemaRegistry", &self.use_schema_registry)?;
4745 }
4746 if !self.proto_message_name.is_empty() {
4747 struct_ser.serialize_field("protoMessageName", &self.proto_message_name)?;
4748 }
4749 if self.csv_delimiter != 0 {
4750 struct_ser.serialize_field("csvDelimiter", &self.csv_delimiter)?;
4751 }
4752 if self.csv_has_header {
4753 struct_ser.serialize_field("csvHasHeader", &self.csv_has_header)?;
4754 }
4755 if self.format != 0 {
4756 let v = super::plan_common::FormatType::try_from(self.format)
4757 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.format)))?;
4758 struct_ser.serialize_field("format", &v)?;
4759 }
4760 if self.row_encode != 0 {
4761 let v = super::plan_common::EncodeType::try_from(self.row_encode)
4762 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.row_encode)))?;
4763 struct_ser.serialize_field("rowEncode", &v)?;
4764 }
4765 if self.name_strategy != 0 {
4766 let v = SchemaRegistryNameStrategy::try_from(self.name_strategy)
4767 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.name_strategy)))?;
4768 struct_ser.serialize_field("nameStrategy", &v)?;
4769 }
4770 if let Some(v) = self.key_message_name.as_ref() {
4771 struct_ser.serialize_field("keyMessageName", v)?;
4772 }
4773 if let Some(v) = self.external_table.as_ref() {
4774 struct_ser.serialize_field("externalTable", v)?;
4775 }
4776 if self.cdc_source_job {
4777 struct_ser.serialize_field("cdcSourceJob", &self.cdc_source_job)?;
4778 }
4779 if self.is_distributed {
4780 struct_ser.serialize_field("isDistributed", &self.is_distributed)?;
4781 }
4782 if !self.format_encode_options.is_empty() {
4783 struct_ser.serialize_field("formatEncodeOptions", &self.format_encode_options)?;
4784 }
4785 if !self.format_encode_secret_refs.is_empty() {
4786 struct_ser.serialize_field("formatEncodeSecretRefs", &self.format_encode_secret_refs)?;
4787 }
4788 if let Some(v) = self.connection_id.as_ref() {
4789 struct_ser.serialize_field("connectionId", v)?;
4790 }
4791 struct_ser.end()
4792 }
4793}
4794impl<'de> serde::Deserialize<'de> for StreamSourceInfo {
4795 #[allow(deprecated)]
4796 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4797 where
4798 D: serde::Deserializer<'de>,
4799 {
4800 const FIELDS: &[&str] = &[
4801 "row_format",
4802 "rowFormat",
4803 "row_schema_location",
4804 "rowSchemaLocation",
4805 "use_schema_registry",
4806 "useSchemaRegistry",
4807 "proto_message_name",
4808 "protoMessageName",
4809 "csv_delimiter",
4810 "csvDelimiter",
4811 "csv_has_header",
4812 "csvHasHeader",
4813 "format",
4814 "row_encode",
4815 "rowEncode",
4816 "name_strategy",
4817 "nameStrategy",
4818 "key_message_name",
4819 "keyMessageName",
4820 "external_table",
4821 "externalTable",
4822 "cdc_source_job",
4823 "cdcSourceJob",
4824 "is_distributed",
4825 "isDistributed",
4826 "format_encode_options",
4827 "formatEncodeOptions",
4828 "format_encode_secret_refs",
4829 "formatEncodeSecretRefs",
4830 "connection_id",
4831 "connectionId",
4832 ];
4833
4834 #[allow(clippy::enum_variant_names)]
4835 enum GeneratedField {
4836 RowFormat,
4837 RowSchemaLocation,
4838 UseSchemaRegistry,
4839 ProtoMessageName,
4840 CsvDelimiter,
4841 CsvHasHeader,
4842 Format,
4843 RowEncode,
4844 NameStrategy,
4845 KeyMessageName,
4846 ExternalTable,
4847 CdcSourceJob,
4848 IsDistributed,
4849 FormatEncodeOptions,
4850 FormatEncodeSecretRefs,
4851 ConnectionId,
4852 }
4853 impl<'de> serde::Deserialize<'de> for GeneratedField {
4854 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4855 where
4856 D: serde::Deserializer<'de>,
4857 {
4858 struct GeneratedVisitor;
4859
4860 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4861 type Value = GeneratedField;
4862
4863 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4864 write!(formatter, "expected one of: {:?}", &FIELDS)
4865 }
4866
4867 #[allow(unused_variables)]
4868 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4869 where
4870 E: serde::de::Error,
4871 {
4872 match value {
4873 "rowFormat" | "row_format" => Ok(GeneratedField::RowFormat),
4874 "rowSchemaLocation" | "row_schema_location" => Ok(GeneratedField::RowSchemaLocation),
4875 "useSchemaRegistry" | "use_schema_registry" => Ok(GeneratedField::UseSchemaRegistry),
4876 "protoMessageName" | "proto_message_name" => Ok(GeneratedField::ProtoMessageName),
4877 "csvDelimiter" | "csv_delimiter" => Ok(GeneratedField::CsvDelimiter),
4878 "csvHasHeader" | "csv_has_header" => Ok(GeneratedField::CsvHasHeader),
4879 "format" => Ok(GeneratedField::Format),
4880 "rowEncode" | "row_encode" => Ok(GeneratedField::RowEncode),
4881 "nameStrategy" | "name_strategy" => Ok(GeneratedField::NameStrategy),
4882 "keyMessageName" | "key_message_name" => Ok(GeneratedField::KeyMessageName),
4883 "externalTable" | "external_table" => Ok(GeneratedField::ExternalTable),
4884 "cdcSourceJob" | "cdc_source_job" => Ok(GeneratedField::CdcSourceJob),
4885 "isDistributed" | "is_distributed" => Ok(GeneratedField::IsDistributed),
4886 "formatEncodeOptions" | "format_encode_options" => Ok(GeneratedField::FormatEncodeOptions),
4887 "formatEncodeSecretRefs" | "format_encode_secret_refs" => Ok(GeneratedField::FormatEncodeSecretRefs),
4888 "connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
4889 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4890 }
4891 }
4892 }
4893 deserializer.deserialize_identifier(GeneratedVisitor)
4894 }
4895 }
4896 struct GeneratedVisitor;
4897 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4898 type Value = StreamSourceInfo;
4899
4900 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4901 formatter.write_str("struct catalog.StreamSourceInfo")
4902 }
4903
4904 fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSourceInfo, V::Error>
4905 where
4906 V: serde::de::MapAccess<'de>,
4907 {
4908 let mut row_format__ = None;
4909 let mut row_schema_location__ = None;
4910 let mut use_schema_registry__ = None;
4911 let mut proto_message_name__ = None;
4912 let mut csv_delimiter__ = None;
4913 let mut csv_has_header__ = None;
4914 let mut format__ = None;
4915 let mut row_encode__ = None;
4916 let mut name_strategy__ = None;
4917 let mut key_message_name__ = None;
4918 let mut external_table__ = None;
4919 let mut cdc_source_job__ = None;
4920 let mut is_distributed__ = None;
4921 let mut format_encode_options__ = None;
4922 let mut format_encode_secret_refs__ = None;
4923 let mut connection_id__ = None;
4924 while let Some(k) = map_.next_key()? {
4925 match k {
4926 GeneratedField::RowFormat => {
4927 if row_format__.is_some() {
4928 return Err(serde::de::Error::duplicate_field("rowFormat"));
4929 }
4930 row_format__ = Some(map_.next_value::<super::plan_common::RowFormatType>()? as i32);
4931 }
4932 GeneratedField::RowSchemaLocation => {
4933 if row_schema_location__.is_some() {
4934 return Err(serde::de::Error::duplicate_field("rowSchemaLocation"));
4935 }
4936 row_schema_location__ = Some(map_.next_value()?);
4937 }
4938 GeneratedField::UseSchemaRegistry => {
4939 if use_schema_registry__.is_some() {
4940 return Err(serde::de::Error::duplicate_field("useSchemaRegistry"));
4941 }
4942 use_schema_registry__ = Some(map_.next_value()?);
4943 }
4944 GeneratedField::ProtoMessageName => {
4945 if proto_message_name__.is_some() {
4946 return Err(serde::de::Error::duplicate_field("protoMessageName"));
4947 }
4948 proto_message_name__ = Some(map_.next_value()?);
4949 }
4950 GeneratedField::CsvDelimiter => {
4951 if csv_delimiter__.is_some() {
4952 return Err(serde::de::Error::duplicate_field("csvDelimiter"));
4953 }
4954 csv_delimiter__ =
4955 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4956 ;
4957 }
4958 GeneratedField::CsvHasHeader => {
4959 if csv_has_header__.is_some() {
4960 return Err(serde::de::Error::duplicate_field("csvHasHeader"));
4961 }
4962 csv_has_header__ = Some(map_.next_value()?);
4963 }
4964 GeneratedField::Format => {
4965 if format__.is_some() {
4966 return Err(serde::de::Error::duplicate_field("format"));
4967 }
4968 format__ = Some(map_.next_value::<super::plan_common::FormatType>()? as i32);
4969 }
4970 GeneratedField::RowEncode => {
4971 if row_encode__.is_some() {
4972 return Err(serde::de::Error::duplicate_field("rowEncode"));
4973 }
4974 row_encode__ = Some(map_.next_value::<super::plan_common::EncodeType>()? as i32);
4975 }
4976 GeneratedField::NameStrategy => {
4977 if name_strategy__.is_some() {
4978 return Err(serde::de::Error::duplicate_field("nameStrategy"));
4979 }
4980 name_strategy__ = Some(map_.next_value::<SchemaRegistryNameStrategy>()? as i32);
4981 }
4982 GeneratedField::KeyMessageName => {
4983 if key_message_name__.is_some() {
4984 return Err(serde::de::Error::duplicate_field("keyMessageName"));
4985 }
4986 key_message_name__ = map_.next_value()?;
4987 }
4988 GeneratedField::ExternalTable => {
4989 if external_table__.is_some() {
4990 return Err(serde::de::Error::duplicate_field("externalTable"));
4991 }
4992 external_table__ = map_.next_value()?;
4993 }
4994 GeneratedField::CdcSourceJob => {
4995 if cdc_source_job__.is_some() {
4996 return Err(serde::de::Error::duplicate_field("cdcSourceJob"));
4997 }
4998 cdc_source_job__ = Some(map_.next_value()?);
4999 }
5000 GeneratedField::IsDistributed => {
5001 if is_distributed__.is_some() {
5002 return Err(serde::de::Error::duplicate_field("isDistributed"));
5003 }
5004 is_distributed__ = Some(map_.next_value()?);
5005 }
5006 GeneratedField::FormatEncodeOptions => {
5007 if format_encode_options__.is_some() {
5008 return Err(serde::de::Error::duplicate_field("formatEncodeOptions"));
5009 }
5010 format_encode_options__ = Some(
5011 map_.next_value::<std::collections::BTreeMap<_, _>>()?
5012 );
5013 }
5014 GeneratedField::FormatEncodeSecretRefs => {
5015 if format_encode_secret_refs__.is_some() {
5016 return Err(serde::de::Error::duplicate_field("formatEncodeSecretRefs"));
5017 }
5018 format_encode_secret_refs__ = Some(
5019 map_.next_value::<std::collections::BTreeMap<_, _>>()?
5020 );
5021 }
5022 GeneratedField::ConnectionId => {
5023 if connection_id__.is_some() {
5024 return Err(serde::de::Error::duplicate_field("connectionId"));
5025 }
5026 connection_id__ =
5027 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5028 ;
5029 }
5030 }
5031 }
5032 Ok(StreamSourceInfo {
5033 row_format: row_format__.unwrap_or_default(),
5034 row_schema_location: row_schema_location__.unwrap_or_default(),
5035 use_schema_registry: use_schema_registry__.unwrap_or_default(),
5036 proto_message_name: proto_message_name__.unwrap_or_default(),
5037 csv_delimiter: csv_delimiter__.unwrap_or_default(),
5038 csv_has_header: csv_has_header__.unwrap_or_default(),
5039 format: format__.unwrap_or_default(),
5040 row_encode: row_encode__.unwrap_or_default(),
5041 name_strategy: name_strategy__.unwrap_or_default(),
5042 key_message_name: key_message_name__,
5043 external_table: external_table__,
5044 cdc_source_job: cdc_source_job__.unwrap_or_default(),
5045 is_distributed: is_distributed__.unwrap_or_default(),
5046 format_encode_options: format_encode_options__.unwrap_or_default(),
5047 format_encode_secret_refs: format_encode_secret_refs__.unwrap_or_default(),
5048 connection_id: connection_id__,
5049 })
5050 }
5051 }
5052 deserializer.deserialize_struct("catalog.StreamSourceInfo", FIELDS, GeneratedVisitor)
5053 }
5054}
5055impl serde::Serialize for Subscription {
5056 #[allow(deprecated)]
5057 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5058 where
5059 S: serde::Serializer,
5060 {
5061 use serde::ser::SerializeStruct;
5062 let mut len = 0;
5063 if self.id != 0 {
5064 len += 1;
5065 }
5066 if !self.name.is_empty() {
5067 len += 1;
5068 }
5069 if !self.definition.is_empty() {
5070 len += 1;
5071 }
5072 if self.retention_seconds != 0 {
5073 len += 1;
5074 }
5075 if self.database_id != 0 {
5076 len += 1;
5077 }
5078 if self.schema_id != 0 {
5079 len += 1;
5080 }
5081 if self.dependent_table_id != 0 {
5082 len += 1;
5083 }
5084 if self.initialized_at_epoch.is_some() {
5085 len += 1;
5086 }
5087 if self.created_at_epoch.is_some() {
5088 len += 1;
5089 }
5090 if self.owner != 0 {
5091 len += 1;
5092 }
5093 if self.initialized_at_cluster_version.is_some() {
5094 len += 1;
5095 }
5096 if self.created_at_cluster_version.is_some() {
5097 len += 1;
5098 }
5099 if self.subscription_state != 0 {
5100 len += 1;
5101 }
5102 let mut struct_ser = serializer.serialize_struct("catalog.Subscription", len)?;
5103 if self.id != 0 {
5104 struct_ser.serialize_field("id", &self.id)?;
5105 }
5106 if !self.name.is_empty() {
5107 struct_ser.serialize_field("name", &self.name)?;
5108 }
5109 if !self.definition.is_empty() {
5110 struct_ser.serialize_field("definition", &self.definition)?;
5111 }
5112 if self.retention_seconds != 0 {
5113 #[allow(clippy::needless_borrow)]
5114 #[allow(clippy::needless_borrows_for_generic_args)]
5115 struct_ser.serialize_field("retentionSeconds", ToString::to_string(&self.retention_seconds).as_str())?;
5116 }
5117 if self.database_id != 0 {
5118 struct_ser.serialize_field("databaseId", &self.database_id)?;
5119 }
5120 if self.schema_id != 0 {
5121 struct_ser.serialize_field("schemaId", &self.schema_id)?;
5122 }
5123 if self.dependent_table_id != 0 {
5124 struct_ser.serialize_field("dependentTableId", &self.dependent_table_id)?;
5125 }
5126 if let Some(v) = self.initialized_at_epoch.as_ref() {
5127 #[allow(clippy::needless_borrow)]
5128 #[allow(clippy::needless_borrows_for_generic_args)]
5129 struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
5130 }
5131 if let Some(v) = self.created_at_epoch.as_ref() {
5132 #[allow(clippy::needless_borrow)]
5133 #[allow(clippy::needless_borrows_for_generic_args)]
5134 struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
5135 }
5136 if self.owner != 0 {
5137 struct_ser.serialize_field("owner", &self.owner)?;
5138 }
5139 if let Some(v) = self.initialized_at_cluster_version.as_ref() {
5140 struct_ser.serialize_field("initializedAtClusterVersion", v)?;
5141 }
5142 if let Some(v) = self.created_at_cluster_version.as_ref() {
5143 struct_ser.serialize_field("createdAtClusterVersion", v)?;
5144 }
5145 if self.subscription_state != 0 {
5146 let v = subscription::SubscriptionState::try_from(self.subscription_state)
5147 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscription_state)))?;
5148 struct_ser.serialize_field("subscriptionState", &v)?;
5149 }
5150 struct_ser.end()
5151 }
5152}
5153impl<'de> serde::Deserialize<'de> for Subscription {
5154 #[allow(deprecated)]
5155 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5156 where
5157 D: serde::Deserializer<'de>,
5158 {
5159 const FIELDS: &[&str] = &[
5160 "id",
5161 "name",
5162 "definition",
5163 "retention_seconds",
5164 "retentionSeconds",
5165 "database_id",
5166 "databaseId",
5167 "schema_id",
5168 "schemaId",
5169 "dependent_table_id",
5170 "dependentTableId",
5171 "initialized_at_epoch",
5172 "initializedAtEpoch",
5173 "created_at_epoch",
5174 "createdAtEpoch",
5175 "owner",
5176 "initialized_at_cluster_version",
5177 "initializedAtClusterVersion",
5178 "created_at_cluster_version",
5179 "createdAtClusterVersion",
5180 "subscription_state",
5181 "subscriptionState",
5182 ];
5183
5184 #[allow(clippy::enum_variant_names)]
5185 enum GeneratedField {
5186 Id,
5187 Name,
5188 Definition,
5189 RetentionSeconds,
5190 DatabaseId,
5191 SchemaId,
5192 DependentTableId,
5193 InitializedAtEpoch,
5194 CreatedAtEpoch,
5195 Owner,
5196 InitializedAtClusterVersion,
5197 CreatedAtClusterVersion,
5198 SubscriptionState,
5199 }
5200 impl<'de> serde::Deserialize<'de> for GeneratedField {
5201 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5202 where
5203 D: serde::Deserializer<'de>,
5204 {
5205 struct GeneratedVisitor;
5206
5207 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5208 type Value = GeneratedField;
5209
5210 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5211 write!(formatter, "expected one of: {:?}", &FIELDS)
5212 }
5213
5214 #[allow(unused_variables)]
5215 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5216 where
5217 E: serde::de::Error,
5218 {
5219 match value {
5220 "id" => Ok(GeneratedField::Id),
5221 "name" => Ok(GeneratedField::Name),
5222 "definition" => Ok(GeneratedField::Definition),
5223 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
5224 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
5225 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
5226 "dependentTableId" | "dependent_table_id" => Ok(GeneratedField::DependentTableId),
5227 "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
5228 "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
5229 "owner" => Ok(GeneratedField::Owner),
5230 "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
5231 "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
5232 "subscriptionState" | "subscription_state" => Ok(GeneratedField::SubscriptionState),
5233 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5234 }
5235 }
5236 }
5237 deserializer.deserialize_identifier(GeneratedVisitor)
5238 }
5239 }
5240 struct GeneratedVisitor;
5241 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5242 type Value = Subscription;
5243
5244 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5245 formatter.write_str("struct catalog.Subscription")
5246 }
5247
5248 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Subscription, V::Error>
5249 where
5250 V: serde::de::MapAccess<'de>,
5251 {
5252 let mut id__ = None;
5253 let mut name__ = None;
5254 let mut definition__ = None;
5255 let mut retention_seconds__ = None;
5256 let mut database_id__ = None;
5257 let mut schema_id__ = None;
5258 let mut dependent_table_id__ = None;
5259 let mut initialized_at_epoch__ = None;
5260 let mut created_at_epoch__ = None;
5261 let mut owner__ = None;
5262 let mut initialized_at_cluster_version__ = None;
5263 let mut created_at_cluster_version__ = None;
5264 let mut subscription_state__ = None;
5265 while let Some(k) = map_.next_key()? {
5266 match k {
5267 GeneratedField::Id => {
5268 if id__.is_some() {
5269 return Err(serde::de::Error::duplicate_field("id"));
5270 }
5271 id__ =
5272 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5273 ;
5274 }
5275 GeneratedField::Name => {
5276 if name__.is_some() {
5277 return Err(serde::de::Error::duplicate_field("name"));
5278 }
5279 name__ = Some(map_.next_value()?);
5280 }
5281 GeneratedField::Definition => {
5282 if definition__.is_some() {
5283 return Err(serde::de::Error::duplicate_field("definition"));
5284 }
5285 definition__ = Some(map_.next_value()?);
5286 }
5287 GeneratedField::RetentionSeconds => {
5288 if retention_seconds__.is_some() {
5289 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
5290 }
5291 retention_seconds__ =
5292 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5293 ;
5294 }
5295 GeneratedField::DatabaseId => {
5296 if database_id__.is_some() {
5297 return Err(serde::de::Error::duplicate_field("databaseId"));
5298 }
5299 database_id__ =
5300 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5301 ;
5302 }
5303 GeneratedField::SchemaId => {
5304 if schema_id__.is_some() {
5305 return Err(serde::de::Error::duplicate_field("schemaId"));
5306 }
5307 schema_id__ =
5308 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5309 ;
5310 }
5311 GeneratedField::DependentTableId => {
5312 if dependent_table_id__.is_some() {
5313 return Err(serde::de::Error::duplicate_field("dependentTableId"));
5314 }
5315 dependent_table_id__ =
5316 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5317 ;
5318 }
5319 GeneratedField::InitializedAtEpoch => {
5320 if initialized_at_epoch__.is_some() {
5321 return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
5322 }
5323 initialized_at_epoch__ =
5324 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5325 ;
5326 }
5327 GeneratedField::CreatedAtEpoch => {
5328 if created_at_epoch__.is_some() {
5329 return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
5330 }
5331 created_at_epoch__ =
5332 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
5333 ;
5334 }
5335 GeneratedField::Owner => {
5336 if owner__.is_some() {
5337 return Err(serde::de::Error::duplicate_field("owner"));
5338 }
5339 owner__ =
5340 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5341 ;
5342 }
5343 GeneratedField::InitializedAtClusterVersion => {
5344 if initialized_at_cluster_version__.is_some() {
5345 return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
5346 }
5347 initialized_at_cluster_version__ = map_.next_value()?;
5348 }
5349 GeneratedField::CreatedAtClusterVersion => {
5350 if created_at_cluster_version__.is_some() {
5351 return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
5352 }
5353 created_at_cluster_version__ = map_.next_value()?;
5354 }
5355 GeneratedField::SubscriptionState => {
5356 if subscription_state__.is_some() {
5357 return Err(serde::de::Error::duplicate_field("subscriptionState"));
5358 }
5359 subscription_state__ = Some(map_.next_value::<subscription::SubscriptionState>()? as i32);
5360 }
5361 }
5362 }
5363 Ok(Subscription {
5364 id: id__.unwrap_or_default(),
5365 name: name__.unwrap_or_default(),
5366 definition: definition__.unwrap_or_default(),
5367 retention_seconds: retention_seconds__.unwrap_or_default(),
5368 database_id: database_id__.unwrap_or_default(),
5369 schema_id: schema_id__.unwrap_or_default(),
5370 dependent_table_id: dependent_table_id__.unwrap_or_default(),
5371 initialized_at_epoch: initialized_at_epoch__,
5372 created_at_epoch: created_at_epoch__,
5373 owner: owner__.unwrap_or_default(),
5374 initialized_at_cluster_version: initialized_at_cluster_version__,
5375 created_at_cluster_version: created_at_cluster_version__,
5376 subscription_state: subscription_state__.unwrap_or_default(),
5377 })
5378 }
5379 }
5380 deserializer.deserialize_struct("catalog.Subscription", FIELDS, GeneratedVisitor)
5381 }
5382}
5383impl serde::Serialize for subscription::SubscriptionState {
5384 #[allow(deprecated)]
5385 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5386 where
5387 S: serde::Serializer,
5388 {
5389 let variant = match self {
5390 Self::Unspecified => "UNSPECIFIED",
5391 Self::Init => "INIT",
5392 Self::Created => "CREATED",
5393 };
5394 serializer.serialize_str(variant)
5395 }
5396}
5397impl<'de> serde::Deserialize<'de> for subscription::SubscriptionState {
5398 #[allow(deprecated)]
5399 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5400 where
5401 D: serde::Deserializer<'de>,
5402 {
5403 const FIELDS: &[&str] = &[
5404 "UNSPECIFIED",
5405 "INIT",
5406 "CREATED",
5407 ];
5408
5409 struct GeneratedVisitor;
5410
5411 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5412 type Value = subscription::SubscriptionState;
5413
5414 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5415 write!(formatter, "expected one of: {:?}", &FIELDS)
5416 }
5417
5418 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
5419 where
5420 E: serde::de::Error,
5421 {
5422 i32::try_from(v)
5423 .ok()
5424 .and_then(|x| x.try_into().ok())
5425 .ok_or_else(|| {
5426 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
5427 })
5428 }
5429
5430 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
5431 where
5432 E: serde::de::Error,
5433 {
5434 i32::try_from(v)
5435 .ok()
5436 .and_then(|x| x.try_into().ok())
5437 .ok_or_else(|| {
5438 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
5439 })
5440 }
5441
5442 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
5443 where
5444 E: serde::de::Error,
5445 {
5446 match value {
5447 "UNSPECIFIED" => Ok(subscription::SubscriptionState::Unspecified),
5448 "INIT" => Ok(subscription::SubscriptionState::Init),
5449 "CREATED" => Ok(subscription::SubscriptionState::Created),
5450 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
5451 }
5452 }
5453 }
5454 deserializer.deserialize_any(GeneratedVisitor)
5455 }
5456}
5457impl serde::Serialize for Table {
5458 #[allow(deprecated)]
5459 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5460 where
5461 S: serde::Serializer,
5462 {
5463 use serde::ser::SerializeStruct;
5464 let mut len = 0;
5465 if self.id != 0 {
5466 len += 1;
5467 }
5468 if self.schema_id != 0 {
5469 len += 1;
5470 }
5471 if self.database_id != 0 {
5472 len += 1;
5473 }
5474 if !self.name.is_empty() {
5475 len += 1;
5476 }
5477 if !self.columns.is_empty() {
5478 len += 1;
5479 }
5480 if !self.pk.is_empty() {
5481 len += 1;
5482 }
5483 if self.table_type != 0 {
5484 len += 1;
5485 }
5486 if !self.distribution_key.is_empty() {
5487 len += 1;
5488 }
5489 if !self.stream_key.is_empty() {
5490 len += 1;
5491 }
5492 if self.append_only {
5493 len += 1;
5494 }
5495 if self.owner != 0 {
5496 len += 1;
5497 }
5498 if self.fragment_id != 0 {
5499 len += 1;
5500 }
5501 if self.vnode_col_index.is_some() {
5502 len += 1;
5503 }
5504 if self.row_id_index.is_some() {
5505 len += 1;
5506 }
5507 if !self.value_indices.is_empty() {
5508 len += 1;
5509 }
5510 if !self.definition.is_empty() {
5511 len += 1;
5512 }
5513 if self.handle_pk_conflict_behavior != 0 {
5514 len += 1;
5515 }
5516 if self.read_prefix_len_hint != 0 {
5517 len += 1;
5518 }
5519 if !self.watermark_indices.is_empty() {
5520 len += 1;
5521 }
5522 if !self.dist_key_in_pk.is_empty() {
5523 len += 1;
5524 }
5525 if self.dml_fragment_id.is_some() {
5526 len += 1;
5527 }
5528 if self.cardinality.is_some() {
5529 len += 1;
5530 }
5531 if self.initialized_at_epoch.is_some() {
5532 len += 1;
5533 }
5534 if self.created_at_epoch.is_some() {
5535 len += 1;
5536 }
5537 if self.cleaned_by_watermark {
5538 len += 1;
5539 }
5540 if self.stream_job_status != 0 {
5541 len += 1;
5542 }
5543 if self.create_type != 0 {
5544 len += 1;
5545 }
5546 if self.description.is_some() {
5547 len += 1;
5548 }
5549 if !self.incoming_sinks.is_empty() {
5550 len += 1;
5551 }
5552 if self.initialized_at_cluster_version.is_some() {
5553 len += 1;
5554 }
5555 if self.created_at_cluster_version.is_some() {
5556 len += 1;
5557 }
5558 if self.retention_seconds.is_some() {
5559 len += 1;
5560 }
5561 if !self.version_column_indices.is_empty() {
5562 len += 1;
5563 }
5564 if self.cdc_table_id.is_some() {
5565 len += 1;
5566 }
5567 if self.maybe_vnode_count.is_some() {
5568 len += 1;
5569 }
5570 if self.webhook_info.is_some() {
5571 len += 1;
5572 }
5573 if self.job_id.is_some() {
5574 len += 1;
5575 }
5576 if self.engine.is_some() {
5577 len += 1;
5578 }
5579 if self.clean_watermark_index_in_pk.is_some() {
5580 len += 1;
5581 }
5582 if self.refreshable {
5583 len += 1;
5584 }
5585 if self.vector_index_info.is_some() {
5586 len += 1;
5587 }
5588 if self.cdc_table_type.is_some() {
5589 len += 1;
5590 }
5591 if self.refresh_state.is_some() {
5592 len += 1;
5593 }
5594 if self.version.is_some() {
5595 len += 1;
5596 }
5597 if self.optional_associated_source_id.is_some() {
5598 len += 1;
5599 }
5600 let mut struct_ser = serializer.serialize_struct("catalog.Table", len)?;
5601 if self.id != 0 {
5602 struct_ser.serialize_field("id", &self.id)?;
5603 }
5604 if self.schema_id != 0 {
5605 struct_ser.serialize_field("schemaId", &self.schema_id)?;
5606 }
5607 if self.database_id != 0 {
5608 struct_ser.serialize_field("databaseId", &self.database_id)?;
5609 }
5610 if !self.name.is_empty() {
5611 struct_ser.serialize_field("name", &self.name)?;
5612 }
5613 if !self.columns.is_empty() {
5614 struct_ser.serialize_field("columns", &self.columns)?;
5615 }
5616 if !self.pk.is_empty() {
5617 struct_ser.serialize_field("pk", &self.pk)?;
5618 }
5619 if self.table_type != 0 {
5620 let v = table::TableType::try_from(self.table_type)
5621 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.table_type)))?;
5622 struct_ser.serialize_field("tableType", &v)?;
5623 }
5624 if !self.distribution_key.is_empty() {
5625 struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
5626 }
5627 if !self.stream_key.is_empty() {
5628 struct_ser.serialize_field("streamKey", &self.stream_key)?;
5629 }
5630 if self.append_only {
5631 struct_ser.serialize_field("appendOnly", &self.append_only)?;
5632 }
5633 if self.owner != 0 {
5634 struct_ser.serialize_field("owner", &self.owner)?;
5635 }
5636 if self.fragment_id != 0 {
5637 struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5638 }
5639 if let Some(v) = self.vnode_col_index.as_ref() {
5640 struct_ser.serialize_field("vnodeColIndex", v)?;
5641 }
5642 if let Some(v) = self.row_id_index.as_ref() {
5643 struct_ser.serialize_field("rowIdIndex", v)?;
5644 }
5645 if !self.value_indices.is_empty() {
5646 struct_ser.serialize_field("valueIndices", &self.value_indices)?;
5647 }
5648 if !self.definition.is_empty() {
5649 struct_ser.serialize_field("definition", &self.definition)?;
5650 }
5651 if self.handle_pk_conflict_behavior != 0 {
5652 let v = HandleConflictBehavior::try_from(self.handle_pk_conflict_behavior)
5653 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.handle_pk_conflict_behavior)))?;
5654 struct_ser.serialize_field("handlePkConflictBehavior", &v)?;
5655 }
5656 if self.read_prefix_len_hint != 0 {
5657 struct_ser.serialize_field("readPrefixLenHint", &self.read_prefix_len_hint)?;
5658 }
5659 if !self.watermark_indices.is_empty() {
5660 struct_ser.serialize_field("watermarkIndices", &self.watermark_indices)?;
5661 }
5662 if !self.dist_key_in_pk.is_empty() {
5663 struct_ser.serialize_field("distKeyInPk", &self.dist_key_in_pk)?;
5664 }
5665 if let Some(v) = self.dml_fragment_id.as_ref() {
5666 struct_ser.serialize_field("dmlFragmentId", v)?;
5667 }
5668 if let Some(v) = self.cardinality.as_ref() {
5669 struct_ser.serialize_field("cardinality", v)?;
5670 }
5671 if let Some(v) = self.initialized_at_epoch.as_ref() {
5672 #[allow(clippy::needless_borrow)]
5673 #[allow(clippy::needless_borrows_for_generic_args)]
5674 struct_ser.serialize_field("initializedAtEpoch", ToString::to_string(&v).as_str())?;
5675 }
5676 if let Some(v) = self.created_at_epoch.as_ref() {
5677 #[allow(clippy::needless_borrow)]
5678 #[allow(clippy::needless_borrows_for_generic_args)]
5679 struct_ser.serialize_field("createdAtEpoch", ToString::to_string(&v).as_str())?;
5680 }
5681 if self.cleaned_by_watermark {
5682 struct_ser.serialize_field("cleanedByWatermark", &self.cleaned_by_watermark)?;
5683 }
5684 if self.stream_job_status != 0 {
5685 let v = StreamJobStatus::try_from(self.stream_job_status)
5686 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_job_status)))?;
5687 struct_ser.serialize_field("streamJobStatus", &v)?;
5688 }
5689 if self.create_type != 0 {
5690 let v = CreateType::try_from(self.create_type)
5691 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.create_type)))?;
5692 struct_ser.serialize_field("createType", &v)?;
5693 }
5694 if let Some(v) = self.description.as_ref() {
5695 struct_ser.serialize_field("description", v)?;
5696 }
5697 if !self.incoming_sinks.is_empty() {
5698 struct_ser.serialize_field("incomingSinks", &self.incoming_sinks)?;
5699 }
5700 if let Some(v) = self.initialized_at_cluster_version.as_ref() {
5701 struct_ser.serialize_field("initializedAtClusterVersion", v)?;
5702 }
5703 if let Some(v) = self.created_at_cluster_version.as_ref() {
5704 struct_ser.serialize_field("createdAtClusterVersion", v)?;
5705 }
5706 if let Some(v) = self.retention_seconds.as_ref() {
5707 struct_ser.serialize_field("retentionSeconds", v)?;
5708 }
5709 if !self.version_column_indices.is_empty() {
5710 struct_ser.serialize_field("versionColumnIndices", &self.version_column_indices)?;
5711 }
5712 if let Some(v) = self.cdc_table_id.as_ref() {
5713 struct_ser.serialize_field("cdcTableId", v)?;
5714 }
5715 if let Some(v) = self.maybe_vnode_count.as_ref() {
5716 struct_ser.serialize_field("maybeVnodeCount", v)?;
5717 }
5718 if let Some(v) = self.webhook_info.as_ref() {
5719 struct_ser.serialize_field("webhookInfo", v)?;
5720 }
5721 if let Some(v) = self.job_id.as_ref() {
5722 struct_ser.serialize_field("jobId", v)?;
5723 }
5724 if let Some(v) = self.engine.as_ref() {
5725 let v = table::Engine::try_from(*v)
5726 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
5727 struct_ser.serialize_field("engine", &v)?;
5728 }
5729 if let Some(v) = self.clean_watermark_index_in_pk.as_ref() {
5730 struct_ser.serialize_field("cleanWatermarkIndexInPk", v)?;
5731 }
5732 if self.refreshable {
5733 struct_ser.serialize_field("refreshable", &self.refreshable)?;
5734 }
5735 if let Some(v) = self.vector_index_info.as_ref() {
5736 struct_ser.serialize_field("vectorIndexInfo", v)?;
5737 }
5738 if let Some(v) = self.cdc_table_type.as_ref() {
5739 let v = table::CdcTableType::try_from(*v)
5740 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
5741 struct_ser.serialize_field("cdcTableType", &v)?;
5742 }
5743 if let Some(v) = self.refresh_state.as_ref() {
5744 let v = RefreshState::try_from(*v)
5745 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
5746 struct_ser.serialize_field("refreshState", &v)?;
5747 }
5748 if let Some(v) = self.version.as_ref() {
5749 struct_ser.serialize_field("version", v)?;
5750 }
5751 if let Some(v) = self.optional_associated_source_id.as_ref() {
5752 match v {
5753 table::OptionalAssociatedSourceId::AssociatedSourceId(v) => {
5754 struct_ser.serialize_field("associatedSourceId", v)?;
5755 }
5756 }
5757 }
5758 struct_ser.end()
5759 }
5760}
5761impl<'de> serde::Deserialize<'de> for Table {
5762 #[allow(deprecated)]
5763 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5764 where
5765 D: serde::Deserializer<'de>,
5766 {
5767 const FIELDS: &[&str] = &[
5768 "id",
5769 "schema_id",
5770 "schemaId",
5771 "database_id",
5772 "databaseId",
5773 "name",
5774 "columns",
5775 "pk",
5776 "table_type",
5777 "tableType",
5778 "distribution_key",
5779 "distributionKey",
5780 "stream_key",
5781 "streamKey",
5782 "append_only",
5783 "appendOnly",
5784 "owner",
5785 "fragment_id",
5786 "fragmentId",
5787 "vnode_col_index",
5788 "vnodeColIndex",
5789 "row_id_index",
5790 "rowIdIndex",
5791 "value_indices",
5792 "valueIndices",
5793 "definition",
5794 "handle_pk_conflict_behavior",
5795 "handlePkConflictBehavior",
5796 "read_prefix_len_hint",
5797 "readPrefixLenHint",
5798 "watermark_indices",
5799 "watermarkIndices",
5800 "dist_key_in_pk",
5801 "distKeyInPk",
5802 "dml_fragment_id",
5803 "dmlFragmentId",
5804 "cardinality",
5805 "initialized_at_epoch",
5806 "initializedAtEpoch",
5807 "created_at_epoch",
5808 "createdAtEpoch",
5809 "cleaned_by_watermark",
5810 "cleanedByWatermark",
5811 "stream_job_status",
5812 "streamJobStatus",
5813 "create_type",
5814 "createType",
5815 "description",
5816 "incoming_sinks",
5817 "incomingSinks",
5818 "initialized_at_cluster_version",
5819 "initializedAtClusterVersion",
5820 "created_at_cluster_version",
5821 "createdAtClusterVersion",
5822 "retention_seconds",
5823 "retentionSeconds",
5824 "version_column_indices",
5825 "versionColumnIndices",
5826 "cdc_table_id",
5827 "cdcTableId",
5828 "maybe_vnode_count",
5829 "maybeVnodeCount",
5830 "webhook_info",
5831 "webhookInfo",
5832 "job_id",
5833 "jobId",
5834 "engine",
5835 "clean_watermark_index_in_pk",
5836 "cleanWatermarkIndexInPk",
5837 "refreshable",
5838 "vector_index_info",
5839 "vectorIndexInfo",
5840 "cdc_table_type",
5841 "cdcTableType",
5842 "refresh_state",
5843 "refreshState",
5844 "version",
5845 "associated_source_id",
5846 "associatedSourceId",
5847 ];
5848
5849 #[allow(clippy::enum_variant_names)]
5850 enum GeneratedField {
5851 Id,
5852 SchemaId,
5853 DatabaseId,
5854 Name,
5855 Columns,
5856 Pk,
5857 TableType,
5858 DistributionKey,
5859 StreamKey,
5860 AppendOnly,
5861 Owner,
5862 FragmentId,
5863 VnodeColIndex,
5864 RowIdIndex,
5865 ValueIndices,
5866 Definition,
5867 HandlePkConflictBehavior,
5868 ReadPrefixLenHint,
5869 WatermarkIndices,
5870 DistKeyInPk,
5871 DmlFragmentId,
5872 Cardinality,
5873 InitializedAtEpoch,
5874 CreatedAtEpoch,
5875 CleanedByWatermark,
5876 StreamJobStatus,
5877 CreateType,
5878 Description,
5879 IncomingSinks,
5880 InitializedAtClusterVersion,
5881 CreatedAtClusterVersion,
5882 RetentionSeconds,
5883 VersionColumnIndices,
5884 CdcTableId,
5885 MaybeVnodeCount,
5886 WebhookInfo,
5887 JobId,
5888 Engine,
5889 CleanWatermarkIndexInPk,
5890 Refreshable,
5891 VectorIndexInfo,
5892 CdcTableType,
5893 RefreshState,
5894 Version,
5895 AssociatedSourceId,
5896 }
5897 impl<'de> serde::Deserialize<'de> for GeneratedField {
5898 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5899 where
5900 D: serde::Deserializer<'de>,
5901 {
5902 struct GeneratedVisitor;
5903
5904 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5905 type Value = GeneratedField;
5906
5907 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5908 write!(formatter, "expected one of: {:?}", &FIELDS)
5909 }
5910
5911 #[allow(unused_variables)]
5912 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5913 where
5914 E: serde::de::Error,
5915 {
5916 match value {
5917 "id" => Ok(GeneratedField::Id),
5918 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
5919 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
5920 "name" => Ok(GeneratedField::Name),
5921 "columns" => Ok(GeneratedField::Columns),
5922 "pk" => Ok(GeneratedField::Pk),
5923 "tableType" | "table_type" => Ok(GeneratedField::TableType),
5924 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
5925 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
5926 "appendOnly" | "append_only" => Ok(GeneratedField::AppendOnly),
5927 "owner" => Ok(GeneratedField::Owner),
5928 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5929 "vnodeColIndex" | "vnode_col_index" => Ok(GeneratedField::VnodeColIndex),
5930 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
5931 "valueIndices" | "value_indices" => Ok(GeneratedField::ValueIndices),
5932 "definition" => Ok(GeneratedField::Definition),
5933 "handlePkConflictBehavior" | "handle_pk_conflict_behavior" => Ok(GeneratedField::HandlePkConflictBehavior),
5934 "readPrefixLenHint" | "read_prefix_len_hint" => Ok(GeneratedField::ReadPrefixLenHint),
5935 "watermarkIndices" | "watermark_indices" => Ok(GeneratedField::WatermarkIndices),
5936 "distKeyInPk" | "dist_key_in_pk" => Ok(GeneratedField::DistKeyInPk),
5937 "dmlFragmentId" | "dml_fragment_id" => Ok(GeneratedField::DmlFragmentId),
5938 "cardinality" => Ok(GeneratedField::Cardinality),
5939 "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
5940 "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
5941 "cleanedByWatermark" | "cleaned_by_watermark" => Ok(GeneratedField::CleanedByWatermark),
5942 "streamJobStatus" | "stream_job_status" => Ok(GeneratedField::StreamJobStatus),
5943 "createType" | "create_type" => Ok(GeneratedField::CreateType),
5944 "description" => Ok(GeneratedField::Description),
5945 "incomingSinks" | "incoming_sinks" => Ok(GeneratedField::IncomingSinks),
5946 "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
5947 "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
5948 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
5949 "versionColumnIndices" | "version_column_indices" => Ok(GeneratedField::VersionColumnIndices),
5950 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
5951 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
5952 "webhookInfo" | "webhook_info" => Ok(GeneratedField::WebhookInfo),
5953 "jobId" | "job_id" => Ok(GeneratedField::JobId),
5954 "engine" => Ok(GeneratedField::Engine),
5955 "cleanWatermarkIndexInPk" | "clean_watermark_index_in_pk" => Ok(GeneratedField::CleanWatermarkIndexInPk),
5956 "refreshable" => Ok(GeneratedField::Refreshable),
5957 "vectorIndexInfo" | "vector_index_info" => Ok(GeneratedField::VectorIndexInfo),
5958 "cdcTableType" | "cdc_table_type" => Ok(GeneratedField::CdcTableType),
5959 "refreshState" | "refresh_state" => Ok(GeneratedField::RefreshState),
5960 "version" => Ok(GeneratedField::Version),
5961 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
5962 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5963 }
5964 }
5965 }
5966 deserializer.deserialize_identifier(GeneratedVisitor)
5967 }
5968 }
5969 struct GeneratedVisitor;
5970 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5971 type Value = Table;
5972
5973 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5974 formatter.write_str("struct catalog.Table")
5975 }
5976
5977 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Table, V::Error>
5978 where
5979 V: serde::de::MapAccess<'de>,
5980 {
5981 let mut id__ = None;
5982 let mut schema_id__ = None;
5983 let mut database_id__ = None;
5984 let mut name__ = None;
5985 let mut columns__ = None;
5986 let mut pk__ = None;
5987 let mut table_type__ = None;
5988 let mut distribution_key__ = None;
5989 let mut stream_key__ = None;
5990 let mut append_only__ = None;
5991 let mut owner__ = None;
5992 let mut fragment_id__ = None;
5993 let mut vnode_col_index__ = None;
5994 let mut row_id_index__ = None;
5995 let mut value_indices__ = None;
5996 let mut definition__ = None;
5997 let mut handle_pk_conflict_behavior__ = None;
5998 let mut read_prefix_len_hint__ = None;
5999 let mut watermark_indices__ = None;
6000 let mut dist_key_in_pk__ = None;
6001 let mut dml_fragment_id__ = None;
6002 let mut cardinality__ = None;
6003 let mut initialized_at_epoch__ = None;
6004 let mut created_at_epoch__ = None;
6005 let mut cleaned_by_watermark__ = None;
6006 let mut stream_job_status__ = None;
6007 let mut create_type__ = None;
6008 let mut description__ = None;
6009 let mut incoming_sinks__ = None;
6010 let mut initialized_at_cluster_version__ = None;
6011 let mut created_at_cluster_version__ = None;
6012 let mut retention_seconds__ = None;
6013 let mut version_column_indices__ = None;
6014 let mut cdc_table_id__ = None;
6015 let mut maybe_vnode_count__ = None;
6016 let mut webhook_info__ = None;
6017 let mut job_id__ = None;
6018 let mut engine__ = None;
6019 let mut clean_watermark_index_in_pk__ = None;
6020 let mut refreshable__ = None;
6021 let mut vector_index_info__ = None;
6022 let mut cdc_table_type__ = None;
6023 let mut refresh_state__ = None;
6024 let mut version__ = None;
6025 let mut optional_associated_source_id__ = None;
6026 while let Some(k) = map_.next_key()? {
6027 match k {
6028 GeneratedField::Id => {
6029 if id__.is_some() {
6030 return Err(serde::de::Error::duplicate_field("id"));
6031 }
6032 id__ =
6033 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6034 ;
6035 }
6036 GeneratedField::SchemaId => {
6037 if schema_id__.is_some() {
6038 return Err(serde::de::Error::duplicate_field("schemaId"));
6039 }
6040 schema_id__ =
6041 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6042 ;
6043 }
6044 GeneratedField::DatabaseId => {
6045 if database_id__.is_some() {
6046 return Err(serde::de::Error::duplicate_field("databaseId"));
6047 }
6048 database_id__ =
6049 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6050 ;
6051 }
6052 GeneratedField::Name => {
6053 if name__.is_some() {
6054 return Err(serde::de::Error::duplicate_field("name"));
6055 }
6056 name__ = Some(map_.next_value()?);
6057 }
6058 GeneratedField::Columns => {
6059 if columns__.is_some() {
6060 return Err(serde::de::Error::duplicate_field("columns"));
6061 }
6062 columns__ = Some(map_.next_value()?);
6063 }
6064 GeneratedField::Pk => {
6065 if pk__.is_some() {
6066 return Err(serde::de::Error::duplicate_field("pk"));
6067 }
6068 pk__ = Some(map_.next_value()?);
6069 }
6070 GeneratedField::TableType => {
6071 if table_type__.is_some() {
6072 return Err(serde::de::Error::duplicate_field("tableType"));
6073 }
6074 table_type__ = Some(map_.next_value::<table::TableType>()? as i32);
6075 }
6076 GeneratedField::DistributionKey => {
6077 if distribution_key__.is_some() {
6078 return Err(serde::de::Error::duplicate_field("distributionKey"));
6079 }
6080 distribution_key__ =
6081 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6082 .into_iter().map(|x| x.0).collect())
6083 ;
6084 }
6085 GeneratedField::StreamKey => {
6086 if stream_key__.is_some() {
6087 return Err(serde::de::Error::duplicate_field("streamKey"));
6088 }
6089 stream_key__ =
6090 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6091 .into_iter().map(|x| x.0).collect())
6092 ;
6093 }
6094 GeneratedField::AppendOnly => {
6095 if append_only__.is_some() {
6096 return Err(serde::de::Error::duplicate_field("appendOnly"));
6097 }
6098 append_only__ = Some(map_.next_value()?);
6099 }
6100 GeneratedField::Owner => {
6101 if owner__.is_some() {
6102 return Err(serde::de::Error::duplicate_field("owner"));
6103 }
6104 owner__ =
6105 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6106 ;
6107 }
6108 GeneratedField::FragmentId => {
6109 if fragment_id__.is_some() {
6110 return Err(serde::de::Error::duplicate_field("fragmentId"));
6111 }
6112 fragment_id__ =
6113 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6114 ;
6115 }
6116 GeneratedField::VnodeColIndex => {
6117 if vnode_col_index__.is_some() {
6118 return Err(serde::de::Error::duplicate_field("vnodeColIndex"));
6119 }
6120 vnode_col_index__ =
6121 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6122 ;
6123 }
6124 GeneratedField::RowIdIndex => {
6125 if row_id_index__.is_some() {
6126 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
6127 }
6128 row_id_index__ =
6129 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6130 ;
6131 }
6132 GeneratedField::ValueIndices => {
6133 if value_indices__.is_some() {
6134 return Err(serde::de::Error::duplicate_field("valueIndices"));
6135 }
6136 value_indices__ =
6137 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6138 .into_iter().map(|x| x.0).collect())
6139 ;
6140 }
6141 GeneratedField::Definition => {
6142 if definition__.is_some() {
6143 return Err(serde::de::Error::duplicate_field("definition"));
6144 }
6145 definition__ = Some(map_.next_value()?);
6146 }
6147 GeneratedField::HandlePkConflictBehavior => {
6148 if handle_pk_conflict_behavior__.is_some() {
6149 return Err(serde::de::Error::duplicate_field("handlePkConflictBehavior"));
6150 }
6151 handle_pk_conflict_behavior__ = Some(map_.next_value::<HandleConflictBehavior>()? as i32);
6152 }
6153 GeneratedField::ReadPrefixLenHint => {
6154 if read_prefix_len_hint__.is_some() {
6155 return Err(serde::de::Error::duplicate_field("readPrefixLenHint"));
6156 }
6157 read_prefix_len_hint__ =
6158 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6159 ;
6160 }
6161 GeneratedField::WatermarkIndices => {
6162 if watermark_indices__.is_some() {
6163 return Err(serde::de::Error::duplicate_field("watermarkIndices"));
6164 }
6165 watermark_indices__ =
6166 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6167 .into_iter().map(|x| x.0).collect())
6168 ;
6169 }
6170 GeneratedField::DistKeyInPk => {
6171 if dist_key_in_pk__.is_some() {
6172 return Err(serde::de::Error::duplicate_field("distKeyInPk"));
6173 }
6174 dist_key_in_pk__ =
6175 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6176 .into_iter().map(|x| x.0).collect())
6177 ;
6178 }
6179 GeneratedField::DmlFragmentId => {
6180 if dml_fragment_id__.is_some() {
6181 return Err(serde::de::Error::duplicate_field("dmlFragmentId"));
6182 }
6183 dml_fragment_id__ =
6184 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6185 ;
6186 }
6187 GeneratedField::Cardinality => {
6188 if cardinality__.is_some() {
6189 return Err(serde::de::Error::duplicate_field("cardinality"));
6190 }
6191 cardinality__ = map_.next_value()?;
6192 }
6193 GeneratedField::InitializedAtEpoch => {
6194 if initialized_at_epoch__.is_some() {
6195 return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
6196 }
6197 initialized_at_epoch__ =
6198 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6199 ;
6200 }
6201 GeneratedField::CreatedAtEpoch => {
6202 if created_at_epoch__.is_some() {
6203 return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
6204 }
6205 created_at_epoch__ =
6206 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6207 ;
6208 }
6209 GeneratedField::CleanedByWatermark => {
6210 if cleaned_by_watermark__.is_some() {
6211 return Err(serde::de::Error::duplicate_field("cleanedByWatermark"));
6212 }
6213 cleaned_by_watermark__ = Some(map_.next_value()?);
6214 }
6215 GeneratedField::StreamJobStatus => {
6216 if stream_job_status__.is_some() {
6217 return Err(serde::de::Error::duplicate_field("streamJobStatus"));
6218 }
6219 stream_job_status__ = Some(map_.next_value::<StreamJobStatus>()? as i32);
6220 }
6221 GeneratedField::CreateType => {
6222 if create_type__.is_some() {
6223 return Err(serde::de::Error::duplicate_field("createType"));
6224 }
6225 create_type__ = Some(map_.next_value::<CreateType>()? as i32);
6226 }
6227 GeneratedField::Description => {
6228 if description__.is_some() {
6229 return Err(serde::de::Error::duplicate_field("description"));
6230 }
6231 description__ = map_.next_value()?;
6232 }
6233 GeneratedField::IncomingSinks => {
6234 if incoming_sinks__.is_some() {
6235 return Err(serde::de::Error::duplicate_field("incomingSinks"));
6236 }
6237 incoming_sinks__ =
6238 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6239 .into_iter().map(|x| x.0).collect())
6240 ;
6241 }
6242 GeneratedField::InitializedAtClusterVersion => {
6243 if initialized_at_cluster_version__.is_some() {
6244 return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
6245 }
6246 initialized_at_cluster_version__ = map_.next_value()?;
6247 }
6248 GeneratedField::CreatedAtClusterVersion => {
6249 if created_at_cluster_version__.is_some() {
6250 return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
6251 }
6252 created_at_cluster_version__ = map_.next_value()?;
6253 }
6254 GeneratedField::RetentionSeconds => {
6255 if retention_seconds__.is_some() {
6256 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
6257 }
6258 retention_seconds__ =
6259 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6260 ;
6261 }
6262 GeneratedField::VersionColumnIndices => {
6263 if version_column_indices__.is_some() {
6264 return Err(serde::de::Error::duplicate_field("versionColumnIndices"));
6265 }
6266 version_column_indices__ =
6267 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6268 .into_iter().map(|x| x.0).collect())
6269 ;
6270 }
6271 GeneratedField::CdcTableId => {
6272 if cdc_table_id__.is_some() {
6273 return Err(serde::de::Error::duplicate_field("cdcTableId"));
6274 }
6275 cdc_table_id__ = map_.next_value()?;
6276 }
6277 GeneratedField::MaybeVnodeCount => {
6278 if maybe_vnode_count__.is_some() {
6279 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
6280 }
6281 maybe_vnode_count__ =
6282 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6283 ;
6284 }
6285 GeneratedField::WebhookInfo => {
6286 if webhook_info__.is_some() {
6287 return Err(serde::de::Error::duplicate_field("webhookInfo"));
6288 }
6289 webhook_info__ = map_.next_value()?;
6290 }
6291 GeneratedField::JobId => {
6292 if job_id__.is_some() {
6293 return Err(serde::de::Error::duplicate_field("jobId"));
6294 }
6295 job_id__ =
6296 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6297 ;
6298 }
6299 GeneratedField::Engine => {
6300 if engine__.is_some() {
6301 return Err(serde::de::Error::duplicate_field("engine"));
6302 }
6303 engine__ = map_.next_value::<::std::option::Option<table::Engine>>()?.map(|x| x as i32);
6304 }
6305 GeneratedField::CleanWatermarkIndexInPk => {
6306 if clean_watermark_index_in_pk__.is_some() {
6307 return Err(serde::de::Error::duplicate_field("cleanWatermarkIndexInPk"));
6308 }
6309 clean_watermark_index_in_pk__ =
6310 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6311 ;
6312 }
6313 GeneratedField::Refreshable => {
6314 if refreshable__.is_some() {
6315 return Err(serde::de::Error::duplicate_field("refreshable"));
6316 }
6317 refreshable__ = Some(map_.next_value()?);
6318 }
6319 GeneratedField::VectorIndexInfo => {
6320 if vector_index_info__.is_some() {
6321 return Err(serde::de::Error::duplicate_field("vectorIndexInfo"));
6322 }
6323 vector_index_info__ = map_.next_value()?;
6324 }
6325 GeneratedField::CdcTableType => {
6326 if cdc_table_type__.is_some() {
6327 return Err(serde::de::Error::duplicate_field("cdcTableType"));
6328 }
6329 cdc_table_type__ = map_.next_value::<::std::option::Option<table::CdcTableType>>()?.map(|x| x as i32);
6330 }
6331 GeneratedField::RefreshState => {
6332 if refresh_state__.is_some() {
6333 return Err(serde::de::Error::duplicate_field("refreshState"));
6334 }
6335 refresh_state__ = map_.next_value::<::std::option::Option<RefreshState>>()?.map(|x| x as i32);
6336 }
6337 GeneratedField::Version => {
6338 if version__.is_some() {
6339 return Err(serde::de::Error::duplicate_field("version"));
6340 }
6341 version__ = map_.next_value()?;
6342 }
6343 GeneratedField::AssociatedSourceId => {
6344 if optional_associated_source_id__.is_some() {
6345 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
6346 }
6347 optional_associated_source_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| table::OptionalAssociatedSourceId::AssociatedSourceId(x.0));
6348 }
6349 }
6350 }
6351 Ok(Table {
6352 id: id__.unwrap_or_default(),
6353 schema_id: schema_id__.unwrap_or_default(),
6354 database_id: database_id__.unwrap_or_default(),
6355 name: name__.unwrap_or_default(),
6356 columns: columns__.unwrap_or_default(),
6357 pk: pk__.unwrap_or_default(),
6358 table_type: table_type__.unwrap_or_default(),
6359 distribution_key: distribution_key__.unwrap_or_default(),
6360 stream_key: stream_key__.unwrap_or_default(),
6361 append_only: append_only__.unwrap_or_default(),
6362 owner: owner__.unwrap_or_default(),
6363 fragment_id: fragment_id__.unwrap_or_default(),
6364 vnode_col_index: vnode_col_index__,
6365 row_id_index: row_id_index__,
6366 value_indices: value_indices__.unwrap_or_default(),
6367 definition: definition__.unwrap_or_default(),
6368 handle_pk_conflict_behavior: handle_pk_conflict_behavior__.unwrap_or_default(),
6369 read_prefix_len_hint: read_prefix_len_hint__.unwrap_or_default(),
6370 watermark_indices: watermark_indices__.unwrap_or_default(),
6371 dist_key_in_pk: dist_key_in_pk__.unwrap_or_default(),
6372 dml_fragment_id: dml_fragment_id__,
6373 cardinality: cardinality__,
6374 initialized_at_epoch: initialized_at_epoch__,
6375 created_at_epoch: created_at_epoch__,
6376 cleaned_by_watermark: cleaned_by_watermark__.unwrap_or_default(),
6377 stream_job_status: stream_job_status__.unwrap_or_default(),
6378 create_type: create_type__.unwrap_or_default(),
6379 description: description__,
6380 incoming_sinks: incoming_sinks__.unwrap_or_default(),
6381 initialized_at_cluster_version: initialized_at_cluster_version__,
6382 created_at_cluster_version: created_at_cluster_version__,
6383 retention_seconds: retention_seconds__,
6384 version_column_indices: version_column_indices__.unwrap_or_default(),
6385 cdc_table_id: cdc_table_id__,
6386 maybe_vnode_count: maybe_vnode_count__,
6387 webhook_info: webhook_info__,
6388 job_id: job_id__,
6389 engine: engine__,
6390 clean_watermark_index_in_pk: clean_watermark_index_in_pk__,
6391 refreshable: refreshable__.unwrap_or_default(),
6392 vector_index_info: vector_index_info__,
6393 cdc_table_type: cdc_table_type__,
6394 refresh_state: refresh_state__,
6395 version: version__,
6396 optional_associated_source_id: optional_associated_source_id__,
6397 })
6398 }
6399 }
6400 deserializer.deserialize_struct("catalog.Table", FIELDS, GeneratedVisitor)
6401 }
6402}
6403impl serde::Serialize for table::CdcTableType {
6404 #[allow(deprecated)]
6405 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6406 where
6407 S: serde::Serializer,
6408 {
6409 let variant = match self {
6410 Self::Unspecified => "CDC_TABLE_TYPE_UNSPECIFIED",
6411 Self::Postgres => "CDC_TABLE_TYPE_POSTGRES",
6412 Self::Mysql => "CDC_TABLE_TYPE_MYSQL",
6413 Self::Sqlserver => "CDC_TABLE_TYPE_SQLSERVER",
6414 Self::Mongo => "CDC_TABLE_TYPE_MONGO",
6415 Self::Citus => "CDC_TABLE_TYPE_CITUS",
6416 };
6417 serializer.serialize_str(variant)
6418 }
6419}
6420impl<'de> serde::Deserialize<'de> for table::CdcTableType {
6421 #[allow(deprecated)]
6422 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6423 where
6424 D: serde::Deserializer<'de>,
6425 {
6426 const FIELDS: &[&str] = &[
6427 "CDC_TABLE_TYPE_UNSPECIFIED",
6428 "CDC_TABLE_TYPE_POSTGRES",
6429 "CDC_TABLE_TYPE_MYSQL",
6430 "CDC_TABLE_TYPE_SQLSERVER",
6431 "CDC_TABLE_TYPE_MONGO",
6432 "CDC_TABLE_TYPE_CITUS",
6433 ];
6434
6435 struct GeneratedVisitor;
6436
6437 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6438 type Value = table::CdcTableType;
6439
6440 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6441 write!(formatter, "expected one of: {:?}", &FIELDS)
6442 }
6443
6444 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6445 where
6446 E: serde::de::Error,
6447 {
6448 i32::try_from(v)
6449 .ok()
6450 .and_then(|x| x.try_into().ok())
6451 .ok_or_else(|| {
6452 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6453 })
6454 }
6455
6456 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6457 where
6458 E: serde::de::Error,
6459 {
6460 i32::try_from(v)
6461 .ok()
6462 .and_then(|x| x.try_into().ok())
6463 .ok_or_else(|| {
6464 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6465 })
6466 }
6467
6468 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6469 where
6470 E: serde::de::Error,
6471 {
6472 match value {
6473 "CDC_TABLE_TYPE_UNSPECIFIED" => Ok(table::CdcTableType::Unspecified),
6474 "CDC_TABLE_TYPE_POSTGRES" => Ok(table::CdcTableType::Postgres),
6475 "CDC_TABLE_TYPE_MYSQL" => Ok(table::CdcTableType::Mysql),
6476 "CDC_TABLE_TYPE_SQLSERVER" => Ok(table::CdcTableType::Sqlserver),
6477 "CDC_TABLE_TYPE_MONGO" => Ok(table::CdcTableType::Mongo),
6478 "CDC_TABLE_TYPE_CITUS" => Ok(table::CdcTableType::Citus),
6479 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6480 }
6481 }
6482 }
6483 deserializer.deserialize_any(GeneratedVisitor)
6484 }
6485}
6486impl serde::Serialize for table::Engine {
6487 #[allow(deprecated)]
6488 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6489 where
6490 S: serde::Serializer,
6491 {
6492 let variant = match self {
6493 Self::Unspecified => "ENGINE_UNSPECIFIED",
6494 Self::Hummock => "HUMMOCK",
6495 Self::Iceberg => "ICEBERG",
6496 };
6497 serializer.serialize_str(variant)
6498 }
6499}
6500impl<'de> serde::Deserialize<'de> for table::Engine {
6501 #[allow(deprecated)]
6502 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6503 where
6504 D: serde::Deserializer<'de>,
6505 {
6506 const FIELDS: &[&str] = &[
6507 "ENGINE_UNSPECIFIED",
6508 "HUMMOCK",
6509 "ICEBERG",
6510 ];
6511
6512 struct GeneratedVisitor;
6513
6514 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6515 type Value = table::Engine;
6516
6517 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6518 write!(formatter, "expected one of: {:?}", &FIELDS)
6519 }
6520
6521 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6522 where
6523 E: serde::de::Error,
6524 {
6525 i32::try_from(v)
6526 .ok()
6527 .and_then(|x| x.try_into().ok())
6528 .ok_or_else(|| {
6529 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6530 })
6531 }
6532
6533 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6534 where
6535 E: serde::de::Error,
6536 {
6537 i32::try_from(v)
6538 .ok()
6539 .and_then(|x| x.try_into().ok())
6540 .ok_or_else(|| {
6541 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6542 })
6543 }
6544
6545 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6546 where
6547 E: serde::de::Error,
6548 {
6549 match value {
6550 "ENGINE_UNSPECIFIED" => Ok(table::Engine::Unspecified),
6551 "HUMMOCK" => Ok(table::Engine::Hummock),
6552 "ICEBERG" => Ok(table::Engine::Iceberg),
6553 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6554 }
6555 }
6556 }
6557 deserializer.deserialize_any(GeneratedVisitor)
6558 }
6559}
6560impl serde::Serialize for table::TableType {
6561 #[allow(deprecated)]
6562 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6563 where
6564 S: serde::Serializer,
6565 {
6566 let variant = match self {
6567 Self::Unspecified => "UNSPECIFIED",
6568 Self::Table => "TABLE",
6569 Self::MaterializedView => "MATERIALIZED_VIEW",
6570 Self::Index => "INDEX",
6571 Self::Internal => "INTERNAL",
6572 Self::VectorIndex => "VECTOR_INDEX",
6573 };
6574 serializer.serialize_str(variant)
6575 }
6576}
6577impl<'de> serde::Deserialize<'de> for table::TableType {
6578 #[allow(deprecated)]
6579 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6580 where
6581 D: serde::Deserializer<'de>,
6582 {
6583 const FIELDS: &[&str] = &[
6584 "UNSPECIFIED",
6585 "TABLE",
6586 "MATERIALIZED_VIEW",
6587 "INDEX",
6588 "INTERNAL",
6589 "VECTOR_INDEX",
6590 ];
6591
6592 struct GeneratedVisitor;
6593
6594 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6595 type Value = table::TableType;
6596
6597 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6598 write!(formatter, "expected one of: {:?}", &FIELDS)
6599 }
6600
6601 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6602 where
6603 E: serde::de::Error,
6604 {
6605 i32::try_from(v)
6606 .ok()
6607 .and_then(|x| x.try_into().ok())
6608 .ok_or_else(|| {
6609 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6610 })
6611 }
6612
6613 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6614 where
6615 E: serde::de::Error,
6616 {
6617 i32::try_from(v)
6618 .ok()
6619 .and_then(|x| x.try_into().ok())
6620 .ok_or_else(|| {
6621 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6622 })
6623 }
6624
6625 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6626 where
6627 E: serde::de::Error,
6628 {
6629 match value {
6630 "UNSPECIFIED" => Ok(table::TableType::Unspecified),
6631 "TABLE" => Ok(table::TableType::Table),
6632 "MATERIALIZED_VIEW" => Ok(table::TableType::MaterializedView),
6633 "INDEX" => Ok(table::TableType::Index),
6634 "INTERNAL" => Ok(table::TableType::Internal),
6635 "VECTOR_INDEX" => Ok(table::TableType::VectorIndex),
6636 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6637 }
6638 }
6639 }
6640 deserializer.deserialize_any(GeneratedVisitor)
6641 }
6642}
6643impl serde::Serialize for table::TableVersion {
6644 #[allow(deprecated)]
6645 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6646 where
6647 S: serde::Serializer,
6648 {
6649 use serde::ser::SerializeStruct;
6650 let mut len = 0;
6651 if self.version != 0 {
6652 len += 1;
6653 }
6654 if self.next_column_id != 0 {
6655 len += 1;
6656 }
6657 let mut struct_ser = serializer.serialize_struct("catalog.Table.TableVersion", len)?;
6658 if self.version != 0 {
6659 #[allow(clippy::needless_borrow)]
6660 #[allow(clippy::needless_borrows_for_generic_args)]
6661 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
6662 }
6663 if self.next_column_id != 0 {
6664 struct_ser.serialize_field("nextColumnId", &self.next_column_id)?;
6665 }
6666 struct_ser.end()
6667 }
6668}
6669impl<'de> serde::Deserialize<'de> for table::TableVersion {
6670 #[allow(deprecated)]
6671 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6672 where
6673 D: serde::Deserializer<'de>,
6674 {
6675 const FIELDS: &[&str] = &[
6676 "version",
6677 "next_column_id",
6678 "nextColumnId",
6679 ];
6680
6681 #[allow(clippy::enum_variant_names)]
6682 enum GeneratedField {
6683 Version,
6684 NextColumnId,
6685 }
6686 impl<'de> serde::Deserialize<'de> for GeneratedField {
6687 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6688 where
6689 D: serde::Deserializer<'de>,
6690 {
6691 struct GeneratedVisitor;
6692
6693 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6694 type Value = GeneratedField;
6695
6696 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6697 write!(formatter, "expected one of: {:?}", &FIELDS)
6698 }
6699
6700 #[allow(unused_variables)]
6701 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6702 where
6703 E: serde::de::Error,
6704 {
6705 match value {
6706 "version" => Ok(GeneratedField::Version),
6707 "nextColumnId" | "next_column_id" => Ok(GeneratedField::NextColumnId),
6708 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6709 }
6710 }
6711 }
6712 deserializer.deserialize_identifier(GeneratedVisitor)
6713 }
6714 }
6715 struct GeneratedVisitor;
6716 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6717 type Value = table::TableVersion;
6718
6719 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6720 formatter.write_str("struct catalog.Table.TableVersion")
6721 }
6722
6723 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table::TableVersion, V::Error>
6724 where
6725 V: serde::de::MapAccess<'de>,
6726 {
6727 let mut version__ = None;
6728 let mut next_column_id__ = None;
6729 while let Some(k) = map_.next_key()? {
6730 match k {
6731 GeneratedField::Version => {
6732 if version__.is_some() {
6733 return Err(serde::de::Error::duplicate_field("version"));
6734 }
6735 version__ =
6736 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6737 ;
6738 }
6739 GeneratedField::NextColumnId => {
6740 if next_column_id__.is_some() {
6741 return Err(serde::de::Error::duplicate_field("nextColumnId"));
6742 }
6743 next_column_id__ =
6744 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6745 ;
6746 }
6747 }
6748 }
6749 Ok(table::TableVersion {
6750 version: version__.unwrap_or_default(),
6751 next_column_id: next_column_id__.unwrap_or_default(),
6752 })
6753 }
6754 }
6755 deserializer.deserialize_struct("catalog.Table.TableVersion", FIELDS, GeneratedVisitor)
6756 }
6757}
6758impl serde::Serialize for VectorIndexInfo {
6759 #[allow(deprecated)]
6760 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6761 where
6762 S: serde::Serializer,
6763 {
6764 use serde::ser::SerializeStruct;
6765 let mut len = 0;
6766 if self.dimension != 0 {
6767 len += 1;
6768 }
6769 if self.distance_type != 0 {
6770 len += 1;
6771 }
6772 if self.config.is_some() {
6773 len += 1;
6774 }
6775 let mut struct_ser = serializer.serialize_struct("catalog.VectorIndexInfo", len)?;
6776 if self.dimension != 0 {
6777 struct_ser.serialize_field("dimension", &self.dimension)?;
6778 }
6779 if self.distance_type != 0 {
6780 let v = super::common::DistanceType::try_from(self.distance_type)
6781 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distance_type)))?;
6782 struct_ser.serialize_field("distanceType", &v)?;
6783 }
6784 if let Some(v) = self.config.as_ref() {
6785 match v {
6786 vector_index_info::Config::Flat(v) => {
6787 struct_ser.serialize_field("flat", v)?;
6788 }
6789 vector_index_info::Config::HnswFlat(v) => {
6790 struct_ser.serialize_field("hnswFlat", v)?;
6791 }
6792 }
6793 }
6794 struct_ser.end()
6795 }
6796}
6797impl<'de> serde::Deserialize<'de> for VectorIndexInfo {
6798 #[allow(deprecated)]
6799 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6800 where
6801 D: serde::Deserializer<'de>,
6802 {
6803 const FIELDS: &[&str] = &[
6804 "dimension",
6805 "distance_type",
6806 "distanceType",
6807 "flat",
6808 "hnsw_flat",
6809 "hnswFlat",
6810 ];
6811
6812 #[allow(clippy::enum_variant_names)]
6813 enum GeneratedField {
6814 Dimension,
6815 DistanceType,
6816 Flat,
6817 HnswFlat,
6818 }
6819 impl<'de> serde::Deserialize<'de> for GeneratedField {
6820 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6821 where
6822 D: serde::Deserializer<'de>,
6823 {
6824 struct GeneratedVisitor;
6825
6826 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6827 type Value = GeneratedField;
6828
6829 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6830 write!(formatter, "expected one of: {:?}", &FIELDS)
6831 }
6832
6833 #[allow(unused_variables)]
6834 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6835 where
6836 E: serde::de::Error,
6837 {
6838 match value {
6839 "dimension" => Ok(GeneratedField::Dimension),
6840 "distanceType" | "distance_type" => Ok(GeneratedField::DistanceType),
6841 "flat" => Ok(GeneratedField::Flat),
6842 "hnswFlat" | "hnsw_flat" => Ok(GeneratedField::HnswFlat),
6843 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6844 }
6845 }
6846 }
6847 deserializer.deserialize_identifier(GeneratedVisitor)
6848 }
6849 }
6850 struct GeneratedVisitor;
6851 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6852 type Value = VectorIndexInfo;
6853
6854 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6855 formatter.write_str("struct catalog.VectorIndexInfo")
6856 }
6857
6858 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexInfo, V::Error>
6859 where
6860 V: serde::de::MapAccess<'de>,
6861 {
6862 let mut dimension__ = None;
6863 let mut distance_type__ = None;
6864 let mut config__ = None;
6865 while let Some(k) = map_.next_key()? {
6866 match k {
6867 GeneratedField::Dimension => {
6868 if dimension__.is_some() {
6869 return Err(serde::de::Error::duplicate_field("dimension"));
6870 }
6871 dimension__ =
6872 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6873 ;
6874 }
6875 GeneratedField::DistanceType => {
6876 if distance_type__.is_some() {
6877 return Err(serde::de::Error::duplicate_field("distanceType"));
6878 }
6879 distance_type__ = Some(map_.next_value::<super::common::DistanceType>()? as i32);
6880 }
6881 GeneratedField::Flat => {
6882 if config__.is_some() {
6883 return Err(serde::de::Error::duplicate_field("flat"));
6884 }
6885 config__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_info::Config::Flat)
6886;
6887 }
6888 GeneratedField::HnswFlat => {
6889 if config__.is_some() {
6890 return Err(serde::de::Error::duplicate_field("hnswFlat"));
6891 }
6892 config__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_info::Config::HnswFlat)
6893;
6894 }
6895 }
6896 }
6897 Ok(VectorIndexInfo {
6898 dimension: dimension__.unwrap_or_default(),
6899 distance_type: distance_type__.unwrap_or_default(),
6900 config: config__,
6901 })
6902 }
6903 }
6904 deserializer.deserialize_struct("catalog.VectorIndexInfo", FIELDS, GeneratedVisitor)
6905 }
6906}
6907impl serde::Serialize for View {
6908 #[allow(deprecated)]
6909 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6910 where
6911 S: serde::Serializer,
6912 {
6913 use serde::ser::SerializeStruct;
6914 let mut len = 0;
6915 if self.id != 0 {
6916 len += 1;
6917 }
6918 if self.schema_id != 0 {
6919 len += 1;
6920 }
6921 if self.database_id != 0 {
6922 len += 1;
6923 }
6924 if !self.name.is_empty() {
6925 len += 1;
6926 }
6927 if self.owner != 0 {
6928 len += 1;
6929 }
6930 if !self.properties.is_empty() {
6931 len += 1;
6932 }
6933 if !self.sql.is_empty() {
6934 len += 1;
6935 }
6936 if !self.columns.is_empty() {
6937 len += 1;
6938 }
6939 let mut struct_ser = serializer.serialize_struct("catalog.View", len)?;
6940 if self.id != 0 {
6941 struct_ser.serialize_field("id", &self.id)?;
6942 }
6943 if self.schema_id != 0 {
6944 struct_ser.serialize_field("schemaId", &self.schema_id)?;
6945 }
6946 if self.database_id != 0 {
6947 struct_ser.serialize_field("databaseId", &self.database_id)?;
6948 }
6949 if !self.name.is_empty() {
6950 struct_ser.serialize_field("name", &self.name)?;
6951 }
6952 if self.owner != 0 {
6953 struct_ser.serialize_field("owner", &self.owner)?;
6954 }
6955 if !self.properties.is_empty() {
6956 struct_ser.serialize_field("properties", &self.properties)?;
6957 }
6958 if !self.sql.is_empty() {
6959 struct_ser.serialize_field("sql", &self.sql)?;
6960 }
6961 if !self.columns.is_empty() {
6962 struct_ser.serialize_field("columns", &self.columns)?;
6963 }
6964 struct_ser.end()
6965 }
6966}
6967impl<'de> serde::Deserialize<'de> for View {
6968 #[allow(deprecated)]
6969 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6970 where
6971 D: serde::Deserializer<'de>,
6972 {
6973 const FIELDS: &[&str] = &[
6974 "id",
6975 "schema_id",
6976 "schemaId",
6977 "database_id",
6978 "databaseId",
6979 "name",
6980 "owner",
6981 "properties",
6982 "sql",
6983 "columns",
6984 ];
6985
6986 #[allow(clippy::enum_variant_names)]
6987 enum GeneratedField {
6988 Id,
6989 SchemaId,
6990 DatabaseId,
6991 Name,
6992 Owner,
6993 Properties,
6994 Sql,
6995 Columns,
6996 }
6997 impl<'de> serde::Deserialize<'de> for GeneratedField {
6998 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6999 where
7000 D: serde::Deserializer<'de>,
7001 {
7002 struct GeneratedVisitor;
7003
7004 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7005 type Value = GeneratedField;
7006
7007 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7008 write!(formatter, "expected one of: {:?}", &FIELDS)
7009 }
7010
7011 #[allow(unused_variables)]
7012 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7013 where
7014 E: serde::de::Error,
7015 {
7016 match value {
7017 "id" => Ok(GeneratedField::Id),
7018 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
7019 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
7020 "name" => Ok(GeneratedField::Name),
7021 "owner" => Ok(GeneratedField::Owner),
7022 "properties" => Ok(GeneratedField::Properties),
7023 "sql" => Ok(GeneratedField::Sql),
7024 "columns" => Ok(GeneratedField::Columns),
7025 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7026 }
7027 }
7028 }
7029 deserializer.deserialize_identifier(GeneratedVisitor)
7030 }
7031 }
7032 struct GeneratedVisitor;
7033 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7034 type Value = View;
7035
7036 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7037 formatter.write_str("struct catalog.View")
7038 }
7039
7040 fn visit_map<V>(self, mut map_: V) -> std::result::Result<View, V::Error>
7041 where
7042 V: serde::de::MapAccess<'de>,
7043 {
7044 let mut id__ = None;
7045 let mut schema_id__ = None;
7046 let mut database_id__ = None;
7047 let mut name__ = None;
7048 let mut owner__ = None;
7049 let mut properties__ = None;
7050 let mut sql__ = None;
7051 let mut columns__ = None;
7052 while let Some(k) = map_.next_key()? {
7053 match k {
7054 GeneratedField::Id => {
7055 if id__.is_some() {
7056 return Err(serde::de::Error::duplicate_field("id"));
7057 }
7058 id__ =
7059 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7060 ;
7061 }
7062 GeneratedField::SchemaId => {
7063 if schema_id__.is_some() {
7064 return Err(serde::de::Error::duplicate_field("schemaId"));
7065 }
7066 schema_id__ =
7067 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7068 ;
7069 }
7070 GeneratedField::DatabaseId => {
7071 if database_id__.is_some() {
7072 return Err(serde::de::Error::duplicate_field("databaseId"));
7073 }
7074 database_id__ =
7075 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7076 ;
7077 }
7078 GeneratedField::Name => {
7079 if name__.is_some() {
7080 return Err(serde::de::Error::duplicate_field("name"));
7081 }
7082 name__ = Some(map_.next_value()?);
7083 }
7084 GeneratedField::Owner => {
7085 if owner__.is_some() {
7086 return Err(serde::de::Error::duplicate_field("owner"));
7087 }
7088 owner__ =
7089 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7090 ;
7091 }
7092 GeneratedField::Properties => {
7093 if properties__.is_some() {
7094 return Err(serde::de::Error::duplicate_field("properties"));
7095 }
7096 properties__ = Some(
7097 map_.next_value::<std::collections::BTreeMap<_, _>>()?
7098 );
7099 }
7100 GeneratedField::Sql => {
7101 if sql__.is_some() {
7102 return Err(serde::de::Error::duplicate_field("sql"));
7103 }
7104 sql__ = Some(map_.next_value()?);
7105 }
7106 GeneratedField::Columns => {
7107 if columns__.is_some() {
7108 return Err(serde::de::Error::duplicate_field("columns"));
7109 }
7110 columns__ = Some(map_.next_value()?);
7111 }
7112 }
7113 }
7114 Ok(View {
7115 id: id__.unwrap_or_default(),
7116 schema_id: schema_id__.unwrap_or_default(),
7117 database_id: database_id__.unwrap_or_default(),
7118 name: name__.unwrap_or_default(),
7119 owner: owner__.unwrap_or_default(),
7120 properties: properties__.unwrap_or_default(),
7121 sql: sql__.unwrap_or_default(),
7122 columns: columns__.unwrap_or_default(),
7123 })
7124 }
7125 }
7126 deserializer.deserialize_struct("catalog.View", FIELDS, GeneratedVisitor)
7127 }
7128}
7129impl serde::Serialize for WatermarkDesc {
7130 #[allow(deprecated)]
7131 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7132 where
7133 S: serde::Serializer,
7134 {
7135 use serde::ser::SerializeStruct;
7136 let mut len = 0;
7137 if self.watermark_idx != 0 {
7138 len += 1;
7139 }
7140 if self.expr.is_some() {
7141 len += 1;
7142 }
7143 let mut struct_ser = serializer.serialize_struct("catalog.WatermarkDesc", len)?;
7144 if self.watermark_idx != 0 {
7145 struct_ser.serialize_field("watermarkIdx", &self.watermark_idx)?;
7146 }
7147 if let Some(v) = self.expr.as_ref() {
7148 struct_ser.serialize_field("expr", v)?;
7149 }
7150 struct_ser.end()
7151 }
7152}
7153impl<'de> serde::Deserialize<'de> for WatermarkDesc {
7154 #[allow(deprecated)]
7155 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7156 where
7157 D: serde::Deserializer<'de>,
7158 {
7159 const FIELDS: &[&str] = &[
7160 "watermark_idx",
7161 "watermarkIdx",
7162 "expr",
7163 ];
7164
7165 #[allow(clippy::enum_variant_names)]
7166 enum GeneratedField {
7167 WatermarkIdx,
7168 Expr,
7169 }
7170 impl<'de> serde::Deserialize<'de> for GeneratedField {
7171 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7172 where
7173 D: serde::Deserializer<'de>,
7174 {
7175 struct GeneratedVisitor;
7176
7177 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7178 type Value = GeneratedField;
7179
7180 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7181 write!(formatter, "expected one of: {:?}", &FIELDS)
7182 }
7183
7184 #[allow(unused_variables)]
7185 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7186 where
7187 E: serde::de::Error,
7188 {
7189 match value {
7190 "watermarkIdx" | "watermark_idx" => Ok(GeneratedField::WatermarkIdx),
7191 "expr" => Ok(GeneratedField::Expr),
7192 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7193 }
7194 }
7195 }
7196 deserializer.deserialize_identifier(GeneratedVisitor)
7197 }
7198 }
7199 struct GeneratedVisitor;
7200 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7201 type Value = WatermarkDesc;
7202
7203 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7204 formatter.write_str("struct catalog.WatermarkDesc")
7205 }
7206
7207 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkDesc, V::Error>
7208 where
7209 V: serde::de::MapAccess<'de>,
7210 {
7211 let mut watermark_idx__ = None;
7212 let mut expr__ = None;
7213 while let Some(k) = map_.next_key()? {
7214 match k {
7215 GeneratedField::WatermarkIdx => {
7216 if watermark_idx__.is_some() {
7217 return Err(serde::de::Error::duplicate_field("watermarkIdx"));
7218 }
7219 watermark_idx__ =
7220 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7221 ;
7222 }
7223 GeneratedField::Expr => {
7224 if expr__.is_some() {
7225 return Err(serde::de::Error::duplicate_field("expr"));
7226 }
7227 expr__ = map_.next_value()?;
7228 }
7229 }
7230 }
7231 Ok(WatermarkDesc {
7232 watermark_idx: watermark_idx__.unwrap_or_default(),
7233 expr: expr__,
7234 })
7235 }
7236 }
7237 deserializer.deserialize_struct("catalog.WatermarkDesc", FIELDS, GeneratedVisitor)
7238 }
7239}
7240impl serde::Serialize for WebhookSourceInfo {
7241 #[allow(deprecated)]
7242 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7243 where
7244 S: serde::Serializer,
7245 {
7246 use serde::ser::SerializeStruct;
7247 let mut len = 0;
7248 if self.secret_ref.is_some() {
7249 len += 1;
7250 }
7251 if self.signature_expr.is_some() {
7252 len += 1;
7253 }
7254 if self.wait_for_persistence {
7255 len += 1;
7256 }
7257 if self.is_batched {
7258 len += 1;
7259 }
7260 let mut struct_ser = serializer.serialize_struct("catalog.WebhookSourceInfo", len)?;
7261 if let Some(v) = self.secret_ref.as_ref() {
7262 struct_ser.serialize_field("secretRef", v)?;
7263 }
7264 if let Some(v) = self.signature_expr.as_ref() {
7265 struct_ser.serialize_field("signatureExpr", v)?;
7266 }
7267 if self.wait_for_persistence {
7268 struct_ser.serialize_field("waitForPersistence", &self.wait_for_persistence)?;
7269 }
7270 if self.is_batched {
7271 struct_ser.serialize_field("isBatched", &self.is_batched)?;
7272 }
7273 struct_ser.end()
7274 }
7275}
7276impl<'de> serde::Deserialize<'de> for WebhookSourceInfo {
7277 #[allow(deprecated)]
7278 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7279 where
7280 D: serde::Deserializer<'de>,
7281 {
7282 const FIELDS: &[&str] = &[
7283 "secret_ref",
7284 "secretRef",
7285 "signature_expr",
7286 "signatureExpr",
7287 "wait_for_persistence",
7288 "waitForPersistence",
7289 "is_batched",
7290 "isBatched",
7291 ];
7292
7293 #[allow(clippy::enum_variant_names)]
7294 enum GeneratedField {
7295 SecretRef,
7296 SignatureExpr,
7297 WaitForPersistence,
7298 IsBatched,
7299 }
7300 impl<'de> serde::Deserialize<'de> for GeneratedField {
7301 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7302 where
7303 D: serde::Deserializer<'de>,
7304 {
7305 struct GeneratedVisitor;
7306
7307 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7308 type Value = GeneratedField;
7309
7310 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7311 write!(formatter, "expected one of: {:?}", &FIELDS)
7312 }
7313
7314 #[allow(unused_variables)]
7315 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7316 where
7317 E: serde::de::Error,
7318 {
7319 match value {
7320 "secretRef" | "secret_ref" => Ok(GeneratedField::SecretRef),
7321 "signatureExpr" | "signature_expr" => Ok(GeneratedField::SignatureExpr),
7322 "waitForPersistence" | "wait_for_persistence" => Ok(GeneratedField::WaitForPersistence),
7323 "isBatched" | "is_batched" => Ok(GeneratedField::IsBatched),
7324 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7325 }
7326 }
7327 }
7328 deserializer.deserialize_identifier(GeneratedVisitor)
7329 }
7330 }
7331 struct GeneratedVisitor;
7332 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7333 type Value = WebhookSourceInfo;
7334
7335 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7336 formatter.write_str("struct catalog.WebhookSourceInfo")
7337 }
7338
7339 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WebhookSourceInfo, V::Error>
7340 where
7341 V: serde::de::MapAccess<'de>,
7342 {
7343 let mut secret_ref__ = None;
7344 let mut signature_expr__ = None;
7345 let mut wait_for_persistence__ = None;
7346 let mut is_batched__ = None;
7347 while let Some(k) = map_.next_key()? {
7348 match k {
7349 GeneratedField::SecretRef => {
7350 if secret_ref__.is_some() {
7351 return Err(serde::de::Error::duplicate_field("secretRef"));
7352 }
7353 secret_ref__ = map_.next_value()?;
7354 }
7355 GeneratedField::SignatureExpr => {
7356 if signature_expr__.is_some() {
7357 return Err(serde::de::Error::duplicate_field("signatureExpr"));
7358 }
7359 signature_expr__ = map_.next_value()?;
7360 }
7361 GeneratedField::WaitForPersistence => {
7362 if wait_for_persistence__.is_some() {
7363 return Err(serde::de::Error::duplicate_field("waitForPersistence"));
7364 }
7365 wait_for_persistence__ = Some(map_.next_value()?);
7366 }
7367 GeneratedField::IsBatched => {
7368 if is_batched__.is_some() {
7369 return Err(serde::de::Error::duplicate_field("isBatched"));
7370 }
7371 is_batched__ = Some(map_.next_value()?);
7372 }
7373 }
7374 }
7375 Ok(WebhookSourceInfo {
7376 secret_ref: secret_ref__,
7377 signature_expr: signature_expr__,
7378 wait_for_persistence: wait_for_persistence__.unwrap_or_default(),
7379 is_batched: is_batched__.unwrap_or_default(),
7380 })
7381 }
7382 }
7383 deserializer.deserialize_struct("catalog.WebhookSourceInfo", FIELDS, GeneratedVisitor)
7384 }
7385}