1use crate::source::*;
2impl serde::Serialize for CdcTableSnapshotSplit {
3 #[allow(deprecated)]
4 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5 where
6 S: serde::Serializer,
7 {
8 use serde::ser::SerializeStruct;
9 let mut len = 0;
10 if self.split_id != 0 {
11 len += 1;
12 }
13 if !self.left_bound_inclusive.is_empty() {
14 len += 1;
15 }
16 if !self.right_bound_exclusive.is_empty() {
17 len += 1;
18 }
19 let mut struct_ser = serializer.serialize_struct("source.CdcTableSnapshotSplit", len)?;
20 if self.split_id != 0 {
21 #[allow(clippy::needless_borrow)]
22 #[allow(clippy::needless_borrows_for_generic_args)]
23 struct_ser.serialize_field("splitId", ToString::to_string(&self.split_id).as_str())?;
24 }
25 if !self.left_bound_inclusive.is_empty() {
26 #[allow(clippy::needless_borrow)]
27 #[allow(clippy::needless_borrows_for_generic_args)]
28 struct_ser.serialize_field("leftBoundInclusive", pbjson::private::base64::encode(&self.left_bound_inclusive).as_str())?;
29 }
30 if !self.right_bound_exclusive.is_empty() {
31 #[allow(clippy::needless_borrow)]
32 #[allow(clippy::needless_borrows_for_generic_args)]
33 struct_ser.serialize_field("rightBoundExclusive", pbjson::private::base64::encode(&self.right_bound_exclusive).as_str())?;
34 }
35 struct_ser.end()
36 }
37}
38impl<'de> serde::Deserialize<'de> for CdcTableSnapshotSplit {
39 #[allow(deprecated)]
40 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
41 where
42 D: serde::Deserializer<'de>,
43 {
44 const FIELDS: &[&str] = &[
45 "split_id",
46 "splitId",
47 "left_bound_inclusive",
48 "leftBoundInclusive",
49 "right_bound_exclusive",
50 "rightBoundExclusive",
51 ];
52
53 #[allow(clippy::enum_variant_names)]
54 enum GeneratedField {
55 SplitId,
56 LeftBoundInclusive,
57 RightBoundExclusive,
58 }
59 impl<'de> serde::Deserialize<'de> for GeneratedField {
60 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
61 where
62 D: serde::Deserializer<'de>,
63 {
64 struct GeneratedVisitor;
65
66 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
67 type Value = GeneratedField;
68
69 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
70 write!(formatter, "expected one of: {:?}", &FIELDS)
71 }
72
73 #[allow(unused_variables)]
74 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
75 where
76 E: serde::de::Error,
77 {
78 match value {
79 "splitId" | "split_id" => Ok(GeneratedField::SplitId),
80 "leftBoundInclusive" | "left_bound_inclusive" => Ok(GeneratedField::LeftBoundInclusive),
81 "rightBoundExclusive" | "right_bound_exclusive" => Ok(GeneratedField::RightBoundExclusive),
82 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
83 }
84 }
85 }
86 deserializer.deserialize_identifier(GeneratedVisitor)
87 }
88 }
89 struct GeneratedVisitor;
90 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
91 type Value = CdcTableSnapshotSplit;
92
93 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
94 formatter.write_str("struct source.CdcTableSnapshotSplit")
95 }
96
97 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcTableSnapshotSplit, V::Error>
98 where
99 V: serde::de::MapAccess<'de>,
100 {
101 let mut split_id__ = None;
102 let mut left_bound_inclusive__ = None;
103 let mut right_bound_exclusive__ = None;
104 while let Some(k) = map_.next_key()? {
105 match k {
106 GeneratedField::SplitId => {
107 if split_id__.is_some() {
108 return Err(serde::de::Error::duplicate_field("splitId"));
109 }
110 split_id__ =
111 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
112 ;
113 }
114 GeneratedField::LeftBoundInclusive => {
115 if left_bound_inclusive__.is_some() {
116 return Err(serde::de::Error::duplicate_field("leftBoundInclusive"));
117 }
118 left_bound_inclusive__ =
119 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
120 ;
121 }
122 GeneratedField::RightBoundExclusive => {
123 if right_bound_exclusive__.is_some() {
124 return Err(serde::de::Error::duplicate_field("rightBoundExclusive"));
125 }
126 right_bound_exclusive__ =
127 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
128 ;
129 }
130 }
131 }
132 Ok(CdcTableSnapshotSplit {
133 split_id: split_id__.unwrap_or_default(),
134 left_bound_inclusive: left_bound_inclusive__.unwrap_or_default(),
135 right_bound_exclusive: right_bound_exclusive__.unwrap_or_default(),
136 })
137 }
138 }
139 deserializer.deserialize_struct("source.CdcTableSnapshotSplit", FIELDS, GeneratedVisitor)
140 }
141}
142impl serde::Serialize for CdcTableSnapshotSplits {
143 #[allow(deprecated)]
144 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
145 where
146 S: serde::Serializer,
147 {
148 use serde::ser::SerializeStruct;
149 let mut len = 0;
150 if !self.splits.is_empty() {
151 len += 1;
152 }
153 let mut struct_ser = serializer.serialize_struct("source.CdcTableSnapshotSplits", len)?;
154 if !self.splits.is_empty() {
155 struct_ser.serialize_field("splits", &self.splits)?;
156 }
157 struct_ser.end()
158 }
159}
160impl<'de> serde::Deserialize<'de> for CdcTableSnapshotSplits {
161 #[allow(deprecated)]
162 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
163 where
164 D: serde::Deserializer<'de>,
165 {
166 const FIELDS: &[&str] = &[
167 "splits",
168 ];
169
170 #[allow(clippy::enum_variant_names)]
171 enum GeneratedField {
172 Splits,
173 }
174 impl<'de> serde::Deserialize<'de> for GeneratedField {
175 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
176 where
177 D: serde::Deserializer<'de>,
178 {
179 struct GeneratedVisitor;
180
181 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
182 type Value = GeneratedField;
183
184 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
185 write!(formatter, "expected one of: {:?}", &FIELDS)
186 }
187
188 #[allow(unused_variables)]
189 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
190 where
191 E: serde::de::Error,
192 {
193 match value {
194 "splits" => Ok(GeneratedField::Splits),
195 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
196 }
197 }
198 }
199 deserializer.deserialize_identifier(GeneratedVisitor)
200 }
201 }
202 struct GeneratedVisitor;
203 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
204 type Value = CdcTableSnapshotSplits;
205
206 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
207 formatter.write_str("struct source.CdcTableSnapshotSplits")
208 }
209
210 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcTableSnapshotSplits, V::Error>
211 where
212 V: serde::de::MapAccess<'de>,
213 {
214 let mut splits__ = None;
215 while let Some(k) = map_.next_key()? {
216 match k {
217 GeneratedField::Splits => {
218 if splits__.is_some() {
219 return Err(serde::de::Error::duplicate_field("splits"));
220 }
221 splits__ = Some(map_.next_value()?);
222 }
223 }
224 }
225 Ok(CdcTableSnapshotSplits {
226 splits: splits__.unwrap_or_default(),
227 })
228 }
229 }
230 deserializer.deserialize_struct("source.CdcTableSnapshotSplits", FIELDS, GeneratedVisitor)
231 }
232}
233impl serde::Serialize for CdcTableSnapshotSplitsWithGeneration {
234 #[allow(deprecated)]
235 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
236 where
237 S: serde::Serializer,
238 {
239 use serde::ser::SerializeStruct;
240 let mut len = 0;
241 if !self.splits.is_empty() {
242 len += 1;
243 }
244 if self.generation != 0 {
245 len += 1;
246 }
247 let mut struct_ser = serializer.serialize_struct("source.CdcTableSnapshotSplitsWithGeneration", len)?;
248 if !self.splits.is_empty() {
249 struct_ser.serialize_field("splits", &self.splits)?;
250 }
251 if self.generation != 0 {
252 #[allow(clippy::needless_borrow)]
253 #[allow(clippy::needless_borrows_for_generic_args)]
254 struct_ser.serialize_field("generation", ToString::to_string(&self.generation).as_str())?;
255 }
256 struct_ser.end()
257 }
258}
259impl<'de> serde::Deserialize<'de> for CdcTableSnapshotSplitsWithGeneration {
260 #[allow(deprecated)]
261 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
262 where
263 D: serde::Deserializer<'de>,
264 {
265 const FIELDS: &[&str] = &[
266 "splits",
267 "generation",
268 ];
269
270 #[allow(clippy::enum_variant_names)]
271 enum GeneratedField {
272 Splits,
273 Generation,
274 }
275 impl<'de> serde::Deserialize<'de> for GeneratedField {
276 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
277 where
278 D: serde::Deserializer<'de>,
279 {
280 struct GeneratedVisitor;
281
282 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
283 type Value = GeneratedField;
284
285 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
286 write!(formatter, "expected one of: {:?}", &FIELDS)
287 }
288
289 #[allow(unused_variables)]
290 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
291 where
292 E: serde::de::Error,
293 {
294 match value {
295 "splits" => Ok(GeneratedField::Splits),
296 "generation" => Ok(GeneratedField::Generation),
297 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
298 }
299 }
300 }
301 deserializer.deserialize_identifier(GeneratedVisitor)
302 }
303 }
304 struct GeneratedVisitor;
305 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
306 type Value = CdcTableSnapshotSplitsWithGeneration;
307
308 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
309 formatter.write_str("struct source.CdcTableSnapshotSplitsWithGeneration")
310 }
311
312 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcTableSnapshotSplitsWithGeneration, V::Error>
313 where
314 V: serde::de::MapAccess<'de>,
315 {
316 let mut splits__ = None;
317 let mut generation__ = None;
318 while let Some(k) = map_.next_key()? {
319 match k {
320 GeneratedField::Splits => {
321 if splits__.is_some() {
322 return Err(serde::de::Error::duplicate_field("splits"));
323 }
324 splits__ = Some(
325 map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
326 .into_iter().map(|(k,v)| (k.0, v)).collect()
327 );
328 }
329 GeneratedField::Generation => {
330 if generation__.is_some() {
331 return Err(serde::de::Error::duplicate_field("generation"));
332 }
333 generation__ =
334 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
335 ;
336 }
337 }
338 }
339 Ok(CdcTableSnapshotSplitsWithGeneration {
340 splits: splits__.unwrap_or_default(),
341 generation: generation__.unwrap_or_default(),
342 })
343 }
344 }
345 deserializer.deserialize_struct("source.CdcTableSnapshotSplitsWithGeneration", FIELDS, GeneratedVisitor)
346 }
347}
348impl serde::Serialize for ConnectorSplit {
349 #[allow(deprecated)]
350 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
351 where
352 S: serde::Serializer,
353 {
354 use serde::ser::SerializeStruct;
355 let mut len = 0;
356 if !self.split_type.is_empty() {
357 len += 1;
358 }
359 if !self.encoded_split.is_empty() {
360 len += 1;
361 }
362 let mut struct_ser = serializer.serialize_struct("source.ConnectorSplit", len)?;
363 if !self.split_type.is_empty() {
364 struct_ser.serialize_field("splitType", &self.split_type)?;
365 }
366 if !self.encoded_split.is_empty() {
367 #[allow(clippy::needless_borrow)]
368 #[allow(clippy::needless_borrows_for_generic_args)]
369 struct_ser.serialize_field("encodedSplit", pbjson::private::base64::encode(&self.encoded_split).as_str())?;
370 }
371 struct_ser.end()
372 }
373}
374impl<'de> serde::Deserialize<'de> for ConnectorSplit {
375 #[allow(deprecated)]
376 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
377 where
378 D: serde::Deserializer<'de>,
379 {
380 const FIELDS: &[&str] = &[
381 "split_type",
382 "splitType",
383 "encoded_split",
384 "encodedSplit",
385 ];
386
387 #[allow(clippy::enum_variant_names)]
388 enum GeneratedField {
389 SplitType,
390 EncodedSplit,
391 }
392 impl<'de> serde::Deserialize<'de> for GeneratedField {
393 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
394 where
395 D: serde::Deserializer<'de>,
396 {
397 struct GeneratedVisitor;
398
399 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
400 type Value = GeneratedField;
401
402 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
403 write!(formatter, "expected one of: {:?}", &FIELDS)
404 }
405
406 #[allow(unused_variables)]
407 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
408 where
409 E: serde::de::Error,
410 {
411 match value {
412 "splitType" | "split_type" => Ok(GeneratedField::SplitType),
413 "encodedSplit" | "encoded_split" => Ok(GeneratedField::EncodedSplit),
414 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
415 }
416 }
417 }
418 deserializer.deserialize_identifier(GeneratedVisitor)
419 }
420 }
421 struct GeneratedVisitor;
422 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
423 type Value = ConnectorSplit;
424
425 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
426 formatter.write_str("struct source.ConnectorSplit")
427 }
428
429 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorSplit, V::Error>
430 where
431 V: serde::de::MapAccess<'de>,
432 {
433 let mut split_type__ = None;
434 let mut encoded_split__ = None;
435 while let Some(k) = map_.next_key()? {
436 match k {
437 GeneratedField::SplitType => {
438 if split_type__.is_some() {
439 return Err(serde::de::Error::duplicate_field("splitType"));
440 }
441 split_type__ = Some(map_.next_value()?);
442 }
443 GeneratedField::EncodedSplit => {
444 if encoded_split__.is_some() {
445 return Err(serde::de::Error::duplicate_field("encodedSplit"));
446 }
447 encoded_split__ =
448 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
449 ;
450 }
451 }
452 }
453 Ok(ConnectorSplit {
454 split_type: split_type__.unwrap_or_default(),
455 encoded_split: encoded_split__.unwrap_or_default(),
456 })
457 }
458 }
459 deserializer.deserialize_struct("source.ConnectorSplit", FIELDS, GeneratedVisitor)
460 }
461}
462impl serde::Serialize for ConnectorSplits {
463 #[allow(deprecated)]
464 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
465 where
466 S: serde::Serializer,
467 {
468 use serde::ser::SerializeStruct;
469 let mut len = 0;
470 if !self.splits.is_empty() {
471 len += 1;
472 }
473 let mut struct_ser = serializer.serialize_struct("source.ConnectorSplits", len)?;
474 if !self.splits.is_empty() {
475 struct_ser.serialize_field("splits", &self.splits)?;
476 }
477 struct_ser.end()
478 }
479}
480impl<'de> serde::Deserialize<'de> for ConnectorSplits {
481 #[allow(deprecated)]
482 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
483 where
484 D: serde::Deserializer<'de>,
485 {
486 const FIELDS: &[&str] = &[
487 "splits",
488 ];
489
490 #[allow(clippy::enum_variant_names)]
491 enum GeneratedField {
492 Splits,
493 }
494 impl<'de> serde::Deserialize<'de> for GeneratedField {
495 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
496 where
497 D: serde::Deserializer<'de>,
498 {
499 struct GeneratedVisitor;
500
501 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
502 type Value = GeneratedField;
503
504 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
505 write!(formatter, "expected one of: {:?}", &FIELDS)
506 }
507
508 #[allow(unused_variables)]
509 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
510 where
511 E: serde::de::Error,
512 {
513 match value {
514 "splits" => Ok(GeneratedField::Splits),
515 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
516 }
517 }
518 }
519 deserializer.deserialize_identifier(GeneratedVisitor)
520 }
521 }
522 struct GeneratedVisitor;
523 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
524 type Value = ConnectorSplits;
525
526 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
527 formatter.write_str("struct source.ConnectorSplits")
528 }
529
530 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorSplits, V::Error>
531 where
532 V: serde::de::MapAccess<'de>,
533 {
534 let mut splits__ = None;
535 while let Some(k) = map_.next_key()? {
536 match k {
537 GeneratedField::Splits => {
538 if splits__.is_some() {
539 return Err(serde::de::Error::duplicate_field("splits"));
540 }
541 splits__ = Some(map_.next_value()?);
542 }
543 }
544 }
545 Ok(ConnectorSplits {
546 splits: splits__.unwrap_or_default(),
547 })
548 }
549 }
550 deserializer.deserialize_struct("source.ConnectorSplits", FIELDS, GeneratedVisitor)
551 }
552}
553impl serde::Serialize for SourceActorInfo {
554 #[allow(deprecated)]
555 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
556 where
557 S: serde::Serializer,
558 {
559 use serde::ser::SerializeStruct;
560 let mut len = 0;
561 if self.actor_id != 0 {
562 len += 1;
563 }
564 if self.splits.is_some() {
565 len += 1;
566 }
567 let mut struct_ser = serializer.serialize_struct("source.SourceActorInfo", len)?;
568 if self.actor_id != 0 {
569 struct_ser.serialize_field("actorId", &self.actor_id)?;
570 }
571 if let Some(v) = self.splits.as_ref() {
572 struct_ser.serialize_field("splits", v)?;
573 }
574 struct_ser.end()
575 }
576}
577impl<'de> serde::Deserialize<'de> for SourceActorInfo {
578 #[allow(deprecated)]
579 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
580 where
581 D: serde::Deserializer<'de>,
582 {
583 const FIELDS: &[&str] = &[
584 "actor_id",
585 "actorId",
586 "splits",
587 ];
588
589 #[allow(clippy::enum_variant_names)]
590 enum GeneratedField {
591 ActorId,
592 Splits,
593 }
594 impl<'de> serde::Deserialize<'de> for GeneratedField {
595 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
596 where
597 D: serde::Deserializer<'de>,
598 {
599 struct GeneratedVisitor;
600
601 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
602 type Value = GeneratedField;
603
604 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
605 write!(formatter, "expected one of: {:?}", &FIELDS)
606 }
607
608 #[allow(unused_variables)]
609 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
610 where
611 E: serde::de::Error,
612 {
613 match value {
614 "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
615 "splits" => Ok(GeneratedField::Splits),
616 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
617 }
618 }
619 }
620 deserializer.deserialize_identifier(GeneratedVisitor)
621 }
622 }
623 struct GeneratedVisitor;
624 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
625 type Value = SourceActorInfo;
626
627 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
628 formatter.write_str("struct source.SourceActorInfo")
629 }
630
631 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceActorInfo, V::Error>
632 where
633 V: serde::de::MapAccess<'de>,
634 {
635 let mut actor_id__ = None;
636 let mut splits__ = None;
637 while let Some(k) = map_.next_key()? {
638 match k {
639 GeneratedField::ActorId => {
640 if actor_id__.is_some() {
641 return Err(serde::de::Error::duplicate_field("actorId"));
642 }
643 actor_id__ =
644 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
645 ;
646 }
647 GeneratedField::Splits => {
648 if splits__.is_some() {
649 return Err(serde::de::Error::duplicate_field("splits"));
650 }
651 splits__ = map_.next_value()?;
652 }
653 }
654 }
655 Ok(SourceActorInfo {
656 actor_id: actor_id__.unwrap_or_default(),
657 splits: splits__,
658 })
659 }
660 }
661 deserializer.deserialize_struct("source.SourceActorInfo", FIELDS, GeneratedVisitor)
662 }
663}