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.refresh_state.is_some() {
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 let Some(v) = self.refresh_state.as_ref() {
5766 let v = RefreshState::try_from(*v)
5767 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
5768 struct_ser.serialize_field("refreshState", &v)?;
5769 }
5770 if let Some(v) = self.version.as_ref() {
5771 struct_ser.serialize_field("version", v)?;
5772 }
5773 if let Some(v) = self.optional_associated_source_id.as_ref() {
5774 match v {
5775 table::OptionalAssociatedSourceId::AssociatedSourceId(v) => {
5776 struct_ser.serialize_field("associatedSourceId", v)?;
5777 }
5778 }
5779 }
5780 struct_ser.end()
5781 }
5782}
5783impl<'de> serde::Deserialize<'de> for Table {
5784 #[allow(deprecated)]
5785 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5786 where
5787 D: serde::Deserializer<'de>,
5788 {
5789 const FIELDS: &[&str] = &[
5790 "id",
5791 "schema_id",
5792 "schemaId",
5793 "database_id",
5794 "databaseId",
5795 "name",
5796 "columns",
5797 "pk",
5798 "table_type",
5799 "tableType",
5800 "distribution_key",
5801 "distributionKey",
5802 "stream_key",
5803 "streamKey",
5804 "append_only",
5805 "appendOnly",
5806 "owner",
5807 "fragment_id",
5808 "fragmentId",
5809 "vnode_col_index",
5810 "vnodeColIndex",
5811 "row_id_index",
5812 "rowIdIndex",
5813 "value_indices",
5814 "valueIndices",
5815 "definition",
5816 "handle_pk_conflict_behavior",
5817 "handlePkConflictBehavior",
5818 "read_prefix_len_hint",
5819 "readPrefixLenHint",
5820 "watermark_indices",
5821 "watermarkIndices",
5822 "dist_key_in_pk",
5823 "distKeyInPk",
5824 "dml_fragment_id",
5825 "dmlFragmentId",
5826 "cardinality",
5827 "initialized_at_epoch",
5828 "initializedAtEpoch",
5829 "created_at_epoch",
5830 "createdAtEpoch",
5831 "cleaned_by_watermark",
5832 "cleanedByWatermark",
5833 "stream_job_status",
5834 "streamJobStatus",
5835 "create_type",
5836 "createType",
5837 "description",
5838 "incoming_sinks",
5839 "incomingSinks",
5840 "initialized_at_cluster_version",
5841 "initializedAtClusterVersion",
5842 "created_at_cluster_version",
5843 "createdAtClusterVersion",
5844 "retention_seconds",
5845 "retentionSeconds",
5846 "version_column_indices",
5847 "versionColumnIndices",
5848 "cdc_table_id",
5849 "cdcTableId",
5850 "maybe_vnode_count",
5851 "maybeVnodeCount",
5852 "webhook_info",
5853 "webhookInfo",
5854 "job_id",
5855 "jobId",
5856 "engine",
5857 "clean_watermark_index_in_pk",
5858 "cleanWatermarkIndexInPk",
5859 "refreshable",
5860 "vector_index_info",
5861 "vectorIndexInfo",
5862 "cdc_table_type",
5863 "cdcTableType",
5864 "refresh_state",
5865 "refreshState",
5866 "version",
5867 "associated_source_id",
5868 "associatedSourceId",
5869 ];
5870
5871 #[allow(clippy::enum_variant_names)]
5872 enum GeneratedField {
5873 Id,
5874 SchemaId,
5875 DatabaseId,
5876 Name,
5877 Columns,
5878 Pk,
5879 TableType,
5880 DistributionKey,
5881 StreamKey,
5882 AppendOnly,
5883 Owner,
5884 FragmentId,
5885 VnodeColIndex,
5886 RowIdIndex,
5887 ValueIndices,
5888 Definition,
5889 HandlePkConflictBehavior,
5890 ReadPrefixLenHint,
5891 WatermarkIndices,
5892 DistKeyInPk,
5893 DmlFragmentId,
5894 Cardinality,
5895 InitializedAtEpoch,
5896 CreatedAtEpoch,
5897 CleanedByWatermark,
5898 StreamJobStatus,
5899 CreateType,
5900 Description,
5901 IncomingSinks,
5902 InitializedAtClusterVersion,
5903 CreatedAtClusterVersion,
5904 RetentionSeconds,
5905 VersionColumnIndices,
5906 CdcTableId,
5907 MaybeVnodeCount,
5908 WebhookInfo,
5909 JobId,
5910 Engine,
5911 CleanWatermarkIndexInPk,
5912 Refreshable,
5913 VectorIndexInfo,
5914 CdcTableType,
5915 RefreshState,
5916 Version,
5917 AssociatedSourceId,
5918 }
5919 impl<'de> serde::Deserialize<'de> for GeneratedField {
5920 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5921 where
5922 D: serde::Deserializer<'de>,
5923 {
5924 struct GeneratedVisitor;
5925
5926 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5927 type Value = GeneratedField;
5928
5929 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5930 write!(formatter, "expected one of: {:?}", &FIELDS)
5931 }
5932
5933 #[allow(unused_variables)]
5934 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5935 where
5936 E: serde::de::Error,
5937 {
5938 match value {
5939 "id" => Ok(GeneratedField::Id),
5940 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
5941 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
5942 "name" => Ok(GeneratedField::Name),
5943 "columns" => Ok(GeneratedField::Columns),
5944 "pk" => Ok(GeneratedField::Pk),
5945 "tableType" | "table_type" => Ok(GeneratedField::TableType),
5946 "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
5947 "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
5948 "appendOnly" | "append_only" => Ok(GeneratedField::AppendOnly),
5949 "owner" => Ok(GeneratedField::Owner),
5950 "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5951 "vnodeColIndex" | "vnode_col_index" => Ok(GeneratedField::VnodeColIndex),
5952 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
5953 "valueIndices" | "value_indices" => Ok(GeneratedField::ValueIndices),
5954 "definition" => Ok(GeneratedField::Definition),
5955 "handlePkConflictBehavior" | "handle_pk_conflict_behavior" => Ok(GeneratedField::HandlePkConflictBehavior),
5956 "readPrefixLenHint" | "read_prefix_len_hint" => Ok(GeneratedField::ReadPrefixLenHint),
5957 "watermarkIndices" | "watermark_indices" => Ok(GeneratedField::WatermarkIndices),
5958 "distKeyInPk" | "dist_key_in_pk" => Ok(GeneratedField::DistKeyInPk),
5959 "dmlFragmentId" | "dml_fragment_id" => Ok(GeneratedField::DmlFragmentId),
5960 "cardinality" => Ok(GeneratedField::Cardinality),
5961 "initializedAtEpoch" | "initialized_at_epoch" => Ok(GeneratedField::InitializedAtEpoch),
5962 "createdAtEpoch" | "created_at_epoch" => Ok(GeneratedField::CreatedAtEpoch),
5963 "cleanedByWatermark" | "cleaned_by_watermark" => Ok(GeneratedField::CleanedByWatermark),
5964 "streamJobStatus" | "stream_job_status" => Ok(GeneratedField::StreamJobStatus),
5965 "createType" | "create_type" => Ok(GeneratedField::CreateType),
5966 "description" => Ok(GeneratedField::Description),
5967 "incomingSinks" | "incoming_sinks" => Ok(GeneratedField::IncomingSinks),
5968 "initializedAtClusterVersion" | "initialized_at_cluster_version" => Ok(GeneratedField::InitializedAtClusterVersion),
5969 "createdAtClusterVersion" | "created_at_cluster_version" => Ok(GeneratedField::CreatedAtClusterVersion),
5970 "retentionSeconds" | "retention_seconds" => Ok(GeneratedField::RetentionSeconds),
5971 "versionColumnIndices" | "version_column_indices" => Ok(GeneratedField::VersionColumnIndices),
5972 "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
5973 "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
5974 "webhookInfo" | "webhook_info" => Ok(GeneratedField::WebhookInfo),
5975 "jobId" | "job_id" => Ok(GeneratedField::JobId),
5976 "engine" => Ok(GeneratedField::Engine),
5977 "cleanWatermarkIndexInPk" | "clean_watermark_index_in_pk" => Ok(GeneratedField::CleanWatermarkIndexInPk),
5978 "refreshable" => Ok(GeneratedField::Refreshable),
5979 "vectorIndexInfo" | "vector_index_info" => Ok(GeneratedField::VectorIndexInfo),
5980 "cdcTableType" | "cdc_table_type" => Ok(GeneratedField::CdcTableType),
5981 "refreshState" | "refresh_state" => Ok(GeneratedField::RefreshState),
5982 "version" => Ok(GeneratedField::Version),
5983 "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
5984 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5985 }
5986 }
5987 }
5988 deserializer.deserialize_identifier(GeneratedVisitor)
5989 }
5990 }
5991 struct GeneratedVisitor;
5992 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5993 type Value = Table;
5994
5995 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5996 formatter.write_str("struct catalog.Table")
5997 }
5998
5999 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Table, V::Error>
6000 where
6001 V: serde::de::MapAccess<'de>,
6002 {
6003 let mut id__ = None;
6004 let mut schema_id__ = None;
6005 let mut database_id__ = None;
6006 let mut name__ = None;
6007 let mut columns__ = None;
6008 let mut pk__ = None;
6009 let mut table_type__ = None;
6010 let mut distribution_key__ = None;
6011 let mut stream_key__ = None;
6012 let mut append_only__ = None;
6013 let mut owner__ = None;
6014 let mut fragment_id__ = None;
6015 let mut vnode_col_index__ = None;
6016 let mut row_id_index__ = None;
6017 let mut value_indices__ = None;
6018 let mut definition__ = None;
6019 let mut handle_pk_conflict_behavior__ = None;
6020 let mut read_prefix_len_hint__ = None;
6021 let mut watermark_indices__ = None;
6022 let mut dist_key_in_pk__ = None;
6023 let mut dml_fragment_id__ = None;
6024 let mut cardinality__ = None;
6025 let mut initialized_at_epoch__ = None;
6026 let mut created_at_epoch__ = None;
6027 let mut cleaned_by_watermark__ = None;
6028 let mut stream_job_status__ = None;
6029 let mut create_type__ = None;
6030 let mut description__ = None;
6031 let mut incoming_sinks__ = None;
6032 let mut initialized_at_cluster_version__ = None;
6033 let mut created_at_cluster_version__ = None;
6034 let mut retention_seconds__ = None;
6035 let mut version_column_indices__ = None;
6036 let mut cdc_table_id__ = None;
6037 let mut maybe_vnode_count__ = None;
6038 let mut webhook_info__ = None;
6039 let mut job_id__ = None;
6040 let mut engine__ = None;
6041 let mut clean_watermark_index_in_pk__ = None;
6042 let mut refreshable__ = None;
6043 let mut vector_index_info__ = None;
6044 let mut cdc_table_type__ = None;
6045 let mut refresh_state__ = None;
6046 let mut version__ = None;
6047 let mut optional_associated_source_id__ = None;
6048 while let Some(k) = map_.next_key()? {
6049 match k {
6050 GeneratedField::Id => {
6051 if id__.is_some() {
6052 return Err(serde::de::Error::duplicate_field("id"));
6053 }
6054 id__ =
6055 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6056 ;
6057 }
6058 GeneratedField::SchemaId => {
6059 if schema_id__.is_some() {
6060 return Err(serde::de::Error::duplicate_field("schemaId"));
6061 }
6062 schema_id__ =
6063 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6064 ;
6065 }
6066 GeneratedField::DatabaseId => {
6067 if database_id__.is_some() {
6068 return Err(serde::de::Error::duplicate_field("databaseId"));
6069 }
6070 database_id__ =
6071 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6072 ;
6073 }
6074 GeneratedField::Name => {
6075 if name__.is_some() {
6076 return Err(serde::de::Error::duplicate_field("name"));
6077 }
6078 name__ = Some(map_.next_value()?);
6079 }
6080 GeneratedField::Columns => {
6081 if columns__.is_some() {
6082 return Err(serde::de::Error::duplicate_field("columns"));
6083 }
6084 columns__ = Some(map_.next_value()?);
6085 }
6086 GeneratedField::Pk => {
6087 if pk__.is_some() {
6088 return Err(serde::de::Error::duplicate_field("pk"));
6089 }
6090 pk__ = Some(map_.next_value()?);
6091 }
6092 GeneratedField::TableType => {
6093 if table_type__.is_some() {
6094 return Err(serde::de::Error::duplicate_field("tableType"));
6095 }
6096 table_type__ = Some(map_.next_value::<table::TableType>()? as i32);
6097 }
6098 GeneratedField::DistributionKey => {
6099 if distribution_key__.is_some() {
6100 return Err(serde::de::Error::duplicate_field("distributionKey"));
6101 }
6102 distribution_key__ =
6103 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6104 .into_iter().map(|x| x.0).collect())
6105 ;
6106 }
6107 GeneratedField::StreamKey => {
6108 if stream_key__.is_some() {
6109 return Err(serde::de::Error::duplicate_field("streamKey"));
6110 }
6111 stream_key__ =
6112 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6113 .into_iter().map(|x| x.0).collect())
6114 ;
6115 }
6116 GeneratedField::AppendOnly => {
6117 if append_only__.is_some() {
6118 return Err(serde::de::Error::duplicate_field("appendOnly"));
6119 }
6120 append_only__ = Some(map_.next_value()?);
6121 }
6122 GeneratedField::Owner => {
6123 if owner__.is_some() {
6124 return Err(serde::de::Error::duplicate_field("owner"));
6125 }
6126 owner__ =
6127 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6128 ;
6129 }
6130 GeneratedField::FragmentId => {
6131 if fragment_id__.is_some() {
6132 return Err(serde::de::Error::duplicate_field("fragmentId"));
6133 }
6134 fragment_id__ =
6135 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6136 ;
6137 }
6138 GeneratedField::VnodeColIndex => {
6139 if vnode_col_index__.is_some() {
6140 return Err(serde::de::Error::duplicate_field("vnodeColIndex"));
6141 }
6142 vnode_col_index__ =
6143 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6144 ;
6145 }
6146 GeneratedField::RowIdIndex => {
6147 if row_id_index__.is_some() {
6148 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
6149 }
6150 row_id_index__ =
6151 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6152 ;
6153 }
6154 GeneratedField::ValueIndices => {
6155 if value_indices__.is_some() {
6156 return Err(serde::de::Error::duplicate_field("valueIndices"));
6157 }
6158 value_indices__ =
6159 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6160 .into_iter().map(|x| x.0).collect())
6161 ;
6162 }
6163 GeneratedField::Definition => {
6164 if definition__.is_some() {
6165 return Err(serde::de::Error::duplicate_field("definition"));
6166 }
6167 definition__ = Some(map_.next_value()?);
6168 }
6169 GeneratedField::HandlePkConflictBehavior => {
6170 if handle_pk_conflict_behavior__.is_some() {
6171 return Err(serde::de::Error::duplicate_field("handlePkConflictBehavior"));
6172 }
6173 handle_pk_conflict_behavior__ = Some(map_.next_value::<HandleConflictBehavior>()? as i32);
6174 }
6175 GeneratedField::ReadPrefixLenHint => {
6176 if read_prefix_len_hint__.is_some() {
6177 return Err(serde::de::Error::duplicate_field("readPrefixLenHint"));
6178 }
6179 read_prefix_len_hint__ =
6180 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6181 ;
6182 }
6183 GeneratedField::WatermarkIndices => {
6184 if watermark_indices__.is_some() {
6185 return Err(serde::de::Error::duplicate_field("watermarkIndices"));
6186 }
6187 watermark_indices__ =
6188 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6189 .into_iter().map(|x| x.0).collect())
6190 ;
6191 }
6192 GeneratedField::DistKeyInPk => {
6193 if dist_key_in_pk__.is_some() {
6194 return Err(serde::de::Error::duplicate_field("distKeyInPk"));
6195 }
6196 dist_key_in_pk__ =
6197 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6198 .into_iter().map(|x| x.0).collect())
6199 ;
6200 }
6201 GeneratedField::DmlFragmentId => {
6202 if dml_fragment_id__.is_some() {
6203 return Err(serde::de::Error::duplicate_field("dmlFragmentId"));
6204 }
6205 dml_fragment_id__ =
6206 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6207 ;
6208 }
6209 GeneratedField::Cardinality => {
6210 if cardinality__.is_some() {
6211 return Err(serde::de::Error::duplicate_field("cardinality"));
6212 }
6213 cardinality__ = map_.next_value()?;
6214 }
6215 GeneratedField::InitializedAtEpoch => {
6216 if initialized_at_epoch__.is_some() {
6217 return Err(serde::de::Error::duplicate_field("initializedAtEpoch"));
6218 }
6219 initialized_at_epoch__ =
6220 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6221 ;
6222 }
6223 GeneratedField::CreatedAtEpoch => {
6224 if created_at_epoch__.is_some() {
6225 return Err(serde::de::Error::duplicate_field("createdAtEpoch"));
6226 }
6227 created_at_epoch__ =
6228 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6229 ;
6230 }
6231 GeneratedField::CleanedByWatermark => {
6232 if cleaned_by_watermark__.is_some() {
6233 return Err(serde::de::Error::duplicate_field("cleanedByWatermark"));
6234 }
6235 cleaned_by_watermark__ = Some(map_.next_value()?);
6236 }
6237 GeneratedField::StreamJobStatus => {
6238 if stream_job_status__.is_some() {
6239 return Err(serde::de::Error::duplicate_field("streamJobStatus"));
6240 }
6241 stream_job_status__ = Some(map_.next_value::<StreamJobStatus>()? as i32);
6242 }
6243 GeneratedField::CreateType => {
6244 if create_type__.is_some() {
6245 return Err(serde::de::Error::duplicate_field("createType"));
6246 }
6247 create_type__ = Some(map_.next_value::<CreateType>()? as i32);
6248 }
6249 GeneratedField::Description => {
6250 if description__.is_some() {
6251 return Err(serde::de::Error::duplicate_field("description"));
6252 }
6253 description__ = map_.next_value()?;
6254 }
6255 GeneratedField::IncomingSinks => {
6256 if incoming_sinks__.is_some() {
6257 return Err(serde::de::Error::duplicate_field("incomingSinks"));
6258 }
6259 incoming_sinks__ =
6260 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6261 .into_iter().map(|x| x.0).collect())
6262 ;
6263 }
6264 GeneratedField::InitializedAtClusterVersion => {
6265 if initialized_at_cluster_version__.is_some() {
6266 return Err(serde::de::Error::duplicate_field("initializedAtClusterVersion"));
6267 }
6268 initialized_at_cluster_version__ = map_.next_value()?;
6269 }
6270 GeneratedField::CreatedAtClusterVersion => {
6271 if created_at_cluster_version__.is_some() {
6272 return Err(serde::de::Error::duplicate_field("createdAtClusterVersion"));
6273 }
6274 created_at_cluster_version__ = map_.next_value()?;
6275 }
6276 GeneratedField::RetentionSeconds => {
6277 if retention_seconds__.is_some() {
6278 return Err(serde::de::Error::duplicate_field("retentionSeconds"));
6279 }
6280 retention_seconds__ =
6281 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6282 ;
6283 }
6284 GeneratedField::VersionColumnIndices => {
6285 if version_column_indices__.is_some() {
6286 return Err(serde::de::Error::duplicate_field("versionColumnIndices"));
6287 }
6288 version_column_indices__ =
6289 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6290 .into_iter().map(|x| x.0).collect())
6291 ;
6292 }
6293 GeneratedField::CdcTableId => {
6294 if cdc_table_id__.is_some() {
6295 return Err(serde::de::Error::duplicate_field("cdcTableId"));
6296 }
6297 cdc_table_id__ = map_.next_value()?;
6298 }
6299 GeneratedField::MaybeVnodeCount => {
6300 if maybe_vnode_count__.is_some() {
6301 return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
6302 }
6303 maybe_vnode_count__ =
6304 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6305 ;
6306 }
6307 GeneratedField::WebhookInfo => {
6308 if webhook_info__.is_some() {
6309 return Err(serde::de::Error::duplicate_field("webhookInfo"));
6310 }
6311 webhook_info__ = map_.next_value()?;
6312 }
6313 GeneratedField::JobId => {
6314 if job_id__.is_some() {
6315 return Err(serde::de::Error::duplicate_field("jobId"));
6316 }
6317 job_id__ =
6318 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6319 ;
6320 }
6321 GeneratedField::Engine => {
6322 if engine__.is_some() {
6323 return Err(serde::de::Error::duplicate_field("engine"));
6324 }
6325 engine__ = map_.next_value::<::std::option::Option<table::Engine>>()?.map(|x| x as i32);
6326 }
6327 GeneratedField::CleanWatermarkIndexInPk => {
6328 if clean_watermark_index_in_pk__.is_some() {
6329 return Err(serde::de::Error::duplicate_field("cleanWatermarkIndexInPk"));
6330 }
6331 clean_watermark_index_in_pk__ =
6332 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6333 ;
6334 }
6335 GeneratedField::Refreshable => {
6336 if refreshable__.is_some() {
6337 return Err(serde::de::Error::duplicate_field("refreshable"));
6338 }
6339 refreshable__ = Some(map_.next_value()?);
6340 }
6341 GeneratedField::VectorIndexInfo => {
6342 if vector_index_info__.is_some() {
6343 return Err(serde::de::Error::duplicate_field("vectorIndexInfo"));
6344 }
6345 vector_index_info__ = map_.next_value()?;
6346 }
6347 GeneratedField::CdcTableType => {
6348 if cdc_table_type__.is_some() {
6349 return Err(serde::de::Error::duplicate_field("cdcTableType"));
6350 }
6351 cdc_table_type__ = map_.next_value::<::std::option::Option<table::CdcTableType>>()?.map(|x| x as i32);
6352 }
6353 GeneratedField::RefreshState => {
6354 if refresh_state__.is_some() {
6355 return Err(serde::de::Error::duplicate_field("refreshState"));
6356 }
6357 refresh_state__ = map_.next_value::<::std::option::Option<RefreshState>>()?.map(|x| x as i32);
6358 }
6359 GeneratedField::Version => {
6360 if version__.is_some() {
6361 return Err(serde::de::Error::duplicate_field("version"));
6362 }
6363 version__ = map_.next_value()?;
6364 }
6365 GeneratedField::AssociatedSourceId => {
6366 if optional_associated_source_id__.is_some() {
6367 return Err(serde::de::Error::duplicate_field("associatedSourceId"));
6368 }
6369 optional_associated_source_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| table::OptionalAssociatedSourceId::AssociatedSourceId(x.0));
6370 }
6371 }
6372 }
6373 Ok(Table {
6374 id: id__.unwrap_or_default(),
6375 schema_id: schema_id__.unwrap_or_default(),
6376 database_id: database_id__.unwrap_or_default(),
6377 name: name__.unwrap_or_default(),
6378 columns: columns__.unwrap_or_default(),
6379 pk: pk__.unwrap_or_default(),
6380 table_type: table_type__.unwrap_or_default(),
6381 distribution_key: distribution_key__.unwrap_or_default(),
6382 stream_key: stream_key__.unwrap_or_default(),
6383 append_only: append_only__.unwrap_or_default(),
6384 owner: owner__.unwrap_or_default(),
6385 fragment_id: fragment_id__.unwrap_or_default(),
6386 vnode_col_index: vnode_col_index__,
6387 row_id_index: row_id_index__,
6388 value_indices: value_indices__.unwrap_or_default(),
6389 definition: definition__.unwrap_or_default(),
6390 handle_pk_conflict_behavior: handle_pk_conflict_behavior__.unwrap_or_default(),
6391 read_prefix_len_hint: read_prefix_len_hint__.unwrap_or_default(),
6392 watermark_indices: watermark_indices__.unwrap_or_default(),
6393 dist_key_in_pk: dist_key_in_pk__.unwrap_or_default(),
6394 dml_fragment_id: dml_fragment_id__,
6395 cardinality: cardinality__,
6396 initialized_at_epoch: initialized_at_epoch__,
6397 created_at_epoch: created_at_epoch__,
6398 cleaned_by_watermark: cleaned_by_watermark__.unwrap_or_default(),
6399 stream_job_status: stream_job_status__.unwrap_or_default(),
6400 create_type: create_type__.unwrap_or_default(),
6401 description: description__,
6402 incoming_sinks: incoming_sinks__.unwrap_or_default(),
6403 initialized_at_cluster_version: initialized_at_cluster_version__,
6404 created_at_cluster_version: created_at_cluster_version__,
6405 retention_seconds: retention_seconds__,
6406 version_column_indices: version_column_indices__.unwrap_or_default(),
6407 cdc_table_id: cdc_table_id__,
6408 maybe_vnode_count: maybe_vnode_count__,
6409 webhook_info: webhook_info__,
6410 job_id: job_id__,
6411 engine: engine__,
6412 clean_watermark_index_in_pk: clean_watermark_index_in_pk__,
6413 refreshable: refreshable__.unwrap_or_default(),
6414 vector_index_info: vector_index_info__,
6415 cdc_table_type: cdc_table_type__,
6416 refresh_state: refresh_state__,
6417 version: version__,
6418 optional_associated_source_id: optional_associated_source_id__,
6419 })
6420 }
6421 }
6422 deserializer.deserialize_struct("catalog.Table", FIELDS, GeneratedVisitor)
6423 }
6424}
6425impl serde::Serialize for table::CdcTableType {
6426 #[allow(deprecated)]
6427 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6428 where
6429 S: serde::Serializer,
6430 {
6431 let variant = match self {
6432 Self::Unspecified => "CDC_TABLE_TYPE_UNSPECIFIED",
6433 Self::Postgres => "CDC_TABLE_TYPE_POSTGRES",
6434 Self::Mysql => "CDC_TABLE_TYPE_MYSQL",
6435 Self::Sqlserver => "CDC_TABLE_TYPE_SQLSERVER",
6436 Self::Mongo => "CDC_TABLE_TYPE_MONGO",
6437 Self::Citus => "CDC_TABLE_TYPE_CITUS",
6438 };
6439 serializer.serialize_str(variant)
6440 }
6441}
6442impl<'de> serde::Deserialize<'de> for table::CdcTableType {
6443 #[allow(deprecated)]
6444 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6445 where
6446 D: serde::Deserializer<'de>,
6447 {
6448 const FIELDS: &[&str] = &[
6449 "CDC_TABLE_TYPE_UNSPECIFIED",
6450 "CDC_TABLE_TYPE_POSTGRES",
6451 "CDC_TABLE_TYPE_MYSQL",
6452 "CDC_TABLE_TYPE_SQLSERVER",
6453 "CDC_TABLE_TYPE_MONGO",
6454 "CDC_TABLE_TYPE_CITUS",
6455 ];
6456
6457 struct GeneratedVisitor;
6458
6459 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6460 type Value = table::CdcTableType;
6461
6462 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6463 write!(formatter, "expected one of: {:?}", &FIELDS)
6464 }
6465
6466 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6467 where
6468 E: serde::de::Error,
6469 {
6470 i32::try_from(v)
6471 .ok()
6472 .and_then(|x| x.try_into().ok())
6473 .ok_or_else(|| {
6474 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6475 })
6476 }
6477
6478 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6479 where
6480 E: serde::de::Error,
6481 {
6482 i32::try_from(v)
6483 .ok()
6484 .and_then(|x| x.try_into().ok())
6485 .ok_or_else(|| {
6486 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6487 })
6488 }
6489
6490 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6491 where
6492 E: serde::de::Error,
6493 {
6494 match value {
6495 "CDC_TABLE_TYPE_UNSPECIFIED" => Ok(table::CdcTableType::Unspecified),
6496 "CDC_TABLE_TYPE_POSTGRES" => Ok(table::CdcTableType::Postgres),
6497 "CDC_TABLE_TYPE_MYSQL" => Ok(table::CdcTableType::Mysql),
6498 "CDC_TABLE_TYPE_SQLSERVER" => Ok(table::CdcTableType::Sqlserver),
6499 "CDC_TABLE_TYPE_MONGO" => Ok(table::CdcTableType::Mongo),
6500 "CDC_TABLE_TYPE_CITUS" => Ok(table::CdcTableType::Citus),
6501 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6502 }
6503 }
6504 }
6505 deserializer.deserialize_any(GeneratedVisitor)
6506 }
6507}
6508impl serde::Serialize for table::Engine {
6509 #[allow(deprecated)]
6510 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6511 where
6512 S: serde::Serializer,
6513 {
6514 let variant = match self {
6515 Self::Unspecified => "ENGINE_UNSPECIFIED",
6516 Self::Hummock => "HUMMOCK",
6517 Self::Iceberg => "ICEBERG",
6518 };
6519 serializer.serialize_str(variant)
6520 }
6521}
6522impl<'de> serde::Deserialize<'de> for table::Engine {
6523 #[allow(deprecated)]
6524 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6525 where
6526 D: serde::Deserializer<'de>,
6527 {
6528 const FIELDS: &[&str] = &[
6529 "ENGINE_UNSPECIFIED",
6530 "HUMMOCK",
6531 "ICEBERG",
6532 ];
6533
6534 struct GeneratedVisitor;
6535
6536 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6537 type Value = table::Engine;
6538
6539 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6540 write!(formatter, "expected one of: {:?}", &FIELDS)
6541 }
6542
6543 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6544 where
6545 E: serde::de::Error,
6546 {
6547 i32::try_from(v)
6548 .ok()
6549 .and_then(|x| x.try_into().ok())
6550 .ok_or_else(|| {
6551 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6552 })
6553 }
6554
6555 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6556 where
6557 E: serde::de::Error,
6558 {
6559 i32::try_from(v)
6560 .ok()
6561 .and_then(|x| x.try_into().ok())
6562 .ok_or_else(|| {
6563 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6564 })
6565 }
6566
6567 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6568 where
6569 E: serde::de::Error,
6570 {
6571 match value {
6572 "ENGINE_UNSPECIFIED" => Ok(table::Engine::Unspecified),
6573 "HUMMOCK" => Ok(table::Engine::Hummock),
6574 "ICEBERG" => Ok(table::Engine::Iceberg),
6575 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6576 }
6577 }
6578 }
6579 deserializer.deserialize_any(GeneratedVisitor)
6580 }
6581}
6582impl serde::Serialize for table::TableType {
6583 #[allow(deprecated)]
6584 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6585 where
6586 S: serde::Serializer,
6587 {
6588 let variant = match self {
6589 Self::Unspecified => "UNSPECIFIED",
6590 Self::Table => "TABLE",
6591 Self::MaterializedView => "MATERIALIZED_VIEW",
6592 Self::Index => "INDEX",
6593 Self::Internal => "INTERNAL",
6594 Self::VectorIndex => "VECTOR_INDEX",
6595 };
6596 serializer.serialize_str(variant)
6597 }
6598}
6599impl<'de> serde::Deserialize<'de> for table::TableType {
6600 #[allow(deprecated)]
6601 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6602 where
6603 D: serde::Deserializer<'de>,
6604 {
6605 const FIELDS: &[&str] = &[
6606 "UNSPECIFIED",
6607 "TABLE",
6608 "MATERIALIZED_VIEW",
6609 "INDEX",
6610 "INTERNAL",
6611 "VECTOR_INDEX",
6612 ];
6613
6614 struct GeneratedVisitor;
6615
6616 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6617 type Value = table::TableType;
6618
6619 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6620 write!(formatter, "expected one of: {:?}", &FIELDS)
6621 }
6622
6623 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6624 where
6625 E: serde::de::Error,
6626 {
6627 i32::try_from(v)
6628 .ok()
6629 .and_then(|x| x.try_into().ok())
6630 .ok_or_else(|| {
6631 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6632 })
6633 }
6634
6635 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6636 where
6637 E: serde::de::Error,
6638 {
6639 i32::try_from(v)
6640 .ok()
6641 .and_then(|x| x.try_into().ok())
6642 .ok_or_else(|| {
6643 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6644 })
6645 }
6646
6647 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6648 where
6649 E: serde::de::Error,
6650 {
6651 match value {
6652 "UNSPECIFIED" => Ok(table::TableType::Unspecified),
6653 "TABLE" => Ok(table::TableType::Table),
6654 "MATERIALIZED_VIEW" => Ok(table::TableType::MaterializedView),
6655 "INDEX" => Ok(table::TableType::Index),
6656 "INTERNAL" => Ok(table::TableType::Internal),
6657 "VECTOR_INDEX" => Ok(table::TableType::VectorIndex),
6658 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6659 }
6660 }
6661 }
6662 deserializer.deserialize_any(GeneratedVisitor)
6663 }
6664}
6665impl serde::Serialize for table::TableVersion {
6666 #[allow(deprecated)]
6667 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6668 where
6669 S: serde::Serializer,
6670 {
6671 use serde::ser::SerializeStruct;
6672 let mut len = 0;
6673 if self.version != 0 {
6674 len += 1;
6675 }
6676 if self.next_column_id != 0 {
6677 len += 1;
6678 }
6679 let mut struct_ser = serializer.serialize_struct("catalog.Table.TableVersion", len)?;
6680 if self.version != 0 {
6681 #[allow(clippy::needless_borrow)]
6682 #[allow(clippy::needless_borrows_for_generic_args)]
6683 struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
6684 }
6685 if self.next_column_id != 0 {
6686 struct_ser.serialize_field("nextColumnId", &self.next_column_id)?;
6687 }
6688 struct_ser.end()
6689 }
6690}
6691impl<'de> serde::Deserialize<'de> for table::TableVersion {
6692 #[allow(deprecated)]
6693 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6694 where
6695 D: serde::Deserializer<'de>,
6696 {
6697 const FIELDS: &[&str] = &[
6698 "version",
6699 "next_column_id",
6700 "nextColumnId",
6701 ];
6702
6703 #[allow(clippy::enum_variant_names)]
6704 enum GeneratedField {
6705 Version,
6706 NextColumnId,
6707 }
6708 impl<'de> serde::Deserialize<'de> for GeneratedField {
6709 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6710 where
6711 D: serde::Deserializer<'de>,
6712 {
6713 struct GeneratedVisitor;
6714
6715 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6716 type Value = GeneratedField;
6717
6718 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6719 write!(formatter, "expected one of: {:?}", &FIELDS)
6720 }
6721
6722 #[allow(unused_variables)]
6723 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6724 where
6725 E: serde::de::Error,
6726 {
6727 match value {
6728 "version" => Ok(GeneratedField::Version),
6729 "nextColumnId" | "next_column_id" => Ok(GeneratedField::NextColumnId),
6730 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6731 }
6732 }
6733 }
6734 deserializer.deserialize_identifier(GeneratedVisitor)
6735 }
6736 }
6737 struct GeneratedVisitor;
6738 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6739 type Value = table::TableVersion;
6740
6741 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6742 formatter.write_str("struct catalog.Table.TableVersion")
6743 }
6744
6745 fn visit_map<V>(self, mut map_: V) -> std::result::Result<table::TableVersion, V::Error>
6746 where
6747 V: serde::de::MapAccess<'de>,
6748 {
6749 let mut version__ = None;
6750 let mut next_column_id__ = None;
6751 while let Some(k) = map_.next_key()? {
6752 match k {
6753 GeneratedField::Version => {
6754 if version__.is_some() {
6755 return Err(serde::de::Error::duplicate_field("version"));
6756 }
6757 version__ =
6758 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6759 ;
6760 }
6761 GeneratedField::NextColumnId => {
6762 if next_column_id__.is_some() {
6763 return Err(serde::de::Error::duplicate_field("nextColumnId"));
6764 }
6765 next_column_id__ =
6766 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6767 ;
6768 }
6769 }
6770 }
6771 Ok(table::TableVersion {
6772 version: version__.unwrap_or_default(),
6773 next_column_id: next_column_id__.unwrap_or_default(),
6774 })
6775 }
6776 }
6777 deserializer.deserialize_struct("catalog.Table.TableVersion", FIELDS, GeneratedVisitor)
6778 }
6779}
6780impl serde::Serialize for VectorIndexInfo {
6781 #[allow(deprecated)]
6782 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6783 where
6784 S: serde::Serializer,
6785 {
6786 use serde::ser::SerializeStruct;
6787 let mut len = 0;
6788 if self.dimension != 0 {
6789 len += 1;
6790 }
6791 if self.distance_type != 0 {
6792 len += 1;
6793 }
6794 if self.config.is_some() {
6795 len += 1;
6796 }
6797 let mut struct_ser = serializer.serialize_struct("catalog.VectorIndexInfo", len)?;
6798 if self.dimension != 0 {
6799 struct_ser.serialize_field("dimension", &self.dimension)?;
6800 }
6801 if self.distance_type != 0 {
6802 let v = super::common::DistanceType::try_from(self.distance_type)
6803 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distance_type)))?;
6804 struct_ser.serialize_field("distanceType", &v)?;
6805 }
6806 if let Some(v) = self.config.as_ref() {
6807 match v {
6808 vector_index_info::Config::Flat(v) => {
6809 struct_ser.serialize_field("flat", v)?;
6810 }
6811 vector_index_info::Config::HnswFlat(v) => {
6812 struct_ser.serialize_field("hnswFlat", v)?;
6813 }
6814 }
6815 }
6816 struct_ser.end()
6817 }
6818}
6819impl<'de> serde::Deserialize<'de> for VectorIndexInfo {
6820 #[allow(deprecated)]
6821 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6822 where
6823 D: serde::Deserializer<'de>,
6824 {
6825 const FIELDS: &[&str] = &[
6826 "dimension",
6827 "distance_type",
6828 "distanceType",
6829 "flat",
6830 "hnsw_flat",
6831 "hnswFlat",
6832 ];
6833
6834 #[allow(clippy::enum_variant_names)]
6835 enum GeneratedField {
6836 Dimension,
6837 DistanceType,
6838 Flat,
6839 HnswFlat,
6840 }
6841 impl<'de> serde::Deserialize<'de> for GeneratedField {
6842 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6843 where
6844 D: serde::Deserializer<'de>,
6845 {
6846 struct GeneratedVisitor;
6847
6848 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6849 type Value = GeneratedField;
6850
6851 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6852 write!(formatter, "expected one of: {:?}", &FIELDS)
6853 }
6854
6855 #[allow(unused_variables)]
6856 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6857 where
6858 E: serde::de::Error,
6859 {
6860 match value {
6861 "dimension" => Ok(GeneratedField::Dimension),
6862 "distanceType" | "distance_type" => Ok(GeneratedField::DistanceType),
6863 "flat" => Ok(GeneratedField::Flat),
6864 "hnswFlat" | "hnsw_flat" => Ok(GeneratedField::HnswFlat),
6865 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6866 }
6867 }
6868 }
6869 deserializer.deserialize_identifier(GeneratedVisitor)
6870 }
6871 }
6872 struct GeneratedVisitor;
6873 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6874 type Value = VectorIndexInfo;
6875
6876 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6877 formatter.write_str("struct catalog.VectorIndexInfo")
6878 }
6879
6880 fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexInfo, V::Error>
6881 where
6882 V: serde::de::MapAccess<'de>,
6883 {
6884 let mut dimension__ = None;
6885 let mut distance_type__ = None;
6886 let mut config__ = None;
6887 while let Some(k) = map_.next_key()? {
6888 match k {
6889 GeneratedField::Dimension => {
6890 if dimension__.is_some() {
6891 return Err(serde::de::Error::duplicate_field("dimension"));
6892 }
6893 dimension__ =
6894 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6895 ;
6896 }
6897 GeneratedField::DistanceType => {
6898 if distance_type__.is_some() {
6899 return Err(serde::de::Error::duplicate_field("distanceType"));
6900 }
6901 distance_type__ = Some(map_.next_value::<super::common::DistanceType>()? as i32);
6902 }
6903 GeneratedField::Flat => {
6904 if config__.is_some() {
6905 return Err(serde::de::Error::duplicate_field("flat"));
6906 }
6907 config__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_info::Config::Flat)
6908;
6909 }
6910 GeneratedField::HnswFlat => {
6911 if config__.is_some() {
6912 return Err(serde::de::Error::duplicate_field("hnswFlat"));
6913 }
6914 config__ = map_.next_value::<::std::option::Option<_>>()?.map(vector_index_info::Config::HnswFlat)
6915;
6916 }
6917 }
6918 }
6919 Ok(VectorIndexInfo {
6920 dimension: dimension__.unwrap_or_default(),
6921 distance_type: distance_type__.unwrap_or_default(),
6922 config: config__,
6923 })
6924 }
6925 }
6926 deserializer.deserialize_struct("catalog.VectorIndexInfo", FIELDS, GeneratedVisitor)
6927 }
6928}
6929impl serde::Serialize for View {
6930 #[allow(deprecated)]
6931 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6932 where
6933 S: serde::Serializer,
6934 {
6935 use serde::ser::SerializeStruct;
6936 let mut len = 0;
6937 if self.id != 0 {
6938 len += 1;
6939 }
6940 if self.schema_id != 0 {
6941 len += 1;
6942 }
6943 if self.database_id != 0 {
6944 len += 1;
6945 }
6946 if !self.name.is_empty() {
6947 len += 1;
6948 }
6949 if self.owner != 0 {
6950 len += 1;
6951 }
6952 if !self.properties.is_empty() {
6953 len += 1;
6954 }
6955 if !self.sql.is_empty() {
6956 len += 1;
6957 }
6958 if !self.columns.is_empty() {
6959 len += 1;
6960 }
6961 let mut struct_ser = serializer.serialize_struct("catalog.View", len)?;
6962 if self.id != 0 {
6963 struct_ser.serialize_field("id", &self.id)?;
6964 }
6965 if self.schema_id != 0 {
6966 struct_ser.serialize_field("schemaId", &self.schema_id)?;
6967 }
6968 if self.database_id != 0 {
6969 struct_ser.serialize_field("databaseId", &self.database_id)?;
6970 }
6971 if !self.name.is_empty() {
6972 struct_ser.serialize_field("name", &self.name)?;
6973 }
6974 if self.owner != 0 {
6975 struct_ser.serialize_field("owner", &self.owner)?;
6976 }
6977 if !self.properties.is_empty() {
6978 struct_ser.serialize_field("properties", &self.properties)?;
6979 }
6980 if !self.sql.is_empty() {
6981 struct_ser.serialize_field("sql", &self.sql)?;
6982 }
6983 if !self.columns.is_empty() {
6984 struct_ser.serialize_field("columns", &self.columns)?;
6985 }
6986 struct_ser.end()
6987 }
6988}
6989impl<'de> serde::Deserialize<'de> for View {
6990 #[allow(deprecated)]
6991 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6992 where
6993 D: serde::Deserializer<'de>,
6994 {
6995 const FIELDS: &[&str] = &[
6996 "id",
6997 "schema_id",
6998 "schemaId",
6999 "database_id",
7000 "databaseId",
7001 "name",
7002 "owner",
7003 "properties",
7004 "sql",
7005 "columns",
7006 ];
7007
7008 #[allow(clippy::enum_variant_names)]
7009 enum GeneratedField {
7010 Id,
7011 SchemaId,
7012 DatabaseId,
7013 Name,
7014 Owner,
7015 Properties,
7016 Sql,
7017 Columns,
7018 }
7019 impl<'de> serde::Deserialize<'de> for GeneratedField {
7020 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7021 where
7022 D: serde::Deserializer<'de>,
7023 {
7024 struct GeneratedVisitor;
7025
7026 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7027 type Value = GeneratedField;
7028
7029 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7030 write!(formatter, "expected one of: {:?}", &FIELDS)
7031 }
7032
7033 #[allow(unused_variables)]
7034 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7035 where
7036 E: serde::de::Error,
7037 {
7038 match value {
7039 "id" => Ok(GeneratedField::Id),
7040 "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
7041 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
7042 "name" => Ok(GeneratedField::Name),
7043 "owner" => Ok(GeneratedField::Owner),
7044 "properties" => Ok(GeneratedField::Properties),
7045 "sql" => Ok(GeneratedField::Sql),
7046 "columns" => Ok(GeneratedField::Columns),
7047 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7048 }
7049 }
7050 }
7051 deserializer.deserialize_identifier(GeneratedVisitor)
7052 }
7053 }
7054 struct GeneratedVisitor;
7055 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7056 type Value = View;
7057
7058 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7059 formatter.write_str("struct catalog.View")
7060 }
7061
7062 fn visit_map<V>(self, mut map_: V) -> std::result::Result<View, V::Error>
7063 where
7064 V: serde::de::MapAccess<'de>,
7065 {
7066 let mut id__ = None;
7067 let mut schema_id__ = None;
7068 let mut database_id__ = None;
7069 let mut name__ = None;
7070 let mut owner__ = None;
7071 let mut properties__ = None;
7072 let mut sql__ = None;
7073 let mut columns__ = None;
7074 while let Some(k) = map_.next_key()? {
7075 match k {
7076 GeneratedField::Id => {
7077 if id__.is_some() {
7078 return Err(serde::de::Error::duplicate_field("id"));
7079 }
7080 id__ =
7081 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7082 ;
7083 }
7084 GeneratedField::SchemaId => {
7085 if schema_id__.is_some() {
7086 return Err(serde::de::Error::duplicate_field("schemaId"));
7087 }
7088 schema_id__ =
7089 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7090 ;
7091 }
7092 GeneratedField::DatabaseId => {
7093 if database_id__.is_some() {
7094 return Err(serde::de::Error::duplicate_field("databaseId"));
7095 }
7096 database_id__ =
7097 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7098 ;
7099 }
7100 GeneratedField::Name => {
7101 if name__.is_some() {
7102 return Err(serde::de::Error::duplicate_field("name"));
7103 }
7104 name__ = Some(map_.next_value()?);
7105 }
7106 GeneratedField::Owner => {
7107 if owner__.is_some() {
7108 return Err(serde::de::Error::duplicate_field("owner"));
7109 }
7110 owner__ =
7111 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7112 ;
7113 }
7114 GeneratedField::Properties => {
7115 if properties__.is_some() {
7116 return Err(serde::de::Error::duplicate_field("properties"));
7117 }
7118 properties__ = Some(
7119 map_.next_value::<std::collections::BTreeMap<_, _>>()?
7120 );
7121 }
7122 GeneratedField::Sql => {
7123 if sql__.is_some() {
7124 return Err(serde::de::Error::duplicate_field("sql"));
7125 }
7126 sql__ = Some(map_.next_value()?);
7127 }
7128 GeneratedField::Columns => {
7129 if columns__.is_some() {
7130 return Err(serde::de::Error::duplicate_field("columns"));
7131 }
7132 columns__ = Some(map_.next_value()?);
7133 }
7134 }
7135 }
7136 Ok(View {
7137 id: id__.unwrap_or_default(),
7138 schema_id: schema_id__.unwrap_or_default(),
7139 database_id: database_id__.unwrap_or_default(),
7140 name: name__.unwrap_or_default(),
7141 owner: owner__.unwrap_or_default(),
7142 properties: properties__.unwrap_or_default(),
7143 sql: sql__.unwrap_or_default(),
7144 columns: columns__.unwrap_or_default(),
7145 })
7146 }
7147 }
7148 deserializer.deserialize_struct("catalog.View", FIELDS, GeneratedVisitor)
7149 }
7150}
7151impl serde::Serialize for WatermarkDesc {
7152 #[allow(deprecated)]
7153 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7154 where
7155 S: serde::Serializer,
7156 {
7157 use serde::ser::SerializeStruct;
7158 let mut len = 0;
7159 if self.watermark_idx != 0 {
7160 len += 1;
7161 }
7162 if self.expr.is_some() {
7163 len += 1;
7164 }
7165 let mut struct_ser = serializer.serialize_struct("catalog.WatermarkDesc", len)?;
7166 if self.watermark_idx != 0 {
7167 struct_ser.serialize_field("watermarkIdx", &self.watermark_idx)?;
7168 }
7169 if let Some(v) = self.expr.as_ref() {
7170 struct_ser.serialize_field("expr", v)?;
7171 }
7172 struct_ser.end()
7173 }
7174}
7175impl<'de> serde::Deserialize<'de> for WatermarkDesc {
7176 #[allow(deprecated)]
7177 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7178 where
7179 D: serde::Deserializer<'de>,
7180 {
7181 const FIELDS: &[&str] = &[
7182 "watermark_idx",
7183 "watermarkIdx",
7184 "expr",
7185 ];
7186
7187 #[allow(clippy::enum_variant_names)]
7188 enum GeneratedField {
7189 WatermarkIdx,
7190 Expr,
7191 }
7192 impl<'de> serde::Deserialize<'de> for GeneratedField {
7193 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7194 where
7195 D: serde::Deserializer<'de>,
7196 {
7197 struct GeneratedVisitor;
7198
7199 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7200 type Value = GeneratedField;
7201
7202 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7203 write!(formatter, "expected one of: {:?}", &FIELDS)
7204 }
7205
7206 #[allow(unused_variables)]
7207 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7208 where
7209 E: serde::de::Error,
7210 {
7211 match value {
7212 "watermarkIdx" | "watermark_idx" => Ok(GeneratedField::WatermarkIdx),
7213 "expr" => Ok(GeneratedField::Expr),
7214 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7215 }
7216 }
7217 }
7218 deserializer.deserialize_identifier(GeneratedVisitor)
7219 }
7220 }
7221 struct GeneratedVisitor;
7222 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7223 type Value = WatermarkDesc;
7224
7225 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7226 formatter.write_str("struct catalog.WatermarkDesc")
7227 }
7228
7229 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkDesc, V::Error>
7230 where
7231 V: serde::de::MapAccess<'de>,
7232 {
7233 let mut watermark_idx__ = None;
7234 let mut expr__ = None;
7235 while let Some(k) = map_.next_key()? {
7236 match k {
7237 GeneratedField::WatermarkIdx => {
7238 if watermark_idx__.is_some() {
7239 return Err(serde::de::Error::duplicate_field("watermarkIdx"));
7240 }
7241 watermark_idx__ =
7242 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7243 ;
7244 }
7245 GeneratedField::Expr => {
7246 if expr__.is_some() {
7247 return Err(serde::de::Error::duplicate_field("expr"));
7248 }
7249 expr__ = map_.next_value()?;
7250 }
7251 }
7252 }
7253 Ok(WatermarkDesc {
7254 watermark_idx: watermark_idx__.unwrap_or_default(),
7255 expr: expr__,
7256 })
7257 }
7258 }
7259 deserializer.deserialize_struct("catalog.WatermarkDesc", FIELDS, GeneratedVisitor)
7260 }
7261}
7262impl serde::Serialize for WebhookSourceInfo {
7263 #[allow(deprecated)]
7264 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7265 where
7266 S: serde::Serializer,
7267 {
7268 use serde::ser::SerializeStruct;
7269 let mut len = 0;
7270 if self.secret_ref.is_some() {
7271 len += 1;
7272 }
7273 if self.signature_expr.is_some() {
7274 len += 1;
7275 }
7276 if self.wait_for_persistence {
7277 len += 1;
7278 }
7279 if self.is_batched {
7280 len += 1;
7281 }
7282 let mut struct_ser = serializer.serialize_struct("catalog.WebhookSourceInfo", len)?;
7283 if let Some(v) = self.secret_ref.as_ref() {
7284 struct_ser.serialize_field("secretRef", v)?;
7285 }
7286 if let Some(v) = self.signature_expr.as_ref() {
7287 struct_ser.serialize_field("signatureExpr", v)?;
7288 }
7289 if self.wait_for_persistence {
7290 struct_ser.serialize_field("waitForPersistence", &self.wait_for_persistence)?;
7291 }
7292 if self.is_batched {
7293 struct_ser.serialize_field("isBatched", &self.is_batched)?;
7294 }
7295 struct_ser.end()
7296 }
7297}
7298impl<'de> serde::Deserialize<'de> for WebhookSourceInfo {
7299 #[allow(deprecated)]
7300 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7301 where
7302 D: serde::Deserializer<'de>,
7303 {
7304 const FIELDS: &[&str] = &[
7305 "secret_ref",
7306 "secretRef",
7307 "signature_expr",
7308 "signatureExpr",
7309 "wait_for_persistence",
7310 "waitForPersistence",
7311 "is_batched",
7312 "isBatched",
7313 ];
7314
7315 #[allow(clippy::enum_variant_names)]
7316 enum GeneratedField {
7317 SecretRef,
7318 SignatureExpr,
7319 WaitForPersistence,
7320 IsBatched,
7321 }
7322 impl<'de> serde::Deserialize<'de> for GeneratedField {
7323 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7324 where
7325 D: serde::Deserializer<'de>,
7326 {
7327 struct GeneratedVisitor;
7328
7329 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7330 type Value = GeneratedField;
7331
7332 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7333 write!(formatter, "expected one of: {:?}", &FIELDS)
7334 }
7335
7336 #[allow(unused_variables)]
7337 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7338 where
7339 E: serde::de::Error,
7340 {
7341 match value {
7342 "secretRef" | "secret_ref" => Ok(GeneratedField::SecretRef),
7343 "signatureExpr" | "signature_expr" => Ok(GeneratedField::SignatureExpr),
7344 "waitForPersistence" | "wait_for_persistence" => Ok(GeneratedField::WaitForPersistence),
7345 "isBatched" | "is_batched" => Ok(GeneratedField::IsBatched),
7346 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7347 }
7348 }
7349 }
7350 deserializer.deserialize_identifier(GeneratedVisitor)
7351 }
7352 }
7353 struct GeneratedVisitor;
7354 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7355 type Value = WebhookSourceInfo;
7356
7357 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7358 formatter.write_str("struct catalog.WebhookSourceInfo")
7359 }
7360
7361 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WebhookSourceInfo, V::Error>
7362 where
7363 V: serde::de::MapAccess<'de>,
7364 {
7365 let mut secret_ref__ = None;
7366 let mut signature_expr__ = None;
7367 let mut wait_for_persistence__ = None;
7368 let mut is_batched__ = None;
7369 while let Some(k) = map_.next_key()? {
7370 match k {
7371 GeneratedField::SecretRef => {
7372 if secret_ref__.is_some() {
7373 return Err(serde::de::Error::duplicate_field("secretRef"));
7374 }
7375 secret_ref__ = map_.next_value()?;
7376 }
7377 GeneratedField::SignatureExpr => {
7378 if signature_expr__.is_some() {
7379 return Err(serde::de::Error::duplicate_field("signatureExpr"));
7380 }
7381 signature_expr__ = map_.next_value()?;
7382 }
7383 GeneratedField::WaitForPersistence => {
7384 if wait_for_persistence__.is_some() {
7385 return Err(serde::de::Error::duplicate_field("waitForPersistence"));
7386 }
7387 wait_for_persistence__ = Some(map_.next_value()?);
7388 }
7389 GeneratedField::IsBatched => {
7390 if is_batched__.is_some() {
7391 return Err(serde::de::Error::duplicate_field("isBatched"));
7392 }
7393 is_batched__ = Some(map_.next_value()?);
7394 }
7395 }
7396 }
7397 Ok(WebhookSourceInfo {
7398 secret_ref: secret_ref__,
7399 signature_expr: signature_expr__,
7400 wait_for_persistence: wait_for_persistence__.unwrap_or_default(),
7401 is_batched: is_batched__.unwrap_or_default(),
7402 })
7403 }
7404 }
7405 deserializer.deserialize_struct("catalog.WebhookSourceInfo", FIELDS, GeneratedVisitor)
7406 }
7407}