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