1#![allow(clippy::useless_conversion)]
2use crate::connector_service::*;
3impl serde::Serialize for CdcMessage {
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.payload.is_empty() {
12 len += 1;
13 }
14 if !self.partition.is_empty() {
15 len += 1;
16 }
17 if !self.offset.is_empty() {
18 len += 1;
19 }
20 if !self.full_table_name.is_empty() {
21 len += 1;
22 }
23 if self.source_ts_ms != 0 {
24 len += 1;
25 }
26 if self.msg_type != 0 {
27 len += 1;
28 }
29 if !self.key.is_empty() {
30 len += 1;
31 }
32 if self.source_type != 0 {
33 len += 1;
34 }
35 let mut struct_ser = serializer.serialize_struct("connector_service.CdcMessage", len)?;
36 if !self.payload.is_empty() {
37 struct_ser.serialize_field("payload", &self.payload)?;
38 }
39 if !self.partition.is_empty() {
40 struct_ser.serialize_field("partition", &self.partition)?;
41 }
42 if !self.offset.is_empty() {
43 struct_ser.serialize_field("offset", &self.offset)?;
44 }
45 if !self.full_table_name.is_empty() {
46 struct_ser.serialize_field("fullTableName", &self.full_table_name)?;
47 }
48 if self.source_ts_ms != 0 {
49 #[allow(clippy::needless_borrow)]
50 #[allow(clippy::needless_borrows_for_generic_args)]
51 struct_ser.serialize_field("sourceTsMs", ToString::to_string(&self.source_ts_ms).as_str())?;
52 }
53 if self.msg_type != 0 {
54 let v = cdc_message::CdcMessageType::try_from(self.msg_type)
55 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.msg_type)))?;
56 struct_ser.serialize_field("msgType", &v)?;
57 }
58 if !self.key.is_empty() {
59 struct_ser.serialize_field("key", &self.key)?;
60 }
61 if self.source_type != 0 {
62 let v = SourceType::try_from(self.source_type)
63 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.source_type)))?;
64 struct_ser.serialize_field("sourceType", &v)?;
65 }
66 struct_ser.end()
67 }
68}
69impl<'de> serde::Deserialize<'de> for CdcMessage {
70 #[allow(deprecated)]
71 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
72 where
73 D: serde::Deserializer<'de>,
74 {
75 const FIELDS: &[&str] = &[
76 "payload",
77 "partition",
78 "offset",
79 "full_table_name",
80 "fullTableName",
81 "source_ts_ms",
82 "sourceTsMs",
83 "msg_type",
84 "msgType",
85 "key",
86 "source_type",
87 "sourceType",
88 ];
89
90 #[allow(clippy::enum_variant_names)]
91 enum GeneratedField {
92 Payload,
93 Partition,
94 Offset,
95 FullTableName,
96 SourceTsMs,
97 MsgType,
98 Key,
99 SourceType,
100 }
101 impl<'de> serde::Deserialize<'de> for GeneratedField {
102 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
103 where
104 D: serde::Deserializer<'de>,
105 {
106 struct GeneratedVisitor;
107
108 impl serde::de::Visitor<'_> for GeneratedVisitor {
109 type Value = GeneratedField;
110
111 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
112 write!(formatter, "expected one of: {:?}", &FIELDS)
113 }
114
115 #[allow(unused_variables)]
116 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
117 where
118 E: serde::de::Error,
119 {
120 match value {
121 "payload" => Ok(GeneratedField::Payload),
122 "partition" => Ok(GeneratedField::Partition),
123 "offset" => Ok(GeneratedField::Offset),
124 "fullTableName" | "full_table_name" => Ok(GeneratedField::FullTableName),
125 "sourceTsMs" | "source_ts_ms" => Ok(GeneratedField::SourceTsMs),
126 "msgType" | "msg_type" => Ok(GeneratedField::MsgType),
127 "key" => Ok(GeneratedField::Key),
128 "sourceType" | "source_type" => Ok(GeneratedField::SourceType),
129 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
130 }
131 }
132 }
133 deserializer.deserialize_identifier(GeneratedVisitor)
134 }
135 }
136 struct GeneratedVisitor;
137 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
138 type Value = CdcMessage;
139
140 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
141 formatter.write_str("struct connector_service.CdcMessage")
142 }
143
144 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcMessage, V::Error>
145 where
146 V: serde::de::MapAccess<'de>,
147 {
148 let mut payload__ = None;
149 let mut partition__ = None;
150 let mut offset__ = None;
151 let mut full_table_name__ = None;
152 let mut source_ts_ms__ = None;
153 let mut msg_type__ = None;
154 let mut key__ = None;
155 let mut source_type__ = None;
156 while let Some(k) = map_.next_key()? {
157 match k {
158 GeneratedField::Payload => {
159 if payload__.is_some() {
160 return Err(serde::de::Error::duplicate_field("payload"));
161 }
162 payload__ = Some(map_.next_value()?);
163 }
164 GeneratedField::Partition => {
165 if partition__.is_some() {
166 return Err(serde::de::Error::duplicate_field("partition"));
167 }
168 partition__ = Some(map_.next_value()?);
169 }
170 GeneratedField::Offset => {
171 if offset__.is_some() {
172 return Err(serde::de::Error::duplicate_field("offset"));
173 }
174 offset__ = Some(map_.next_value()?);
175 }
176 GeneratedField::FullTableName => {
177 if full_table_name__.is_some() {
178 return Err(serde::de::Error::duplicate_field("fullTableName"));
179 }
180 full_table_name__ = Some(map_.next_value()?);
181 }
182 GeneratedField::SourceTsMs => {
183 if source_ts_ms__.is_some() {
184 return Err(serde::de::Error::duplicate_field("sourceTsMs"));
185 }
186 source_ts_ms__ =
187 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
188 ;
189 }
190 GeneratedField::MsgType => {
191 if msg_type__.is_some() {
192 return Err(serde::de::Error::duplicate_field("msgType"));
193 }
194 msg_type__ = Some(map_.next_value::<cdc_message::CdcMessageType>()? as i32);
195 }
196 GeneratedField::Key => {
197 if key__.is_some() {
198 return Err(serde::de::Error::duplicate_field("key"));
199 }
200 key__ = Some(map_.next_value()?);
201 }
202 GeneratedField::SourceType => {
203 if source_type__.is_some() {
204 return Err(serde::de::Error::duplicate_field("sourceType"));
205 }
206 source_type__ = Some(map_.next_value::<SourceType>()? as i32);
207 }
208 }
209 }
210 Ok(CdcMessage {
211 payload: payload__.unwrap_or_default(),
212 partition: partition__.unwrap_or_default(),
213 offset: offset__.unwrap_or_default(),
214 full_table_name: full_table_name__.unwrap_or_default(),
215 source_ts_ms: source_ts_ms__.unwrap_or_default(),
216 msg_type: msg_type__.unwrap_or_default(),
217 key: key__.unwrap_or_default(),
218 source_type: source_type__.unwrap_or_default(),
219 })
220 }
221 }
222 deserializer.deserialize_struct("connector_service.CdcMessage", FIELDS, GeneratedVisitor)
223 }
224}
225impl serde::Serialize for cdc_message::CdcMessageType {
226 #[allow(deprecated)]
227 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
228 where
229 S: serde::Serializer,
230 {
231 let variant = match self {
232 Self::Unspecified => "UNSPECIFIED",
233 Self::Heartbeat => "HEARTBEAT",
234 Self::Data => "DATA",
235 Self::TransactionMeta => "TRANSACTION_META",
236 Self::SchemaChange => "SCHEMA_CHANGE",
237 };
238 serializer.serialize_str(variant)
239 }
240}
241impl<'de> serde::Deserialize<'de> for cdc_message::CdcMessageType {
242 #[allow(deprecated)]
243 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
244 where
245 D: serde::Deserializer<'de>,
246 {
247 const FIELDS: &[&str] = &[
248 "UNSPECIFIED",
249 "HEARTBEAT",
250 "DATA",
251 "TRANSACTION_META",
252 "SCHEMA_CHANGE",
253 ];
254
255 struct GeneratedVisitor;
256
257 impl serde::de::Visitor<'_> for GeneratedVisitor {
258 type Value = cdc_message::CdcMessageType;
259
260 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
261 write!(formatter, "expected one of: {:?}", &FIELDS)
262 }
263
264 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
265 where
266 E: serde::de::Error,
267 {
268 i32::try_from(v)
269 .ok()
270 .and_then(|x| x.try_into().ok())
271 .ok_or_else(|| {
272 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
273 })
274 }
275
276 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
277 where
278 E: serde::de::Error,
279 {
280 i32::try_from(v)
281 .ok()
282 .and_then(|x| x.try_into().ok())
283 .ok_or_else(|| {
284 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
285 })
286 }
287
288 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
289 where
290 E: serde::de::Error,
291 {
292 match value {
293 "UNSPECIFIED" => Ok(cdc_message::CdcMessageType::Unspecified),
294 "HEARTBEAT" => Ok(cdc_message::CdcMessageType::Heartbeat),
295 "DATA" => Ok(cdc_message::CdcMessageType::Data),
296 "TRANSACTION_META" => Ok(cdc_message::CdcMessageType::TransactionMeta),
297 "SCHEMA_CHANGE" => Ok(cdc_message::CdcMessageType::SchemaChange),
298 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
299 }
300 }
301 }
302 deserializer.deserialize_any(GeneratedVisitor)
303 }
304}
305impl serde::Serialize for CoordinateRequest {
306 #[allow(deprecated)]
307 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
308 where
309 S: serde::Serializer,
310 {
311 use serde::ser::SerializeStruct;
312 let mut len = 0;
313 if self.msg.is_some() {
314 len += 1;
315 }
316 let mut struct_ser = serializer.serialize_struct("connector_service.CoordinateRequest", len)?;
317 if let Some(v) = self.msg.as_ref() {
318 match v {
319 coordinate_request::Msg::StartRequest(v) => {
320 struct_ser.serialize_field("startRequest", v)?;
321 }
322 coordinate_request::Msg::CommitRequest(v) => {
323 struct_ser.serialize_field("commitRequest", v)?;
324 }
325 coordinate_request::Msg::UpdateVnodeRequest(v) => {
326 struct_ser.serialize_field("updateVnodeRequest", v)?;
327 }
328 coordinate_request::Msg::Stop(v) => {
329 struct_ser.serialize_field("stop", v)?;
330 }
331 coordinate_request::Msg::AlignInitialEpochRequest(v) => {
332 #[allow(clippy::needless_borrow)]
333 #[allow(clippy::needless_borrows_for_generic_args)]
334 struct_ser.serialize_field("alignInitialEpochRequest", ToString::to_string(&v).as_str())?;
335 }
336 }
337 }
338 struct_ser.end()
339 }
340}
341impl<'de> serde::Deserialize<'de> for CoordinateRequest {
342 #[allow(deprecated)]
343 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
344 where
345 D: serde::Deserializer<'de>,
346 {
347 const FIELDS: &[&str] = &[
348 "start_request",
349 "startRequest",
350 "commit_request",
351 "commitRequest",
352 "update_vnode_request",
353 "updateVnodeRequest",
354 "stop",
355 "align_initial_epoch_request",
356 "alignInitialEpochRequest",
357 ];
358
359 #[allow(clippy::enum_variant_names)]
360 enum GeneratedField {
361 StartRequest,
362 CommitRequest,
363 UpdateVnodeRequest,
364 Stop,
365 AlignInitialEpochRequest,
366 }
367 impl<'de> serde::Deserialize<'de> for GeneratedField {
368 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
369 where
370 D: serde::Deserializer<'de>,
371 {
372 struct GeneratedVisitor;
373
374 impl serde::de::Visitor<'_> for GeneratedVisitor {
375 type Value = GeneratedField;
376
377 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
378 write!(formatter, "expected one of: {:?}", &FIELDS)
379 }
380
381 #[allow(unused_variables)]
382 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
383 where
384 E: serde::de::Error,
385 {
386 match value {
387 "startRequest" | "start_request" => Ok(GeneratedField::StartRequest),
388 "commitRequest" | "commit_request" => Ok(GeneratedField::CommitRequest),
389 "updateVnodeRequest" | "update_vnode_request" => Ok(GeneratedField::UpdateVnodeRequest),
390 "stop" => Ok(GeneratedField::Stop),
391 "alignInitialEpochRequest" | "align_initial_epoch_request" => Ok(GeneratedField::AlignInitialEpochRequest),
392 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
393 }
394 }
395 }
396 deserializer.deserialize_identifier(GeneratedVisitor)
397 }
398 }
399 struct GeneratedVisitor;
400 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
401 type Value = CoordinateRequest;
402
403 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
404 formatter.write_str("struct connector_service.CoordinateRequest")
405 }
406
407 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CoordinateRequest, V::Error>
408 where
409 V: serde::de::MapAccess<'de>,
410 {
411 let mut msg__ = None;
412 while let Some(k) = map_.next_key()? {
413 match k {
414 GeneratedField::StartRequest => {
415 if msg__.is_some() {
416 return Err(serde::de::Error::duplicate_field("startRequest"));
417 }
418 msg__ = map_.next_value::<::std::option::Option<_>>()?.map(coordinate_request::Msg::StartRequest)
419;
420 }
421 GeneratedField::CommitRequest => {
422 if msg__.is_some() {
423 return Err(serde::de::Error::duplicate_field("commitRequest"));
424 }
425 msg__ = map_.next_value::<::std::option::Option<_>>()?.map(coordinate_request::Msg::CommitRequest)
426;
427 }
428 GeneratedField::UpdateVnodeRequest => {
429 if msg__.is_some() {
430 return Err(serde::de::Error::duplicate_field("updateVnodeRequest"));
431 }
432 msg__ = map_.next_value::<::std::option::Option<_>>()?.map(coordinate_request::Msg::UpdateVnodeRequest)
433;
434 }
435 GeneratedField::Stop => {
436 if msg__.is_some() {
437 return Err(serde::de::Error::duplicate_field("stop"));
438 }
439 msg__ = map_.next_value::<::std::option::Option<_>>()?.map(coordinate_request::Msg::Stop);
440 }
441 GeneratedField::AlignInitialEpochRequest => {
442 if msg__.is_some() {
443 return Err(serde::de::Error::duplicate_field("alignInitialEpochRequest"));
444 }
445 msg__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| coordinate_request::Msg::AlignInitialEpochRequest(x.0));
446 }
447 }
448 }
449 Ok(CoordinateRequest {
450 msg: msg__,
451 })
452 }
453 }
454 deserializer.deserialize_struct("connector_service.CoordinateRequest", FIELDS, GeneratedVisitor)
455 }
456}
457impl serde::Serialize for coordinate_request::CommitRequest {
458 #[allow(deprecated)]
459 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
460 where
461 S: serde::Serializer,
462 {
463 use serde::ser::SerializeStruct;
464 let mut len = 0;
465 if self.epoch != 0 {
466 len += 1;
467 }
468 if self.metadata.is_some() {
469 len += 1;
470 }
471 if self.schema_change.is_some() {
472 len += 1;
473 }
474 let mut struct_ser = serializer.serialize_struct("connector_service.CoordinateRequest.CommitRequest", len)?;
475 if self.epoch != 0 {
476 #[allow(clippy::needless_borrow)]
477 #[allow(clippy::needless_borrows_for_generic_args)]
478 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
479 }
480 if let Some(v) = self.metadata.as_ref() {
481 struct_ser.serialize_field("metadata", v)?;
482 }
483 if let Some(v) = self.schema_change.as_ref() {
484 struct_ser.serialize_field("schemaChange", v)?;
485 }
486 struct_ser.end()
487 }
488}
489impl<'de> serde::Deserialize<'de> for coordinate_request::CommitRequest {
490 #[allow(deprecated)]
491 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
492 where
493 D: serde::Deserializer<'de>,
494 {
495 const FIELDS: &[&str] = &[
496 "epoch",
497 "metadata",
498 "schema_change",
499 "schemaChange",
500 ];
501
502 #[allow(clippy::enum_variant_names)]
503 enum GeneratedField {
504 Epoch,
505 Metadata,
506 SchemaChange,
507 }
508 impl<'de> serde::Deserialize<'de> for GeneratedField {
509 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
510 where
511 D: serde::Deserializer<'de>,
512 {
513 struct GeneratedVisitor;
514
515 impl serde::de::Visitor<'_> for GeneratedVisitor {
516 type Value = GeneratedField;
517
518 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
519 write!(formatter, "expected one of: {:?}", &FIELDS)
520 }
521
522 #[allow(unused_variables)]
523 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
524 where
525 E: serde::de::Error,
526 {
527 match value {
528 "epoch" => Ok(GeneratedField::Epoch),
529 "metadata" => Ok(GeneratedField::Metadata),
530 "schemaChange" | "schema_change" => Ok(GeneratedField::SchemaChange),
531 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
532 }
533 }
534 }
535 deserializer.deserialize_identifier(GeneratedVisitor)
536 }
537 }
538 struct GeneratedVisitor;
539 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
540 type Value = coordinate_request::CommitRequest;
541
542 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
543 formatter.write_str("struct connector_service.CoordinateRequest.CommitRequest")
544 }
545
546 fn visit_map<V>(self, mut map_: V) -> std::result::Result<coordinate_request::CommitRequest, V::Error>
547 where
548 V: serde::de::MapAccess<'de>,
549 {
550 let mut epoch__ = None;
551 let mut metadata__ = None;
552 let mut schema_change__ = None;
553 while let Some(k) = map_.next_key()? {
554 match k {
555 GeneratedField::Epoch => {
556 if epoch__.is_some() {
557 return Err(serde::de::Error::duplicate_field("epoch"));
558 }
559 epoch__ =
560 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
561 ;
562 }
563 GeneratedField::Metadata => {
564 if metadata__.is_some() {
565 return Err(serde::de::Error::duplicate_field("metadata"));
566 }
567 metadata__ = map_.next_value()?;
568 }
569 GeneratedField::SchemaChange => {
570 if schema_change__.is_some() {
571 return Err(serde::de::Error::duplicate_field("schemaChange"));
572 }
573 schema_change__ = map_.next_value()?;
574 }
575 }
576 }
577 Ok(coordinate_request::CommitRequest {
578 epoch: epoch__.unwrap_or_default(),
579 metadata: metadata__,
580 schema_change: schema_change__,
581 })
582 }
583 }
584 deserializer.deserialize_struct("connector_service.CoordinateRequest.CommitRequest", FIELDS, GeneratedVisitor)
585 }
586}
587impl serde::Serialize for coordinate_request::StartCoordinationRequest {
588 #[allow(deprecated)]
589 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
590 where
591 S: serde::Serializer,
592 {
593 use serde::ser::SerializeStruct;
594 let mut len = 0;
595 if self.vnode_bitmap.is_some() {
596 len += 1;
597 }
598 if self.param.is_some() {
599 len += 1;
600 }
601 let mut struct_ser = serializer.serialize_struct("connector_service.CoordinateRequest.StartCoordinationRequest", len)?;
602 if let Some(v) = self.vnode_bitmap.as_ref() {
603 struct_ser.serialize_field("vnodeBitmap", v)?;
604 }
605 if let Some(v) = self.param.as_ref() {
606 struct_ser.serialize_field("param", v)?;
607 }
608 struct_ser.end()
609 }
610}
611impl<'de> serde::Deserialize<'de> for coordinate_request::StartCoordinationRequest {
612 #[allow(deprecated)]
613 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
614 where
615 D: serde::Deserializer<'de>,
616 {
617 const FIELDS: &[&str] = &[
618 "vnode_bitmap",
619 "vnodeBitmap",
620 "param",
621 ];
622
623 #[allow(clippy::enum_variant_names)]
624 enum GeneratedField {
625 VnodeBitmap,
626 Param,
627 }
628 impl<'de> serde::Deserialize<'de> for GeneratedField {
629 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
630 where
631 D: serde::Deserializer<'de>,
632 {
633 struct GeneratedVisitor;
634
635 impl serde::de::Visitor<'_> for GeneratedVisitor {
636 type Value = GeneratedField;
637
638 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
639 write!(formatter, "expected one of: {:?}", &FIELDS)
640 }
641
642 #[allow(unused_variables)]
643 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
644 where
645 E: serde::de::Error,
646 {
647 match value {
648 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
649 "param" => Ok(GeneratedField::Param),
650 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
651 }
652 }
653 }
654 deserializer.deserialize_identifier(GeneratedVisitor)
655 }
656 }
657 struct GeneratedVisitor;
658 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
659 type Value = coordinate_request::StartCoordinationRequest;
660
661 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
662 formatter.write_str("struct connector_service.CoordinateRequest.StartCoordinationRequest")
663 }
664
665 fn visit_map<V>(self, mut map_: V) -> std::result::Result<coordinate_request::StartCoordinationRequest, V::Error>
666 where
667 V: serde::de::MapAccess<'de>,
668 {
669 let mut vnode_bitmap__ = None;
670 let mut param__ = None;
671 while let Some(k) = map_.next_key()? {
672 match k {
673 GeneratedField::VnodeBitmap => {
674 if vnode_bitmap__.is_some() {
675 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
676 }
677 vnode_bitmap__ = map_.next_value()?;
678 }
679 GeneratedField::Param => {
680 if param__.is_some() {
681 return Err(serde::de::Error::duplicate_field("param"));
682 }
683 param__ = map_.next_value()?;
684 }
685 }
686 }
687 Ok(coordinate_request::StartCoordinationRequest {
688 vnode_bitmap: vnode_bitmap__,
689 param: param__,
690 })
691 }
692 }
693 deserializer.deserialize_struct("connector_service.CoordinateRequest.StartCoordinationRequest", FIELDS, GeneratedVisitor)
694 }
695}
696impl serde::Serialize for coordinate_request::UpdateVnodeBitmapRequest {
697 #[allow(deprecated)]
698 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
699 where
700 S: serde::Serializer,
701 {
702 use serde::ser::SerializeStruct;
703 let mut len = 0;
704 if self.vnode_bitmap.is_some() {
705 len += 1;
706 }
707 let mut struct_ser = serializer.serialize_struct("connector_service.CoordinateRequest.UpdateVnodeBitmapRequest", len)?;
708 if let Some(v) = self.vnode_bitmap.as_ref() {
709 struct_ser.serialize_field("vnodeBitmap", v)?;
710 }
711 struct_ser.end()
712 }
713}
714impl<'de> serde::Deserialize<'de> for coordinate_request::UpdateVnodeBitmapRequest {
715 #[allow(deprecated)]
716 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
717 where
718 D: serde::Deserializer<'de>,
719 {
720 const FIELDS: &[&str] = &[
721 "vnode_bitmap",
722 "vnodeBitmap",
723 ];
724
725 #[allow(clippy::enum_variant_names)]
726 enum GeneratedField {
727 VnodeBitmap,
728 }
729 impl<'de> serde::Deserialize<'de> for GeneratedField {
730 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
731 where
732 D: serde::Deserializer<'de>,
733 {
734 struct GeneratedVisitor;
735
736 impl serde::de::Visitor<'_> for GeneratedVisitor {
737 type Value = GeneratedField;
738
739 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
740 write!(formatter, "expected one of: {:?}", &FIELDS)
741 }
742
743 #[allow(unused_variables)]
744 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
745 where
746 E: serde::de::Error,
747 {
748 match value {
749 "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
750 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
751 }
752 }
753 }
754 deserializer.deserialize_identifier(GeneratedVisitor)
755 }
756 }
757 struct GeneratedVisitor;
758 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
759 type Value = coordinate_request::UpdateVnodeBitmapRequest;
760
761 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
762 formatter.write_str("struct connector_service.CoordinateRequest.UpdateVnodeBitmapRequest")
763 }
764
765 fn visit_map<V>(self, mut map_: V) -> std::result::Result<coordinate_request::UpdateVnodeBitmapRequest, V::Error>
766 where
767 V: serde::de::MapAccess<'de>,
768 {
769 let mut vnode_bitmap__ = None;
770 while let Some(k) = map_.next_key()? {
771 match k {
772 GeneratedField::VnodeBitmap => {
773 if vnode_bitmap__.is_some() {
774 return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
775 }
776 vnode_bitmap__ = map_.next_value()?;
777 }
778 }
779 }
780 Ok(coordinate_request::UpdateVnodeBitmapRequest {
781 vnode_bitmap: vnode_bitmap__,
782 })
783 }
784 }
785 deserializer.deserialize_struct("connector_service.CoordinateRequest.UpdateVnodeBitmapRequest", FIELDS, GeneratedVisitor)
786 }
787}
788impl serde::Serialize for CoordinateResponse {
789 #[allow(deprecated)]
790 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
791 where
792 S: serde::Serializer,
793 {
794 use serde::ser::SerializeStruct;
795 let mut len = 0;
796 if self.msg.is_some() {
797 len += 1;
798 }
799 let mut struct_ser = serializer.serialize_struct("connector_service.CoordinateResponse", len)?;
800 if let Some(v) = self.msg.as_ref() {
801 match v {
802 coordinate_response::Msg::StartResponse(v) => {
803 struct_ser.serialize_field("startResponse", v)?;
804 }
805 coordinate_response::Msg::CommitResponse(v) => {
806 struct_ser.serialize_field("commitResponse", v)?;
807 }
808 coordinate_response::Msg::Stopped(v) => {
809 struct_ser.serialize_field("stopped", v)?;
810 }
811 coordinate_response::Msg::AlignInitialEpochResponse(v) => {
812 #[allow(clippy::needless_borrow)]
813 #[allow(clippy::needless_borrows_for_generic_args)]
814 struct_ser.serialize_field("alignInitialEpochResponse", ToString::to_string(&v).as_str())?;
815 }
816 }
817 }
818 struct_ser.end()
819 }
820}
821impl<'de> serde::Deserialize<'de> for CoordinateResponse {
822 #[allow(deprecated)]
823 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
824 where
825 D: serde::Deserializer<'de>,
826 {
827 const FIELDS: &[&str] = &[
828 "start_response",
829 "startResponse",
830 "commit_response",
831 "commitResponse",
832 "stopped",
833 "align_initial_epoch_response",
834 "alignInitialEpochResponse",
835 ];
836
837 #[allow(clippy::enum_variant_names)]
838 enum GeneratedField {
839 StartResponse,
840 CommitResponse,
841 Stopped,
842 AlignInitialEpochResponse,
843 }
844 impl<'de> serde::Deserialize<'de> for GeneratedField {
845 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
846 where
847 D: serde::Deserializer<'de>,
848 {
849 struct GeneratedVisitor;
850
851 impl serde::de::Visitor<'_> for GeneratedVisitor {
852 type Value = GeneratedField;
853
854 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
855 write!(formatter, "expected one of: {:?}", &FIELDS)
856 }
857
858 #[allow(unused_variables)]
859 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
860 where
861 E: serde::de::Error,
862 {
863 match value {
864 "startResponse" | "start_response" => Ok(GeneratedField::StartResponse),
865 "commitResponse" | "commit_response" => Ok(GeneratedField::CommitResponse),
866 "stopped" => Ok(GeneratedField::Stopped),
867 "alignInitialEpochResponse" | "align_initial_epoch_response" => Ok(GeneratedField::AlignInitialEpochResponse),
868 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
869 }
870 }
871 }
872 deserializer.deserialize_identifier(GeneratedVisitor)
873 }
874 }
875 struct GeneratedVisitor;
876 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
877 type Value = CoordinateResponse;
878
879 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
880 formatter.write_str("struct connector_service.CoordinateResponse")
881 }
882
883 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CoordinateResponse, V::Error>
884 where
885 V: serde::de::MapAccess<'de>,
886 {
887 let mut msg__ = None;
888 while let Some(k) = map_.next_key()? {
889 match k {
890 GeneratedField::StartResponse => {
891 if msg__.is_some() {
892 return Err(serde::de::Error::duplicate_field("startResponse"));
893 }
894 msg__ = map_.next_value::<::std::option::Option<_>>()?.map(coordinate_response::Msg::StartResponse)
895;
896 }
897 GeneratedField::CommitResponse => {
898 if msg__.is_some() {
899 return Err(serde::de::Error::duplicate_field("commitResponse"));
900 }
901 msg__ = map_.next_value::<::std::option::Option<_>>()?.map(coordinate_response::Msg::CommitResponse)
902;
903 }
904 GeneratedField::Stopped => {
905 if msg__.is_some() {
906 return Err(serde::de::Error::duplicate_field("stopped"));
907 }
908 msg__ = map_.next_value::<::std::option::Option<_>>()?.map(coordinate_response::Msg::Stopped);
909 }
910 GeneratedField::AlignInitialEpochResponse => {
911 if msg__.is_some() {
912 return Err(serde::de::Error::duplicate_field("alignInitialEpochResponse"));
913 }
914 msg__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| coordinate_response::Msg::AlignInitialEpochResponse(x.0));
915 }
916 }
917 }
918 Ok(CoordinateResponse {
919 msg: msg__,
920 })
921 }
922 }
923 deserializer.deserialize_struct("connector_service.CoordinateResponse", FIELDS, GeneratedVisitor)
924 }
925}
926impl serde::Serialize for coordinate_response::CommitResponse {
927 #[allow(deprecated)]
928 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
929 where
930 S: serde::Serializer,
931 {
932 use serde::ser::SerializeStruct;
933 let mut len = 0;
934 if self.epoch != 0 {
935 len += 1;
936 }
937 let mut struct_ser = serializer.serialize_struct("connector_service.CoordinateResponse.CommitResponse", len)?;
938 if self.epoch != 0 {
939 #[allow(clippy::needless_borrow)]
940 #[allow(clippy::needless_borrows_for_generic_args)]
941 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
942 }
943 struct_ser.end()
944 }
945}
946impl<'de> serde::Deserialize<'de> for coordinate_response::CommitResponse {
947 #[allow(deprecated)]
948 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
949 where
950 D: serde::Deserializer<'de>,
951 {
952 const FIELDS: &[&str] = &[
953 "epoch",
954 ];
955
956 #[allow(clippy::enum_variant_names)]
957 enum GeneratedField {
958 Epoch,
959 }
960 impl<'de> serde::Deserialize<'de> for GeneratedField {
961 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
962 where
963 D: serde::Deserializer<'de>,
964 {
965 struct GeneratedVisitor;
966
967 impl serde::de::Visitor<'_> for GeneratedVisitor {
968 type Value = GeneratedField;
969
970 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
971 write!(formatter, "expected one of: {:?}", &FIELDS)
972 }
973
974 #[allow(unused_variables)]
975 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
976 where
977 E: serde::de::Error,
978 {
979 match value {
980 "epoch" => Ok(GeneratedField::Epoch),
981 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
982 }
983 }
984 }
985 deserializer.deserialize_identifier(GeneratedVisitor)
986 }
987 }
988 struct GeneratedVisitor;
989 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
990 type Value = coordinate_response::CommitResponse;
991
992 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
993 formatter.write_str("struct connector_service.CoordinateResponse.CommitResponse")
994 }
995
996 fn visit_map<V>(self, mut map_: V) -> std::result::Result<coordinate_response::CommitResponse, V::Error>
997 where
998 V: serde::de::MapAccess<'de>,
999 {
1000 let mut epoch__ = None;
1001 while let Some(k) = map_.next_key()? {
1002 match k {
1003 GeneratedField::Epoch => {
1004 if epoch__.is_some() {
1005 return Err(serde::de::Error::duplicate_field("epoch"));
1006 }
1007 epoch__ =
1008 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1009 ;
1010 }
1011 }
1012 }
1013 Ok(coordinate_response::CommitResponse {
1014 epoch: epoch__.unwrap_or_default(),
1015 })
1016 }
1017 }
1018 deserializer.deserialize_struct("connector_service.CoordinateResponse.CommitResponse", FIELDS, GeneratedVisitor)
1019 }
1020}
1021impl serde::Serialize for coordinate_response::StartCoordinationResponse {
1022 #[allow(deprecated)]
1023 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1024 where
1025 S: serde::Serializer,
1026 {
1027 use serde::ser::SerializeStruct;
1028 let mut len = 0;
1029 if self.log_store_rewind_start_epoch.is_some() {
1030 len += 1;
1031 }
1032 let mut struct_ser = serializer.serialize_struct("connector_service.CoordinateResponse.StartCoordinationResponse", len)?;
1033 if let Some(v) = self.log_store_rewind_start_epoch.as_ref() {
1034 #[allow(clippy::needless_borrow)]
1035 #[allow(clippy::needless_borrows_for_generic_args)]
1036 struct_ser.serialize_field("logStoreRewindStartEpoch", ToString::to_string(&v).as_str())?;
1037 }
1038 struct_ser.end()
1039 }
1040}
1041impl<'de> serde::Deserialize<'de> for coordinate_response::StartCoordinationResponse {
1042 #[allow(deprecated)]
1043 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1044 where
1045 D: serde::Deserializer<'de>,
1046 {
1047 const FIELDS: &[&str] = &[
1048 "log_store_rewind_start_epoch",
1049 "logStoreRewindStartEpoch",
1050 ];
1051
1052 #[allow(clippy::enum_variant_names)]
1053 enum GeneratedField {
1054 LogStoreRewindStartEpoch,
1055 }
1056 impl<'de> serde::Deserialize<'de> for GeneratedField {
1057 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1058 where
1059 D: serde::Deserializer<'de>,
1060 {
1061 struct GeneratedVisitor;
1062
1063 impl serde::de::Visitor<'_> for GeneratedVisitor {
1064 type Value = GeneratedField;
1065
1066 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1067 write!(formatter, "expected one of: {:?}", &FIELDS)
1068 }
1069
1070 #[allow(unused_variables)]
1071 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1072 where
1073 E: serde::de::Error,
1074 {
1075 match value {
1076 "logStoreRewindStartEpoch" | "log_store_rewind_start_epoch" => Ok(GeneratedField::LogStoreRewindStartEpoch),
1077 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1078 }
1079 }
1080 }
1081 deserializer.deserialize_identifier(GeneratedVisitor)
1082 }
1083 }
1084 struct GeneratedVisitor;
1085 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1086 type Value = coordinate_response::StartCoordinationResponse;
1087
1088 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1089 formatter.write_str("struct connector_service.CoordinateResponse.StartCoordinationResponse")
1090 }
1091
1092 fn visit_map<V>(self, mut map_: V) -> std::result::Result<coordinate_response::StartCoordinationResponse, V::Error>
1093 where
1094 V: serde::de::MapAccess<'de>,
1095 {
1096 let mut log_store_rewind_start_epoch__ = None;
1097 while let Some(k) = map_.next_key()? {
1098 match k {
1099 GeneratedField::LogStoreRewindStartEpoch => {
1100 if log_store_rewind_start_epoch__.is_some() {
1101 return Err(serde::de::Error::duplicate_field("logStoreRewindStartEpoch"));
1102 }
1103 log_store_rewind_start_epoch__ =
1104 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1105 ;
1106 }
1107 }
1108 }
1109 Ok(coordinate_response::StartCoordinationResponse {
1110 log_store_rewind_start_epoch: log_store_rewind_start_epoch__,
1111 })
1112 }
1113 }
1114 deserializer.deserialize_struct("connector_service.CoordinateResponse.StartCoordinationResponse", FIELDS, GeneratedVisitor)
1115 }
1116}
1117impl serde::Serialize for GetEventStreamRequest {
1118 #[allow(deprecated)]
1119 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1120 where
1121 S: serde::Serializer,
1122 {
1123 use serde::ser::SerializeStruct;
1124 let mut len = 0;
1125 if self.source_id != 0 {
1126 len += 1;
1127 }
1128 if self.source_type != 0 {
1129 len += 1;
1130 }
1131 if !self.start_offset.is_empty() {
1132 len += 1;
1133 }
1134 if !self.properties.is_empty() {
1135 len += 1;
1136 }
1137 if self.snapshot_done {
1138 len += 1;
1139 }
1140 if self.is_source_job {
1141 len += 1;
1142 }
1143 let mut struct_ser = serializer.serialize_struct("connector_service.GetEventStreamRequest", len)?;
1144 if self.source_id != 0 {
1145 #[allow(clippy::needless_borrow)]
1146 #[allow(clippy::needless_borrows_for_generic_args)]
1147 struct_ser.serialize_field("sourceId", ToString::to_string(&self.source_id).as_str())?;
1148 }
1149 if self.source_type != 0 {
1150 let v = SourceType::try_from(self.source_type)
1151 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.source_type)))?;
1152 struct_ser.serialize_field("sourceType", &v)?;
1153 }
1154 if !self.start_offset.is_empty() {
1155 struct_ser.serialize_field("startOffset", &self.start_offset)?;
1156 }
1157 if !self.properties.is_empty() {
1158 struct_ser.serialize_field("properties", &self.properties)?;
1159 }
1160 if self.snapshot_done {
1161 struct_ser.serialize_field("snapshotDone", &self.snapshot_done)?;
1162 }
1163 if self.is_source_job {
1164 struct_ser.serialize_field("isSourceJob", &self.is_source_job)?;
1165 }
1166 struct_ser.end()
1167 }
1168}
1169impl<'de> serde::Deserialize<'de> for GetEventStreamRequest {
1170 #[allow(deprecated)]
1171 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1172 where
1173 D: serde::Deserializer<'de>,
1174 {
1175 const FIELDS: &[&str] = &[
1176 "source_id",
1177 "sourceId",
1178 "source_type",
1179 "sourceType",
1180 "start_offset",
1181 "startOffset",
1182 "properties",
1183 "snapshot_done",
1184 "snapshotDone",
1185 "is_source_job",
1186 "isSourceJob",
1187 ];
1188
1189 #[allow(clippy::enum_variant_names)]
1190 enum GeneratedField {
1191 SourceId,
1192 SourceType,
1193 StartOffset,
1194 Properties,
1195 SnapshotDone,
1196 IsSourceJob,
1197 }
1198 impl<'de> serde::Deserialize<'de> for GeneratedField {
1199 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1200 where
1201 D: serde::Deserializer<'de>,
1202 {
1203 struct GeneratedVisitor;
1204
1205 impl serde::de::Visitor<'_> for GeneratedVisitor {
1206 type Value = GeneratedField;
1207
1208 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1209 write!(formatter, "expected one of: {:?}", &FIELDS)
1210 }
1211
1212 #[allow(unused_variables)]
1213 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1214 where
1215 E: serde::de::Error,
1216 {
1217 match value {
1218 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1219 "sourceType" | "source_type" => Ok(GeneratedField::SourceType),
1220 "startOffset" | "start_offset" => Ok(GeneratedField::StartOffset),
1221 "properties" => Ok(GeneratedField::Properties),
1222 "snapshotDone" | "snapshot_done" => Ok(GeneratedField::SnapshotDone),
1223 "isSourceJob" | "is_source_job" => Ok(GeneratedField::IsSourceJob),
1224 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1225 }
1226 }
1227 }
1228 deserializer.deserialize_identifier(GeneratedVisitor)
1229 }
1230 }
1231 struct GeneratedVisitor;
1232 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1233 type Value = GetEventStreamRequest;
1234
1235 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1236 formatter.write_str("struct connector_service.GetEventStreamRequest")
1237 }
1238
1239 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetEventStreamRequest, V::Error>
1240 where
1241 V: serde::de::MapAccess<'de>,
1242 {
1243 let mut source_id__ = None;
1244 let mut source_type__ = None;
1245 let mut start_offset__ = None;
1246 let mut properties__ = None;
1247 let mut snapshot_done__ = None;
1248 let mut is_source_job__ = None;
1249 while let Some(k) = map_.next_key()? {
1250 match k {
1251 GeneratedField::SourceId => {
1252 if source_id__.is_some() {
1253 return Err(serde::de::Error::duplicate_field("sourceId"));
1254 }
1255 source_id__ =
1256 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1257 ;
1258 }
1259 GeneratedField::SourceType => {
1260 if source_type__.is_some() {
1261 return Err(serde::de::Error::duplicate_field("sourceType"));
1262 }
1263 source_type__ = Some(map_.next_value::<SourceType>()? as i32);
1264 }
1265 GeneratedField::StartOffset => {
1266 if start_offset__.is_some() {
1267 return Err(serde::de::Error::duplicate_field("startOffset"));
1268 }
1269 start_offset__ = Some(map_.next_value()?);
1270 }
1271 GeneratedField::Properties => {
1272 if properties__.is_some() {
1273 return Err(serde::de::Error::duplicate_field("properties"));
1274 }
1275 properties__ = Some(
1276 map_.next_value::<std::collections::BTreeMap<_, _>>()?
1277 );
1278 }
1279 GeneratedField::SnapshotDone => {
1280 if snapshot_done__.is_some() {
1281 return Err(serde::de::Error::duplicate_field("snapshotDone"));
1282 }
1283 snapshot_done__ = Some(map_.next_value()?);
1284 }
1285 GeneratedField::IsSourceJob => {
1286 if is_source_job__.is_some() {
1287 return Err(serde::de::Error::duplicate_field("isSourceJob"));
1288 }
1289 is_source_job__ = Some(map_.next_value()?);
1290 }
1291 }
1292 }
1293 Ok(GetEventStreamRequest {
1294 source_id: source_id__.unwrap_or_default(),
1295 source_type: source_type__.unwrap_or_default(),
1296 start_offset: start_offset__.unwrap_or_default(),
1297 properties: properties__.unwrap_or_default(),
1298 snapshot_done: snapshot_done__.unwrap_or_default(),
1299 is_source_job: is_source_job__.unwrap_or_default(),
1300 })
1301 }
1302 }
1303 deserializer.deserialize_struct("connector_service.GetEventStreamRequest", FIELDS, GeneratedVisitor)
1304 }
1305}
1306impl serde::Serialize for GetEventStreamResponse {
1307 #[allow(deprecated)]
1308 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1309 where
1310 S: serde::Serializer,
1311 {
1312 use serde::ser::SerializeStruct;
1313 let mut len = 0;
1314 if self.source_id != 0 {
1315 len += 1;
1316 }
1317 if !self.events.is_empty() {
1318 len += 1;
1319 }
1320 if self.control.is_some() {
1321 len += 1;
1322 }
1323 let mut struct_ser = serializer.serialize_struct("connector_service.GetEventStreamResponse", len)?;
1324 if self.source_id != 0 {
1325 #[allow(clippy::needless_borrow)]
1326 #[allow(clippy::needless_borrows_for_generic_args)]
1327 struct_ser.serialize_field("sourceId", ToString::to_string(&self.source_id).as_str())?;
1328 }
1329 if !self.events.is_empty() {
1330 struct_ser.serialize_field("events", &self.events)?;
1331 }
1332 if let Some(v) = self.control.as_ref() {
1333 struct_ser.serialize_field("control", v)?;
1334 }
1335 struct_ser.end()
1336 }
1337}
1338impl<'de> serde::Deserialize<'de> for GetEventStreamResponse {
1339 #[allow(deprecated)]
1340 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1341 where
1342 D: serde::Deserializer<'de>,
1343 {
1344 const FIELDS: &[&str] = &[
1345 "source_id",
1346 "sourceId",
1347 "events",
1348 "control",
1349 ];
1350
1351 #[allow(clippy::enum_variant_names)]
1352 enum GeneratedField {
1353 SourceId,
1354 Events,
1355 Control,
1356 }
1357 impl<'de> serde::Deserialize<'de> for GeneratedField {
1358 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1359 where
1360 D: serde::Deserializer<'de>,
1361 {
1362 struct GeneratedVisitor;
1363
1364 impl serde::de::Visitor<'_> for GeneratedVisitor {
1365 type Value = GeneratedField;
1366
1367 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1368 write!(formatter, "expected one of: {:?}", &FIELDS)
1369 }
1370
1371 #[allow(unused_variables)]
1372 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1373 where
1374 E: serde::de::Error,
1375 {
1376 match value {
1377 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1378 "events" => Ok(GeneratedField::Events),
1379 "control" => Ok(GeneratedField::Control),
1380 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1381 }
1382 }
1383 }
1384 deserializer.deserialize_identifier(GeneratedVisitor)
1385 }
1386 }
1387 struct GeneratedVisitor;
1388 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1389 type Value = GetEventStreamResponse;
1390
1391 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1392 formatter.write_str("struct connector_service.GetEventStreamResponse")
1393 }
1394
1395 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetEventStreamResponse, V::Error>
1396 where
1397 V: serde::de::MapAccess<'de>,
1398 {
1399 let mut source_id__ = None;
1400 let mut events__ = None;
1401 let mut control__ = None;
1402 while let Some(k) = map_.next_key()? {
1403 match k {
1404 GeneratedField::SourceId => {
1405 if source_id__.is_some() {
1406 return Err(serde::de::Error::duplicate_field("sourceId"));
1407 }
1408 source_id__ =
1409 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1410 ;
1411 }
1412 GeneratedField::Events => {
1413 if events__.is_some() {
1414 return Err(serde::de::Error::duplicate_field("events"));
1415 }
1416 events__ = Some(map_.next_value()?);
1417 }
1418 GeneratedField::Control => {
1419 if control__.is_some() {
1420 return Err(serde::de::Error::duplicate_field("control"));
1421 }
1422 control__ = map_.next_value()?;
1423 }
1424 }
1425 }
1426 Ok(GetEventStreamResponse {
1427 source_id: source_id__.unwrap_or_default(),
1428 events: events__.unwrap_or_default(),
1429 control: control__,
1430 })
1431 }
1432 }
1433 deserializer.deserialize_struct("connector_service.GetEventStreamResponse", FIELDS, GeneratedVisitor)
1434 }
1435}
1436impl serde::Serialize for get_event_stream_response::ControlInfo {
1437 #[allow(deprecated)]
1438 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1439 where
1440 S: serde::Serializer,
1441 {
1442 use serde::ser::SerializeStruct;
1443 let mut len = 0;
1444 if self.handshake_ok {
1445 len += 1;
1446 }
1447 let mut struct_ser = serializer.serialize_struct("connector_service.GetEventStreamResponse.ControlInfo", len)?;
1448 if self.handshake_ok {
1449 struct_ser.serialize_field("handshakeOk", &self.handshake_ok)?;
1450 }
1451 struct_ser.end()
1452 }
1453}
1454impl<'de> serde::Deserialize<'de> for get_event_stream_response::ControlInfo {
1455 #[allow(deprecated)]
1456 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1457 where
1458 D: serde::Deserializer<'de>,
1459 {
1460 const FIELDS: &[&str] = &[
1461 "handshake_ok",
1462 "handshakeOk",
1463 ];
1464
1465 #[allow(clippy::enum_variant_names)]
1466 enum GeneratedField {
1467 HandshakeOk,
1468 }
1469 impl<'de> serde::Deserialize<'de> for GeneratedField {
1470 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1471 where
1472 D: serde::Deserializer<'de>,
1473 {
1474 struct GeneratedVisitor;
1475
1476 impl serde::de::Visitor<'_> for GeneratedVisitor {
1477 type Value = GeneratedField;
1478
1479 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1480 write!(formatter, "expected one of: {:?}", &FIELDS)
1481 }
1482
1483 #[allow(unused_variables)]
1484 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1485 where
1486 E: serde::de::Error,
1487 {
1488 match value {
1489 "handshakeOk" | "handshake_ok" => Ok(GeneratedField::HandshakeOk),
1490 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1491 }
1492 }
1493 }
1494 deserializer.deserialize_identifier(GeneratedVisitor)
1495 }
1496 }
1497 struct GeneratedVisitor;
1498 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1499 type Value = get_event_stream_response::ControlInfo;
1500
1501 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1502 formatter.write_str("struct connector_service.GetEventStreamResponse.ControlInfo")
1503 }
1504
1505 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_event_stream_response::ControlInfo, V::Error>
1506 where
1507 V: serde::de::MapAccess<'de>,
1508 {
1509 let mut handshake_ok__ = None;
1510 while let Some(k) = map_.next_key()? {
1511 match k {
1512 GeneratedField::HandshakeOk => {
1513 if handshake_ok__.is_some() {
1514 return Err(serde::de::Error::duplicate_field("handshakeOk"));
1515 }
1516 handshake_ok__ = Some(map_.next_value()?);
1517 }
1518 }
1519 }
1520 Ok(get_event_stream_response::ControlInfo {
1521 handshake_ok: handshake_ok__.unwrap_or_default(),
1522 })
1523 }
1524 }
1525 deserializer.deserialize_struct("connector_service.GetEventStreamResponse.ControlInfo", FIELDS, GeneratedVisitor)
1526 }
1527}
1528impl serde::Serialize for SinkCoordinatorStreamRequest {
1529 #[allow(deprecated)]
1530 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1531 where
1532 S: serde::Serializer,
1533 {
1534 use serde::ser::SerializeStruct;
1535 let mut len = 0;
1536 if self.request.is_some() {
1537 len += 1;
1538 }
1539 let mut struct_ser = serializer.serialize_struct("connector_service.SinkCoordinatorStreamRequest", len)?;
1540 if let Some(v) = self.request.as_ref() {
1541 match v {
1542 sink_coordinator_stream_request::Request::Start(v) => {
1543 struct_ser.serialize_field("start", v)?;
1544 }
1545 sink_coordinator_stream_request::Request::Commit(v) => {
1546 struct_ser.serialize_field("commit", v)?;
1547 }
1548 }
1549 }
1550 struct_ser.end()
1551 }
1552}
1553impl<'de> serde::Deserialize<'de> for SinkCoordinatorStreamRequest {
1554 #[allow(deprecated)]
1555 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1556 where
1557 D: serde::Deserializer<'de>,
1558 {
1559 const FIELDS: &[&str] = &[
1560 "start",
1561 "commit",
1562 ];
1563
1564 #[allow(clippy::enum_variant_names)]
1565 enum GeneratedField {
1566 Start,
1567 Commit,
1568 }
1569 impl<'de> serde::Deserialize<'de> for GeneratedField {
1570 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1571 where
1572 D: serde::Deserializer<'de>,
1573 {
1574 struct GeneratedVisitor;
1575
1576 impl serde::de::Visitor<'_> for GeneratedVisitor {
1577 type Value = GeneratedField;
1578
1579 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1580 write!(formatter, "expected one of: {:?}", &FIELDS)
1581 }
1582
1583 #[allow(unused_variables)]
1584 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1585 where
1586 E: serde::de::Error,
1587 {
1588 match value {
1589 "start" => Ok(GeneratedField::Start),
1590 "commit" => Ok(GeneratedField::Commit),
1591 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1592 }
1593 }
1594 }
1595 deserializer.deserialize_identifier(GeneratedVisitor)
1596 }
1597 }
1598 struct GeneratedVisitor;
1599 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1600 type Value = SinkCoordinatorStreamRequest;
1601
1602 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1603 formatter.write_str("struct connector_service.SinkCoordinatorStreamRequest")
1604 }
1605
1606 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkCoordinatorStreamRequest, V::Error>
1607 where
1608 V: serde::de::MapAccess<'de>,
1609 {
1610 let mut request__ = None;
1611 while let Some(k) = map_.next_key()? {
1612 match k {
1613 GeneratedField::Start => {
1614 if request__.is_some() {
1615 return Err(serde::de::Error::duplicate_field("start"));
1616 }
1617 request__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_coordinator_stream_request::Request::Start)
1618;
1619 }
1620 GeneratedField::Commit => {
1621 if request__.is_some() {
1622 return Err(serde::de::Error::duplicate_field("commit"));
1623 }
1624 request__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_coordinator_stream_request::Request::Commit)
1625;
1626 }
1627 }
1628 }
1629 Ok(SinkCoordinatorStreamRequest {
1630 request: request__,
1631 })
1632 }
1633 }
1634 deserializer.deserialize_struct("connector_service.SinkCoordinatorStreamRequest", FIELDS, GeneratedVisitor)
1635 }
1636}
1637impl serde::Serialize for sink_coordinator_stream_request::CommitMetadata {
1638 #[allow(deprecated)]
1639 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1640 where
1641 S: serde::Serializer,
1642 {
1643 use serde::ser::SerializeStruct;
1644 let mut len = 0;
1645 if self.epoch != 0 {
1646 len += 1;
1647 }
1648 if !self.metadata.is_empty() {
1649 len += 1;
1650 }
1651 let mut struct_ser = serializer.serialize_struct("connector_service.SinkCoordinatorStreamRequest.CommitMetadata", len)?;
1652 if self.epoch != 0 {
1653 #[allow(clippy::needless_borrow)]
1654 #[allow(clippy::needless_borrows_for_generic_args)]
1655 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
1656 }
1657 if !self.metadata.is_empty() {
1658 struct_ser.serialize_field("metadata", &self.metadata)?;
1659 }
1660 struct_ser.end()
1661 }
1662}
1663impl<'de> serde::Deserialize<'de> for sink_coordinator_stream_request::CommitMetadata {
1664 #[allow(deprecated)]
1665 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1666 where
1667 D: serde::Deserializer<'de>,
1668 {
1669 const FIELDS: &[&str] = &[
1670 "epoch",
1671 "metadata",
1672 ];
1673
1674 #[allow(clippy::enum_variant_names)]
1675 enum GeneratedField {
1676 Epoch,
1677 Metadata,
1678 }
1679 impl<'de> serde::Deserialize<'de> for GeneratedField {
1680 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1681 where
1682 D: serde::Deserializer<'de>,
1683 {
1684 struct GeneratedVisitor;
1685
1686 impl serde::de::Visitor<'_> for GeneratedVisitor {
1687 type Value = GeneratedField;
1688
1689 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1690 write!(formatter, "expected one of: {:?}", &FIELDS)
1691 }
1692
1693 #[allow(unused_variables)]
1694 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1695 where
1696 E: serde::de::Error,
1697 {
1698 match value {
1699 "epoch" => Ok(GeneratedField::Epoch),
1700 "metadata" => Ok(GeneratedField::Metadata),
1701 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1702 }
1703 }
1704 }
1705 deserializer.deserialize_identifier(GeneratedVisitor)
1706 }
1707 }
1708 struct GeneratedVisitor;
1709 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1710 type Value = sink_coordinator_stream_request::CommitMetadata;
1711
1712 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1713 formatter.write_str("struct connector_service.SinkCoordinatorStreamRequest.CommitMetadata")
1714 }
1715
1716 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_coordinator_stream_request::CommitMetadata, V::Error>
1717 where
1718 V: serde::de::MapAccess<'de>,
1719 {
1720 let mut epoch__ = None;
1721 let mut metadata__ = None;
1722 while let Some(k) = map_.next_key()? {
1723 match k {
1724 GeneratedField::Epoch => {
1725 if epoch__.is_some() {
1726 return Err(serde::de::Error::duplicate_field("epoch"));
1727 }
1728 epoch__ =
1729 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1730 ;
1731 }
1732 GeneratedField::Metadata => {
1733 if metadata__.is_some() {
1734 return Err(serde::de::Error::duplicate_field("metadata"));
1735 }
1736 metadata__ = Some(map_.next_value()?);
1737 }
1738 }
1739 }
1740 Ok(sink_coordinator_stream_request::CommitMetadata {
1741 epoch: epoch__.unwrap_or_default(),
1742 metadata: metadata__.unwrap_or_default(),
1743 })
1744 }
1745 }
1746 deserializer.deserialize_struct("connector_service.SinkCoordinatorStreamRequest.CommitMetadata", FIELDS, GeneratedVisitor)
1747 }
1748}
1749impl serde::Serialize for sink_coordinator_stream_request::StartCoordinator {
1750 #[allow(deprecated)]
1751 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1752 where
1753 S: serde::Serializer,
1754 {
1755 use serde::ser::SerializeStruct;
1756 let mut len = 0;
1757 if self.param.is_some() {
1758 len += 1;
1759 }
1760 let mut struct_ser = serializer.serialize_struct("connector_service.SinkCoordinatorStreamRequest.StartCoordinator", len)?;
1761 if let Some(v) = self.param.as_ref() {
1762 struct_ser.serialize_field("param", v)?;
1763 }
1764 struct_ser.end()
1765 }
1766}
1767impl<'de> serde::Deserialize<'de> for sink_coordinator_stream_request::StartCoordinator {
1768 #[allow(deprecated)]
1769 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1770 where
1771 D: serde::Deserializer<'de>,
1772 {
1773 const FIELDS: &[&str] = &[
1774 "param",
1775 ];
1776
1777 #[allow(clippy::enum_variant_names)]
1778 enum GeneratedField {
1779 Param,
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 serde::de::Visitor<'_> 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 match value {
1801 "param" => Ok(GeneratedField::Param),
1802 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1803 }
1804 }
1805 }
1806 deserializer.deserialize_identifier(GeneratedVisitor)
1807 }
1808 }
1809 struct GeneratedVisitor;
1810 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1811 type Value = sink_coordinator_stream_request::StartCoordinator;
1812
1813 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1814 formatter.write_str("struct connector_service.SinkCoordinatorStreamRequest.StartCoordinator")
1815 }
1816
1817 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_coordinator_stream_request::StartCoordinator, V::Error>
1818 where
1819 V: serde::de::MapAccess<'de>,
1820 {
1821 let mut param__ = None;
1822 while let Some(k) = map_.next_key()? {
1823 match k {
1824 GeneratedField::Param => {
1825 if param__.is_some() {
1826 return Err(serde::de::Error::duplicate_field("param"));
1827 }
1828 param__ = map_.next_value()?;
1829 }
1830 }
1831 }
1832 Ok(sink_coordinator_stream_request::StartCoordinator {
1833 param: param__,
1834 })
1835 }
1836 }
1837 deserializer.deserialize_struct("connector_service.SinkCoordinatorStreamRequest.StartCoordinator", FIELDS, GeneratedVisitor)
1838 }
1839}
1840impl serde::Serialize for SinkCoordinatorStreamResponse {
1841 #[allow(deprecated)]
1842 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1843 where
1844 S: serde::Serializer,
1845 {
1846 use serde::ser::SerializeStruct;
1847 let mut len = 0;
1848 if self.response.is_some() {
1849 len += 1;
1850 }
1851 let mut struct_ser = serializer.serialize_struct("connector_service.SinkCoordinatorStreamResponse", len)?;
1852 if let Some(v) = self.response.as_ref() {
1853 match v {
1854 sink_coordinator_stream_response::Response::Start(v) => {
1855 struct_ser.serialize_field("start", v)?;
1856 }
1857 sink_coordinator_stream_response::Response::Commit(v) => {
1858 struct_ser.serialize_field("commit", v)?;
1859 }
1860 }
1861 }
1862 struct_ser.end()
1863 }
1864}
1865impl<'de> serde::Deserialize<'de> for SinkCoordinatorStreamResponse {
1866 #[allow(deprecated)]
1867 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1868 where
1869 D: serde::Deserializer<'de>,
1870 {
1871 const FIELDS: &[&str] = &[
1872 "start",
1873 "commit",
1874 ];
1875
1876 #[allow(clippy::enum_variant_names)]
1877 enum GeneratedField {
1878 Start,
1879 Commit,
1880 }
1881 impl<'de> serde::Deserialize<'de> for GeneratedField {
1882 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1883 where
1884 D: serde::Deserializer<'de>,
1885 {
1886 struct GeneratedVisitor;
1887
1888 impl serde::de::Visitor<'_> for GeneratedVisitor {
1889 type Value = GeneratedField;
1890
1891 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1892 write!(formatter, "expected one of: {:?}", &FIELDS)
1893 }
1894
1895 #[allow(unused_variables)]
1896 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1897 where
1898 E: serde::de::Error,
1899 {
1900 match value {
1901 "start" => Ok(GeneratedField::Start),
1902 "commit" => Ok(GeneratedField::Commit),
1903 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1904 }
1905 }
1906 }
1907 deserializer.deserialize_identifier(GeneratedVisitor)
1908 }
1909 }
1910 struct GeneratedVisitor;
1911 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1912 type Value = SinkCoordinatorStreamResponse;
1913
1914 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1915 formatter.write_str("struct connector_service.SinkCoordinatorStreamResponse")
1916 }
1917
1918 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkCoordinatorStreamResponse, V::Error>
1919 where
1920 V: serde::de::MapAccess<'de>,
1921 {
1922 let mut response__ = None;
1923 while let Some(k) = map_.next_key()? {
1924 match k {
1925 GeneratedField::Start => {
1926 if response__.is_some() {
1927 return Err(serde::de::Error::duplicate_field("start"));
1928 }
1929 response__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_coordinator_stream_response::Response::Start)
1930;
1931 }
1932 GeneratedField::Commit => {
1933 if response__.is_some() {
1934 return Err(serde::de::Error::duplicate_field("commit"));
1935 }
1936 response__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_coordinator_stream_response::Response::Commit)
1937;
1938 }
1939 }
1940 }
1941 Ok(SinkCoordinatorStreamResponse {
1942 response: response__,
1943 })
1944 }
1945 }
1946 deserializer.deserialize_struct("connector_service.SinkCoordinatorStreamResponse", FIELDS, GeneratedVisitor)
1947 }
1948}
1949impl serde::Serialize for sink_coordinator_stream_response::CommitResponse {
1950 #[allow(deprecated)]
1951 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1952 where
1953 S: serde::Serializer,
1954 {
1955 use serde::ser::SerializeStruct;
1956 let mut len = 0;
1957 if self.epoch != 0 {
1958 len += 1;
1959 }
1960 let mut struct_ser = serializer.serialize_struct("connector_service.SinkCoordinatorStreamResponse.CommitResponse", len)?;
1961 if self.epoch != 0 {
1962 #[allow(clippy::needless_borrow)]
1963 #[allow(clippy::needless_borrows_for_generic_args)]
1964 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
1965 }
1966 struct_ser.end()
1967 }
1968}
1969impl<'de> serde::Deserialize<'de> for sink_coordinator_stream_response::CommitResponse {
1970 #[allow(deprecated)]
1971 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1972 where
1973 D: serde::Deserializer<'de>,
1974 {
1975 const FIELDS: &[&str] = &[
1976 "epoch",
1977 ];
1978
1979 #[allow(clippy::enum_variant_names)]
1980 enum GeneratedField {
1981 Epoch,
1982 }
1983 impl<'de> serde::Deserialize<'de> for GeneratedField {
1984 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1985 where
1986 D: serde::Deserializer<'de>,
1987 {
1988 struct GeneratedVisitor;
1989
1990 impl serde::de::Visitor<'_> for GeneratedVisitor {
1991 type Value = GeneratedField;
1992
1993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1994 write!(formatter, "expected one of: {:?}", &FIELDS)
1995 }
1996
1997 #[allow(unused_variables)]
1998 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1999 where
2000 E: serde::de::Error,
2001 {
2002 match value {
2003 "epoch" => Ok(GeneratedField::Epoch),
2004 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2005 }
2006 }
2007 }
2008 deserializer.deserialize_identifier(GeneratedVisitor)
2009 }
2010 }
2011 struct GeneratedVisitor;
2012 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2013 type Value = sink_coordinator_stream_response::CommitResponse;
2014
2015 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2016 formatter.write_str("struct connector_service.SinkCoordinatorStreamResponse.CommitResponse")
2017 }
2018
2019 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_coordinator_stream_response::CommitResponse, V::Error>
2020 where
2021 V: serde::de::MapAccess<'de>,
2022 {
2023 let mut epoch__ = None;
2024 while let Some(k) = map_.next_key()? {
2025 match k {
2026 GeneratedField::Epoch => {
2027 if epoch__.is_some() {
2028 return Err(serde::de::Error::duplicate_field("epoch"));
2029 }
2030 epoch__ =
2031 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2032 ;
2033 }
2034 }
2035 }
2036 Ok(sink_coordinator_stream_response::CommitResponse {
2037 epoch: epoch__.unwrap_or_default(),
2038 })
2039 }
2040 }
2041 deserializer.deserialize_struct("connector_service.SinkCoordinatorStreamResponse.CommitResponse", FIELDS, GeneratedVisitor)
2042 }
2043}
2044impl serde::Serialize for sink_coordinator_stream_response::StartResponse {
2045 #[allow(deprecated)]
2046 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2047 where
2048 S: serde::Serializer,
2049 {
2050 use serde::ser::SerializeStruct;
2051 let len = 0;
2052 let struct_ser = serializer.serialize_struct("connector_service.SinkCoordinatorStreamResponse.StartResponse", len)?;
2053 struct_ser.end()
2054 }
2055}
2056impl<'de> serde::Deserialize<'de> for sink_coordinator_stream_response::StartResponse {
2057 #[allow(deprecated)]
2058 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2059 where
2060 D: serde::Deserializer<'de>,
2061 {
2062 const FIELDS: &[&str] = &[
2063 ];
2064
2065 #[allow(clippy::enum_variant_names)]
2066 enum GeneratedField {
2067 }
2068 impl<'de> serde::Deserialize<'de> for GeneratedField {
2069 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2070 where
2071 D: serde::Deserializer<'de>,
2072 {
2073 struct GeneratedVisitor;
2074
2075 impl serde::de::Visitor<'_> for GeneratedVisitor {
2076 type Value = GeneratedField;
2077
2078 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2079 write!(formatter, "expected one of: {:?}", &FIELDS)
2080 }
2081
2082 #[allow(unused_variables)]
2083 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2084 where
2085 E: serde::de::Error,
2086 {
2087 Err(serde::de::Error::unknown_field(value, FIELDS))
2088 }
2089 }
2090 deserializer.deserialize_identifier(GeneratedVisitor)
2091 }
2092 }
2093 struct GeneratedVisitor;
2094 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2095 type Value = sink_coordinator_stream_response::StartResponse;
2096
2097 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2098 formatter.write_str("struct connector_service.SinkCoordinatorStreamResponse.StartResponse")
2099 }
2100
2101 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_coordinator_stream_response::StartResponse, V::Error>
2102 where
2103 V: serde::de::MapAccess<'de>,
2104 {
2105 while map_.next_key::<GeneratedField>()?.is_some() {
2106 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2107 }
2108 Ok(sink_coordinator_stream_response::StartResponse {
2109 })
2110 }
2111 }
2112 deserializer.deserialize_struct("connector_service.SinkCoordinatorStreamResponse.StartResponse", FIELDS, GeneratedVisitor)
2113 }
2114}
2115impl serde::Serialize for SinkMetadata {
2116 #[allow(deprecated)]
2117 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2118 where
2119 S: serde::Serializer,
2120 {
2121 use serde::ser::SerializeStruct;
2122 let mut len = 0;
2123 if self.metadata.is_some() {
2124 len += 1;
2125 }
2126 let mut struct_ser = serializer.serialize_struct("connector_service.SinkMetadata", len)?;
2127 if let Some(v) = self.metadata.as_ref() {
2128 match v {
2129 sink_metadata::Metadata::Serialized(v) => {
2130 struct_ser.serialize_field("serialized", v)?;
2131 }
2132 }
2133 }
2134 struct_ser.end()
2135 }
2136}
2137impl<'de> serde::Deserialize<'de> for SinkMetadata {
2138 #[allow(deprecated)]
2139 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2140 where
2141 D: serde::Deserializer<'de>,
2142 {
2143 const FIELDS: &[&str] = &[
2144 "serialized",
2145 ];
2146
2147 #[allow(clippy::enum_variant_names)]
2148 enum GeneratedField {
2149 Serialized,
2150 }
2151 impl<'de> serde::Deserialize<'de> for GeneratedField {
2152 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2153 where
2154 D: serde::Deserializer<'de>,
2155 {
2156 struct GeneratedVisitor;
2157
2158 impl serde::de::Visitor<'_> for GeneratedVisitor {
2159 type Value = GeneratedField;
2160
2161 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2162 write!(formatter, "expected one of: {:?}", &FIELDS)
2163 }
2164
2165 #[allow(unused_variables)]
2166 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2167 where
2168 E: serde::de::Error,
2169 {
2170 match value {
2171 "serialized" => Ok(GeneratedField::Serialized),
2172 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2173 }
2174 }
2175 }
2176 deserializer.deserialize_identifier(GeneratedVisitor)
2177 }
2178 }
2179 struct GeneratedVisitor;
2180 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2181 type Value = SinkMetadata;
2182
2183 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2184 formatter.write_str("struct connector_service.SinkMetadata")
2185 }
2186
2187 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkMetadata, V::Error>
2188 where
2189 V: serde::de::MapAccess<'de>,
2190 {
2191 let mut metadata__ = None;
2192 while let Some(k) = map_.next_key()? {
2193 match k {
2194 GeneratedField::Serialized => {
2195 if metadata__.is_some() {
2196 return Err(serde::de::Error::duplicate_field("serialized"));
2197 }
2198 metadata__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_metadata::Metadata::Serialized)
2199;
2200 }
2201 }
2202 }
2203 Ok(SinkMetadata {
2204 metadata: metadata__,
2205 })
2206 }
2207 }
2208 deserializer.deserialize_struct("connector_service.SinkMetadata", FIELDS, GeneratedVisitor)
2209 }
2210}
2211impl serde::Serialize for sink_metadata::SerializedMetadata {
2212 #[allow(deprecated)]
2213 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2214 where
2215 S: serde::Serializer,
2216 {
2217 use serde::ser::SerializeStruct;
2218 let mut len = 0;
2219 if !self.metadata.is_empty() {
2220 len += 1;
2221 }
2222 let mut struct_ser = serializer.serialize_struct("connector_service.SinkMetadata.SerializedMetadata", len)?;
2223 if !self.metadata.is_empty() {
2224 #[allow(clippy::needless_borrow)]
2225 #[allow(clippy::needless_borrows_for_generic_args)]
2226 struct_ser.serialize_field("metadata", pbjson::private::base64::encode(&self.metadata).as_str())?;
2227 }
2228 struct_ser.end()
2229 }
2230}
2231impl<'de> serde::Deserialize<'de> for sink_metadata::SerializedMetadata {
2232 #[allow(deprecated)]
2233 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2234 where
2235 D: serde::Deserializer<'de>,
2236 {
2237 const FIELDS: &[&str] = &[
2238 "metadata",
2239 ];
2240
2241 #[allow(clippy::enum_variant_names)]
2242 enum GeneratedField {
2243 Metadata,
2244 }
2245 impl<'de> serde::Deserialize<'de> for GeneratedField {
2246 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2247 where
2248 D: serde::Deserializer<'de>,
2249 {
2250 struct GeneratedVisitor;
2251
2252 impl serde::de::Visitor<'_> for GeneratedVisitor {
2253 type Value = GeneratedField;
2254
2255 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2256 write!(formatter, "expected one of: {:?}", &FIELDS)
2257 }
2258
2259 #[allow(unused_variables)]
2260 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2261 where
2262 E: serde::de::Error,
2263 {
2264 match value {
2265 "metadata" => Ok(GeneratedField::Metadata),
2266 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2267 }
2268 }
2269 }
2270 deserializer.deserialize_identifier(GeneratedVisitor)
2271 }
2272 }
2273 struct GeneratedVisitor;
2274 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2275 type Value = sink_metadata::SerializedMetadata;
2276
2277 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2278 formatter.write_str("struct connector_service.SinkMetadata.SerializedMetadata")
2279 }
2280
2281 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_metadata::SerializedMetadata, V::Error>
2282 where
2283 V: serde::de::MapAccess<'de>,
2284 {
2285 let mut metadata__ = None;
2286 while let Some(k) = map_.next_key()? {
2287 match k {
2288 GeneratedField::Metadata => {
2289 if metadata__.is_some() {
2290 return Err(serde::de::Error::duplicate_field("metadata"));
2291 }
2292 metadata__ =
2293 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
2294 ;
2295 }
2296 }
2297 }
2298 Ok(sink_metadata::SerializedMetadata {
2299 metadata: metadata__.unwrap_or_default(),
2300 })
2301 }
2302 }
2303 deserializer.deserialize_struct("connector_service.SinkMetadata.SerializedMetadata", FIELDS, GeneratedVisitor)
2304 }
2305}
2306impl serde::Serialize for SinkParam {
2307 #[allow(deprecated)]
2308 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2309 where
2310 S: serde::Serializer,
2311 {
2312 use serde::ser::SerializeStruct;
2313 let mut len = 0;
2314 if self.sink_id != 0 {
2315 len += 1;
2316 }
2317 if !self.properties.is_empty() {
2318 len += 1;
2319 }
2320 if self.table_schema.is_some() {
2321 len += 1;
2322 }
2323 if self.sink_type != 0 {
2324 len += 1;
2325 }
2326 if !self.db_name.is_empty() {
2327 len += 1;
2328 }
2329 if !self.sink_from_name.is_empty() {
2330 len += 1;
2331 }
2332 if self.format_desc.is_some() {
2333 len += 1;
2334 }
2335 if !self.sink_name.is_empty() {
2336 len += 1;
2337 }
2338 if self.raw_ignore_delete {
2339 len += 1;
2340 }
2341 let mut struct_ser = serializer.serialize_struct("connector_service.SinkParam", len)?;
2342 if self.sink_id != 0 {
2343 struct_ser.serialize_field("sinkId", &self.sink_id)?;
2344 }
2345 if !self.properties.is_empty() {
2346 struct_ser.serialize_field("properties", &self.properties)?;
2347 }
2348 if let Some(v) = self.table_schema.as_ref() {
2349 struct_ser.serialize_field("tableSchema", v)?;
2350 }
2351 if self.sink_type != 0 {
2352 let v = super::catalog::SinkType::try_from(self.sink_type)
2353 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
2354 struct_ser.serialize_field("sinkType", &v)?;
2355 }
2356 if !self.db_name.is_empty() {
2357 struct_ser.serialize_field("dbName", &self.db_name)?;
2358 }
2359 if !self.sink_from_name.is_empty() {
2360 struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
2361 }
2362 if let Some(v) = self.format_desc.as_ref() {
2363 struct_ser.serialize_field("formatDesc", v)?;
2364 }
2365 if !self.sink_name.is_empty() {
2366 struct_ser.serialize_field("sinkName", &self.sink_name)?;
2367 }
2368 if self.raw_ignore_delete {
2369 struct_ser.serialize_field("rawIgnoreDelete", &self.raw_ignore_delete)?;
2370 }
2371 struct_ser.end()
2372 }
2373}
2374impl<'de> serde::Deserialize<'de> for SinkParam {
2375 #[allow(deprecated)]
2376 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2377 where
2378 D: serde::Deserializer<'de>,
2379 {
2380 const FIELDS: &[&str] = &[
2381 "sink_id",
2382 "sinkId",
2383 "properties",
2384 "table_schema",
2385 "tableSchema",
2386 "sink_type",
2387 "sinkType",
2388 "db_name",
2389 "dbName",
2390 "sink_from_name",
2391 "sinkFromName",
2392 "format_desc",
2393 "formatDesc",
2394 "sink_name",
2395 "sinkName",
2396 "raw_ignore_delete",
2397 "rawIgnoreDelete",
2398 ];
2399
2400 #[allow(clippy::enum_variant_names)]
2401 enum GeneratedField {
2402 SinkId,
2403 Properties,
2404 TableSchema,
2405 SinkType,
2406 DbName,
2407 SinkFromName,
2408 FormatDesc,
2409 SinkName,
2410 RawIgnoreDelete,
2411 }
2412 impl<'de> serde::Deserialize<'de> for GeneratedField {
2413 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2414 where
2415 D: serde::Deserializer<'de>,
2416 {
2417 struct GeneratedVisitor;
2418
2419 impl serde::de::Visitor<'_> for GeneratedVisitor {
2420 type Value = GeneratedField;
2421
2422 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2423 write!(formatter, "expected one of: {:?}", &FIELDS)
2424 }
2425
2426 #[allow(unused_variables)]
2427 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2428 where
2429 E: serde::de::Error,
2430 {
2431 match value {
2432 "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
2433 "properties" => Ok(GeneratedField::Properties),
2434 "tableSchema" | "table_schema" => Ok(GeneratedField::TableSchema),
2435 "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
2436 "dbName" | "db_name" => Ok(GeneratedField::DbName),
2437 "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
2438 "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
2439 "sinkName" | "sink_name" => Ok(GeneratedField::SinkName),
2440 "rawIgnoreDelete" | "raw_ignore_delete" => Ok(GeneratedField::RawIgnoreDelete),
2441 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2442 }
2443 }
2444 }
2445 deserializer.deserialize_identifier(GeneratedVisitor)
2446 }
2447 }
2448 struct GeneratedVisitor;
2449 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2450 type Value = SinkParam;
2451
2452 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2453 formatter.write_str("struct connector_service.SinkParam")
2454 }
2455
2456 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkParam, V::Error>
2457 where
2458 V: serde::de::MapAccess<'de>,
2459 {
2460 let mut sink_id__ = None;
2461 let mut properties__ = None;
2462 let mut table_schema__ = None;
2463 let mut sink_type__ = None;
2464 let mut db_name__ = None;
2465 let mut sink_from_name__ = None;
2466 let mut format_desc__ = None;
2467 let mut sink_name__ = None;
2468 let mut raw_ignore_delete__ = None;
2469 while let Some(k) = map_.next_key()? {
2470 match k {
2471 GeneratedField::SinkId => {
2472 if sink_id__.is_some() {
2473 return Err(serde::de::Error::duplicate_field("sinkId"));
2474 }
2475 sink_id__ =
2476 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2477 ;
2478 }
2479 GeneratedField::Properties => {
2480 if properties__.is_some() {
2481 return Err(serde::de::Error::duplicate_field("properties"));
2482 }
2483 properties__ = Some(
2484 map_.next_value::<std::collections::BTreeMap<_, _>>()?
2485 );
2486 }
2487 GeneratedField::TableSchema => {
2488 if table_schema__.is_some() {
2489 return Err(serde::de::Error::duplicate_field("tableSchema"));
2490 }
2491 table_schema__ = map_.next_value()?;
2492 }
2493 GeneratedField::SinkType => {
2494 if sink_type__.is_some() {
2495 return Err(serde::de::Error::duplicate_field("sinkType"));
2496 }
2497 sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
2498 }
2499 GeneratedField::DbName => {
2500 if db_name__.is_some() {
2501 return Err(serde::de::Error::duplicate_field("dbName"));
2502 }
2503 db_name__ = Some(map_.next_value()?);
2504 }
2505 GeneratedField::SinkFromName => {
2506 if sink_from_name__.is_some() {
2507 return Err(serde::de::Error::duplicate_field("sinkFromName"));
2508 }
2509 sink_from_name__ = Some(map_.next_value()?);
2510 }
2511 GeneratedField::FormatDesc => {
2512 if format_desc__.is_some() {
2513 return Err(serde::de::Error::duplicate_field("formatDesc"));
2514 }
2515 format_desc__ = map_.next_value()?;
2516 }
2517 GeneratedField::SinkName => {
2518 if sink_name__.is_some() {
2519 return Err(serde::de::Error::duplicate_field("sinkName"));
2520 }
2521 sink_name__ = Some(map_.next_value()?);
2522 }
2523 GeneratedField::RawIgnoreDelete => {
2524 if raw_ignore_delete__.is_some() {
2525 return Err(serde::de::Error::duplicate_field("rawIgnoreDelete"));
2526 }
2527 raw_ignore_delete__ = Some(map_.next_value()?);
2528 }
2529 }
2530 }
2531 Ok(SinkParam {
2532 sink_id: sink_id__.unwrap_or_default(),
2533 properties: properties__.unwrap_or_default(),
2534 table_schema: table_schema__,
2535 sink_type: sink_type__.unwrap_or_default(),
2536 db_name: db_name__.unwrap_or_default(),
2537 sink_from_name: sink_from_name__.unwrap_or_default(),
2538 format_desc: format_desc__,
2539 sink_name: sink_name__.unwrap_or_default(),
2540 raw_ignore_delete: raw_ignore_delete__.unwrap_or_default(),
2541 })
2542 }
2543 }
2544 deserializer.deserialize_struct("connector_service.SinkParam", FIELDS, GeneratedVisitor)
2545 }
2546}
2547impl serde::Serialize for SinkWriterStreamRequest {
2548 #[allow(deprecated)]
2549 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2550 where
2551 S: serde::Serializer,
2552 {
2553 use serde::ser::SerializeStruct;
2554 let mut len = 0;
2555 if self.request.is_some() {
2556 len += 1;
2557 }
2558 let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamRequest", len)?;
2559 if let Some(v) = self.request.as_ref() {
2560 match v {
2561 sink_writer_stream_request::Request::Start(v) => {
2562 struct_ser.serialize_field("start", v)?;
2563 }
2564 sink_writer_stream_request::Request::WriteBatch(v) => {
2565 struct_ser.serialize_field("writeBatch", v)?;
2566 }
2567 sink_writer_stream_request::Request::Barrier(v) => {
2568 struct_ser.serialize_field("barrier", v)?;
2569 }
2570 }
2571 }
2572 struct_ser.end()
2573 }
2574}
2575impl<'de> serde::Deserialize<'de> for SinkWriterStreamRequest {
2576 #[allow(deprecated)]
2577 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2578 where
2579 D: serde::Deserializer<'de>,
2580 {
2581 const FIELDS: &[&str] = &[
2582 "start",
2583 "write_batch",
2584 "writeBatch",
2585 "barrier",
2586 ];
2587
2588 #[allow(clippy::enum_variant_names)]
2589 enum GeneratedField {
2590 Start,
2591 WriteBatch,
2592 Barrier,
2593 }
2594 impl<'de> serde::Deserialize<'de> for GeneratedField {
2595 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2596 where
2597 D: serde::Deserializer<'de>,
2598 {
2599 struct GeneratedVisitor;
2600
2601 impl serde::de::Visitor<'_> for GeneratedVisitor {
2602 type Value = GeneratedField;
2603
2604 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2605 write!(formatter, "expected one of: {:?}", &FIELDS)
2606 }
2607
2608 #[allow(unused_variables)]
2609 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2610 where
2611 E: serde::de::Error,
2612 {
2613 match value {
2614 "start" => Ok(GeneratedField::Start),
2615 "writeBatch" | "write_batch" => Ok(GeneratedField::WriteBatch),
2616 "barrier" => Ok(GeneratedField::Barrier),
2617 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2618 }
2619 }
2620 }
2621 deserializer.deserialize_identifier(GeneratedVisitor)
2622 }
2623 }
2624 struct GeneratedVisitor;
2625 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2626 type Value = SinkWriterStreamRequest;
2627
2628 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2629 formatter.write_str("struct connector_service.SinkWriterStreamRequest")
2630 }
2631
2632 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkWriterStreamRequest, V::Error>
2633 where
2634 V: serde::de::MapAccess<'de>,
2635 {
2636 let mut request__ = None;
2637 while let Some(k) = map_.next_key()? {
2638 match k {
2639 GeneratedField::Start => {
2640 if request__.is_some() {
2641 return Err(serde::de::Error::duplicate_field("start"));
2642 }
2643 request__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_writer_stream_request::Request::Start)
2644;
2645 }
2646 GeneratedField::WriteBatch => {
2647 if request__.is_some() {
2648 return Err(serde::de::Error::duplicate_field("writeBatch"));
2649 }
2650 request__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_writer_stream_request::Request::WriteBatch)
2651;
2652 }
2653 GeneratedField::Barrier => {
2654 if request__.is_some() {
2655 return Err(serde::de::Error::duplicate_field("barrier"));
2656 }
2657 request__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_writer_stream_request::Request::Barrier)
2658;
2659 }
2660 }
2661 }
2662 Ok(SinkWriterStreamRequest {
2663 request: request__,
2664 })
2665 }
2666 }
2667 deserializer.deserialize_struct("connector_service.SinkWriterStreamRequest", FIELDS, GeneratedVisitor)
2668 }
2669}
2670impl serde::Serialize for sink_writer_stream_request::Barrier {
2671 #[allow(deprecated)]
2672 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2673 where
2674 S: serde::Serializer,
2675 {
2676 use serde::ser::SerializeStruct;
2677 let mut len = 0;
2678 if self.epoch != 0 {
2679 len += 1;
2680 }
2681 if self.is_checkpoint {
2682 len += 1;
2683 }
2684 let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamRequest.Barrier", len)?;
2685 if self.epoch != 0 {
2686 #[allow(clippy::needless_borrow)]
2687 #[allow(clippy::needless_borrows_for_generic_args)]
2688 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
2689 }
2690 if self.is_checkpoint {
2691 struct_ser.serialize_field("isCheckpoint", &self.is_checkpoint)?;
2692 }
2693 struct_ser.end()
2694 }
2695}
2696impl<'de> serde::Deserialize<'de> for sink_writer_stream_request::Barrier {
2697 #[allow(deprecated)]
2698 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2699 where
2700 D: serde::Deserializer<'de>,
2701 {
2702 const FIELDS: &[&str] = &[
2703 "epoch",
2704 "is_checkpoint",
2705 "isCheckpoint",
2706 ];
2707
2708 #[allow(clippy::enum_variant_names)]
2709 enum GeneratedField {
2710 Epoch,
2711 IsCheckpoint,
2712 }
2713 impl<'de> serde::Deserialize<'de> for GeneratedField {
2714 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2715 where
2716 D: serde::Deserializer<'de>,
2717 {
2718 struct GeneratedVisitor;
2719
2720 impl serde::de::Visitor<'_> for GeneratedVisitor {
2721 type Value = GeneratedField;
2722
2723 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2724 write!(formatter, "expected one of: {:?}", &FIELDS)
2725 }
2726
2727 #[allow(unused_variables)]
2728 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2729 where
2730 E: serde::de::Error,
2731 {
2732 match value {
2733 "epoch" => Ok(GeneratedField::Epoch),
2734 "isCheckpoint" | "is_checkpoint" => Ok(GeneratedField::IsCheckpoint),
2735 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2736 }
2737 }
2738 }
2739 deserializer.deserialize_identifier(GeneratedVisitor)
2740 }
2741 }
2742 struct GeneratedVisitor;
2743 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2744 type Value = sink_writer_stream_request::Barrier;
2745
2746 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2747 formatter.write_str("struct connector_service.SinkWriterStreamRequest.Barrier")
2748 }
2749
2750 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_writer_stream_request::Barrier, V::Error>
2751 where
2752 V: serde::de::MapAccess<'de>,
2753 {
2754 let mut epoch__ = None;
2755 let mut is_checkpoint__ = None;
2756 while let Some(k) = map_.next_key()? {
2757 match k {
2758 GeneratedField::Epoch => {
2759 if epoch__.is_some() {
2760 return Err(serde::de::Error::duplicate_field("epoch"));
2761 }
2762 epoch__ =
2763 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2764 ;
2765 }
2766 GeneratedField::IsCheckpoint => {
2767 if is_checkpoint__.is_some() {
2768 return Err(serde::de::Error::duplicate_field("isCheckpoint"));
2769 }
2770 is_checkpoint__ = Some(map_.next_value()?);
2771 }
2772 }
2773 }
2774 Ok(sink_writer_stream_request::Barrier {
2775 epoch: epoch__.unwrap_or_default(),
2776 is_checkpoint: is_checkpoint__.unwrap_or_default(),
2777 })
2778 }
2779 }
2780 deserializer.deserialize_struct("connector_service.SinkWriterStreamRequest.Barrier", FIELDS, GeneratedVisitor)
2781 }
2782}
2783impl serde::Serialize for sink_writer_stream_request::StartSink {
2784 #[allow(deprecated)]
2785 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2786 where
2787 S: serde::Serializer,
2788 {
2789 use serde::ser::SerializeStruct;
2790 let mut len = 0;
2791 if self.sink_param.is_some() {
2792 len += 1;
2793 }
2794 if self.payload_schema.is_some() {
2795 len += 1;
2796 }
2797 let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamRequest.StartSink", len)?;
2798 if let Some(v) = self.sink_param.as_ref() {
2799 struct_ser.serialize_field("sinkParam", v)?;
2800 }
2801 if let Some(v) = self.payload_schema.as_ref() {
2802 struct_ser.serialize_field("payloadSchema", v)?;
2803 }
2804 struct_ser.end()
2805 }
2806}
2807impl<'de> serde::Deserialize<'de> for sink_writer_stream_request::StartSink {
2808 #[allow(deprecated)]
2809 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2810 where
2811 D: serde::Deserializer<'de>,
2812 {
2813 const FIELDS: &[&str] = &[
2814 "sink_param",
2815 "sinkParam",
2816 "payload_schema",
2817 "payloadSchema",
2818 ];
2819
2820 #[allow(clippy::enum_variant_names)]
2821 enum GeneratedField {
2822 SinkParam,
2823 PayloadSchema,
2824 }
2825 impl<'de> serde::Deserialize<'de> for GeneratedField {
2826 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2827 where
2828 D: serde::Deserializer<'de>,
2829 {
2830 struct GeneratedVisitor;
2831
2832 impl serde::de::Visitor<'_> for GeneratedVisitor {
2833 type Value = GeneratedField;
2834
2835 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2836 write!(formatter, "expected one of: {:?}", &FIELDS)
2837 }
2838
2839 #[allow(unused_variables)]
2840 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2841 where
2842 E: serde::de::Error,
2843 {
2844 match value {
2845 "sinkParam" | "sink_param" => Ok(GeneratedField::SinkParam),
2846 "payloadSchema" | "payload_schema" => Ok(GeneratedField::PayloadSchema),
2847 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2848 }
2849 }
2850 }
2851 deserializer.deserialize_identifier(GeneratedVisitor)
2852 }
2853 }
2854 struct GeneratedVisitor;
2855 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2856 type Value = sink_writer_stream_request::StartSink;
2857
2858 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2859 formatter.write_str("struct connector_service.SinkWriterStreamRequest.StartSink")
2860 }
2861
2862 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_writer_stream_request::StartSink, V::Error>
2863 where
2864 V: serde::de::MapAccess<'de>,
2865 {
2866 let mut sink_param__ = None;
2867 let mut payload_schema__ = None;
2868 while let Some(k) = map_.next_key()? {
2869 match k {
2870 GeneratedField::SinkParam => {
2871 if sink_param__.is_some() {
2872 return Err(serde::de::Error::duplicate_field("sinkParam"));
2873 }
2874 sink_param__ = map_.next_value()?;
2875 }
2876 GeneratedField::PayloadSchema => {
2877 if payload_schema__.is_some() {
2878 return Err(serde::de::Error::duplicate_field("payloadSchema"));
2879 }
2880 payload_schema__ = map_.next_value()?;
2881 }
2882 }
2883 }
2884 Ok(sink_writer_stream_request::StartSink {
2885 sink_param: sink_param__,
2886 payload_schema: payload_schema__,
2887 })
2888 }
2889 }
2890 deserializer.deserialize_struct("connector_service.SinkWriterStreamRequest.StartSink", FIELDS, GeneratedVisitor)
2891 }
2892}
2893impl serde::Serialize for sink_writer_stream_request::WriteBatch {
2894 #[allow(deprecated)]
2895 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2896 where
2897 S: serde::Serializer,
2898 {
2899 use serde::ser::SerializeStruct;
2900 let mut len = 0;
2901 if self.batch_id != 0 {
2902 len += 1;
2903 }
2904 if self.epoch != 0 {
2905 len += 1;
2906 }
2907 if self.payload.is_some() {
2908 len += 1;
2909 }
2910 let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamRequest.WriteBatch", len)?;
2911 if self.batch_id != 0 {
2912 #[allow(clippy::needless_borrow)]
2913 #[allow(clippy::needless_borrows_for_generic_args)]
2914 struct_ser.serialize_field("batchId", ToString::to_string(&self.batch_id).as_str())?;
2915 }
2916 if self.epoch != 0 {
2917 #[allow(clippy::needless_borrow)]
2918 #[allow(clippy::needless_borrows_for_generic_args)]
2919 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
2920 }
2921 if let Some(v) = self.payload.as_ref() {
2922 match v {
2923 sink_writer_stream_request::write_batch::Payload::StreamChunkPayload(v) => {
2924 struct_ser.serialize_field("streamChunkPayload", v)?;
2925 }
2926 sink_writer_stream_request::write_batch::Payload::StreamChunkRefPointer(v) => {
2927 #[allow(clippy::needless_borrow)]
2928 #[allow(clippy::needless_borrows_for_generic_args)]
2929 struct_ser.serialize_field("streamChunkRefPointer", ToString::to_string(&v).as_str())?;
2930 }
2931 }
2932 }
2933 struct_ser.end()
2934 }
2935}
2936impl<'de> serde::Deserialize<'de> for sink_writer_stream_request::WriteBatch {
2937 #[allow(deprecated)]
2938 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2939 where
2940 D: serde::Deserializer<'de>,
2941 {
2942 const FIELDS: &[&str] = &[
2943 "batch_id",
2944 "batchId",
2945 "epoch",
2946 "stream_chunk_payload",
2947 "streamChunkPayload",
2948 "stream_chunk_ref_pointer",
2949 "streamChunkRefPointer",
2950 ];
2951
2952 #[allow(clippy::enum_variant_names)]
2953 enum GeneratedField {
2954 BatchId,
2955 Epoch,
2956 StreamChunkPayload,
2957 StreamChunkRefPointer,
2958 }
2959 impl<'de> serde::Deserialize<'de> for GeneratedField {
2960 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2961 where
2962 D: serde::Deserializer<'de>,
2963 {
2964 struct GeneratedVisitor;
2965
2966 impl serde::de::Visitor<'_> for GeneratedVisitor {
2967 type Value = GeneratedField;
2968
2969 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2970 write!(formatter, "expected one of: {:?}", &FIELDS)
2971 }
2972
2973 #[allow(unused_variables)]
2974 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2975 where
2976 E: serde::de::Error,
2977 {
2978 match value {
2979 "batchId" | "batch_id" => Ok(GeneratedField::BatchId),
2980 "epoch" => Ok(GeneratedField::Epoch),
2981 "streamChunkPayload" | "stream_chunk_payload" => Ok(GeneratedField::StreamChunkPayload),
2982 "streamChunkRefPointer" | "stream_chunk_ref_pointer" => Ok(GeneratedField::StreamChunkRefPointer),
2983 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2984 }
2985 }
2986 }
2987 deserializer.deserialize_identifier(GeneratedVisitor)
2988 }
2989 }
2990 struct GeneratedVisitor;
2991 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2992 type Value = sink_writer_stream_request::WriteBatch;
2993
2994 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2995 formatter.write_str("struct connector_service.SinkWriterStreamRequest.WriteBatch")
2996 }
2997
2998 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_writer_stream_request::WriteBatch, V::Error>
2999 where
3000 V: serde::de::MapAccess<'de>,
3001 {
3002 let mut batch_id__ = None;
3003 let mut epoch__ = None;
3004 let mut payload__ = None;
3005 while let Some(k) = map_.next_key()? {
3006 match k {
3007 GeneratedField::BatchId => {
3008 if batch_id__.is_some() {
3009 return Err(serde::de::Error::duplicate_field("batchId"));
3010 }
3011 batch_id__ =
3012 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3013 ;
3014 }
3015 GeneratedField::Epoch => {
3016 if epoch__.is_some() {
3017 return Err(serde::de::Error::duplicate_field("epoch"));
3018 }
3019 epoch__ =
3020 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3021 ;
3022 }
3023 GeneratedField::StreamChunkPayload => {
3024 if payload__.is_some() {
3025 return Err(serde::de::Error::duplicate_field("streamChunkPayload"));
3026 }
3027 payload__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_writer_stream_request::write_batch::Payload::StreamChunkPayload)
3028;
3029 }
3030 GeneratedField::StreamChunkRefPointer => {
3031 if payload__.is_some() {
3032 return Err(serde::de::Error::duplicate_field("streamChunkRefPointer"));
3033 }
3034 payload__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| sink_writer_stream_request::write_batch::Payload::StreamChunkRefPointer(x.0));
3035 }
3036 }
3037 }
3038 Ok(sink_writer_stream_request::WriteBatch {
3039 batch_id: batch_id__.unwrap_or_default(),
3040 epoch: epoch__.unwrap_or_default(),
3041 payload: payload__,
3042 })
3043 }
3044 }
3045 deserializer.deserialize_struct("connector_service.SinkWriterStreamRequest.WriteBatch", FIELDS, GeneratedVisitor)
3046 }
3047}
3048impl serde::Serialize for sink_writer_stream_request::write_batch::StreamChunkPayload {
3049 #[allow(deprecated)]
3050 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3051 where
3052 S: serde::Serializer,
3053 {
3054 use serde::ser::SerializeStruct;
3055 let mut len = 0;
3056 if !self.binary_data.is_empty() {
3057 len += 1;
3058 }
3059 let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamRequest.WriteBatch.StreamChunkPayload", len)?;
3060 if !self.binary_data.is_empty() {
3061 #[allow(clippy::needless_borrow)]
3062 #[allow(clippy::needless_borrows_for_generic_args)]
3063 struct_ser.serialize_field("binaryData", pbjson::private::base64::encode(&self.binary_data).as_str())?;
3064 }
3065 struct_ser.end()
3066 }
3067}
3068impl<'de> serde::Deserialize<'de> for sink_writer_stream_request::write_batch::StreamChunkPayload {
3069 #[allow(deprecated)]
3070 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3071 where
3072 D: serde::Deserializer<'de>,
3073 {
3074 const FIELDS: &[&str] = &[
3075 "binary_data",
3076 "binaryData",
3077 ];
3078
3079 #[allow(clippy::enum_variant_names)]
3080 enum GeneratedField {
3081 BinaryData,
3082 }
3083 impl<'de> serde::Deserialize<'de> for GeneratedField {
3084 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3085 where
3086 D: serde::Deserializer<'de>,
3087 {
3088 struct GeneratedVisitor;
3089
3090 impl serde::de::Visitor<'_> for GeneratedVisitor {
3091 type Value = GeneratedField;
3092
3093 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3094 write!(formatter, "expected one of: {:?}", &FIELDS)
3095 }
3096
3097 #[allow(unused_variables)]
3098 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3099 where
3100 E: serde::de::Error,
3101 {
3102 match value {
3103 "binaryData" | "binary_data" => Ok(GeneratedField::BinaryData),
3104 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3105 }
3106 }
3107 }
3108 deserializer.deserialize_identifier(GeneratedVisitor)
3109 }
3110 }
3111 struct GeneratedVisitor;
3112 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3113 type Value = sink_writer_stream_request::write_batch::StreamChunkPayload;
3114
3115 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3116 formatter.write_str("struct connector_service.SinkWriterStreamRequest.WriteBatch.StreamChunkPayload")
3117 }
3118
3119 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_writer_stream_request::write_batch::StreamChunkPayload, V::Error>
3120 where
3121 V: serde::de::MapAccess<'de>,
3122 {
3123 let mut binary_data__ = None;
3124 while let Some(k) = map_.next_key()? {
3125 match k {
3126 GeneratedField::BinaryData => {
3127 if binary_data__.is_some() {
3128 return Err(serde::de::Error::duplicate_field("binaryData"));
3129 }
3130 binary_data__ =
3131 Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
3132 ;
3133 }
3134 }
3135 }
3136 Ok(sink_writer_stream_request::write_batch::StreamChunkPayload {
3137 binary_data: binary_data__.unwrap_or_default(),
3138 })
3139 }
3140 }
3141 deserializer.deserialize_struct("connector_service.SinkWriterStreamRequest.WriteBatch.StreamChunkPayload", FIELDS, GeneratedVisitor)
3142 }
3143}
3144impl serde::Serialize for SinkWriterStreamResponse {
3145 #[allow(deprecated)]
3146 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3147 where
3148 S: serde::Serializer,
3149 {
3150 use serde::ser::SerializeStruct;
3151 let mut len = 0;
3152 if self.response.is_some() {
3153 len += 1;
3154 }
3155 let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamResponse", len)?;
3156 if let Some(v) = self.response.as_ref() {
3157 match v {
3158 sink_writer_stream_response::Response::Start(v) => {
3159 struct_ser.serialize_field("start", v)?;
3160 }
3161 sink_writer_stream_response::Response::Commit(v) => {
3162 struct_ser.serialize_field("commit", v)?;
3163 }
3164 sink_writer_stream_response::Response::Batch(v) => {
3165 struct_ser.serialize_field("batch", v)?;
3166 }
3167 }
3168 }
3169 struct_ser.end()
3170 }
3171}
3172impl<'de> serde::Deserialize<'de> for SinkWriterStreamResponse {
3173 #[allow(deprecated)]
3174 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3175 where
3176 D: serde::Deserializer<'de>,
3177 {
3178 const FIELDS: &[&str] = &[
3179 "start",
3180 "commit",
3181 "batch",
3182 ];
3183
3184 #[allow(clippy::enum_variant_names)]
3185 enum GeneratedField {
3186 Start,
3187 Commit,
3188 Batch,
3189 }
3190 impl<'de> serde::Deserialize<'de> for GeneratedField {
3191 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3192 where
3193 D: serde::Deserializer<'de>,
3194 {
3195 struct GeneratedVisitor;
3196
3197 impl serde::de::Visitor<'_> for GeneratedVisitor {
3198 type Value = GeneratedField;
3199
3200 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3201 write!(formatter, "expected one of: {:?}", &FIELDS)
3202 }
3203
3204 #[allow(unused_variables)]
3205 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3206 where
3207 E: serde::de::Error,
3208 {
3209 match value {
3210 "start" => Ok(GeneratedField::Start),
3211 "commit" => Ok(GeneratedField::Commit),
3212 "batch" => Ok(GeneratedField::Batch),
3213 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3214 }
3215 }
3216 }
3217 deserializer.deserialize_identifier(GeneratedVisitor)
3218 }
3219 }
3220 struct GeneratedVisitor;
3221 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3222 type Value = SinkWriterStreamResponse;
3223
3224 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3225 formatter.write_str("struct connector_service.SinkWriterStreamResponse")
3226 }
3227
3228 fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkWriterStreamResponse, V::Error>
3229 where
3230 V: serde::de::MapAccess<'de>,
3231 {
3232 let mut response__ = None;
3233 while let Some(k) = map_.next_key()? {
3234 match k {
3235 GeneratedField::Start => {
3236 if response__.is_some() {
3237 return Err(serde::de::Error::duplicate_field("start"));
3238 }
3239 response__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_writer_stream_response::Response::Start)
3240;
3241 }
3242 GeneratedField::Commit => {
3243 if response__.is_some() {
3244 return Err(serde::de::Error::duplicate_field("commit"));
3245 }
3246 response__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_writer_stream_response::Response::Commit)
3247;
3248 }
3249 GeneratedField::Batch => {
3250 if response__.is_some() {
3251 return Err(serde::de::Error::duplicate_field("batch"));
3252 }
3253 response__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_writer_stream_response::Response::Batch)
3254;
3255 }
3256 }
3257 }
3258 Ok(SinkWriterStreamResponse {
3259 response: response__,
3260 })
3261 }
3262 }
3263 deserializer.deserialize_struct("connector_service.SinkWriterStreamResponse", FIELDS, GeneratedVisitor)
3264 }
3265}
3266impl serde::Serialize for sink_writer_stream_response::BatchWrittenResponse {
3267 #[allow(deprecated)]
3268 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3269 where
3270 S: serde::Serializer,
3271 {
3272 use serde::ser::SerializeStruct;
3273 let mut len = 0;
3274 if self.epoch != 0 {
3275 len += 1;
3276 }
3277 if self.batch_id != 0 {
3278 len += 1;
3279 }
3280 let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamResponse.BatchWrittenResponse", len)?;
3281 if self.epoch != 0 {
3282 #[allow(clippy::needless_borrow)]
3283 #[allow(clippy::needless_borrows_for_generic_args)]
3284 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
3285 }
3286 if self.batch_id != 0 {
3287 #[allow(clippy::needless_borrow)]
3288 #[allow(clippy::needless_borrows_for_generic_args)]
3289 struct_ser.serialize_field("batchId", ToString::to_string(&self.batch_id).as_str())?;
3290 }
3291 struct_ser.end()
3292 }
3293}
3294impl<'de> serde::Deserialize<'de> for sink_writer_stream_response::BatchWrittenResponse {
3295 #[allow(deprecated)]
3296 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3297 where
3298 D: serde::Deserializer<'de>,
3299 {
3300 const FIELDS: &[&str] = &[
3301 "epoch",
3302 "batch_id",
3303 "batchId",
3304 ];
3305
3306 #[allow(clippy::enum_variant_names)]
3307 enum GeneratedField {
3308 Epoch,
3309 BatchId,
3310 }
3311 impl<'de> serde::Deserialize<'de> for GeneratedField {
3312 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3313 where
3314 D: serde::Deserializer<'de>,
3315 {
3316 struct GeneratedVisitor;
3317
3318 impl serde::de::Visitor<'_> for GeneratedVisitor {
3319 type Value = GeneratedField;
3320
3321 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3322 write!(formatter, "expected one of: {:?}", &FIELDS)
3323 }
3324
3325 #[allow(unused_variables)]
3326 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3327 where
3328 E: serde::de::Error,
3329 {
3330 match value {
3331 "epoch" => Ok(GeneratedField::Epoch),
3332 "batchId" | "batch_id" => Ok(GeneratedField::BatchId),
3333 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3334 }
3335 }
3336 }
3337 deserializer.deserialize_identifier(GeneratedVisitor)
3338 }
3339 }
3340 struct GeneratedVisitor;
3341 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3342 type Value = sink_writer_stream_response::BatchWrittenResponse;
3343
3344 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3345 formatter.write_str("struct connector_service.SinkWriterStreamResponse.BatchWrittenResponse")
3346 }
3347
3348 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_writer_stream_response::BatchWrittenResponse, V::Error>
3349 where
3350 V: serde::de::MapAccess<'de>,
3351 {
3352 let mut epoch__ = None;
3353 let mut batch_id__ = None;
3354 while let Some(k) = map_.next_key()? {
3355 match k {
3356 GeneratedField::Epoch => {
3357 if epoch__.is_some() {
3358 return Err(serde::de::Error::duplicate_field("epoch"));
3359 }
3360 epoch__ =
3361 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3362 ;
3363 }
3364 GeneratedField::BatchId => {
3365 if batch_id__.is_some() {
3366 return Err(serde::de::Error::duplicate_field("batchId"));
3367 }
3368 batch_id__ =
3369 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3370 ;
3371 }
3372 }
3373 }
3374 Ok(sink_writer_stream_response::BatchWrittenResponse {
3375 epoch: epoch__.unwrap_or_default(),
3376 batch_id: batch_id__.unwrap_or_default(),
3377 })
3378 }
3379 }
3380 deserializer.deserialize_struct("connector_service.SinkWriterStreamResponse.BatchWrittenResponse", FIELDS, GeneratedVisitor)
3381 }
3382}
3383impl serde::Serialize for sink_writer_stream_response::CommitResponse {
3384 #[allow(deprecated)]
3385 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3386 where
3387 S: serde::Serializer,
3388 {
3389 use serde::ser::SerializeStruct;
3390 let mut len = 0;
3391 if self.epoch != 0 {
3392 len += 1;
3393 }
3394 if self.metadata.is_some() {
3395 len += 1;
3396 }
3397 let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamResponse.CommitResponse", len)?;
3398 if self.epoch != 0 {
3399 #[allow(clippy::needless_borrow)]
3400 #[allow(clippy::needless_borrows_for_generic_args)]
3401 struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
3402 }
3403 if let Some(v) = self.metadata.as_ref() {
3404 struct_ser.serialize_field("metadata", v)?;
3405 }
3406 struct_ser.end()
3407 }
3408}
3409impl<'de> serde::Deserialize<'de> for sink_writer_stream_response::CommitResponse {
3410 #[allow(deprecated)]
3411 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3412 where
3413 D: serde::Deserializer<'de>,
3414 {
3415 const FIELDS: &[&str] = &[
3416 "epoch",
3417 "metadata",
3418 ];
3419
3420 #[allow(clippy::enum_variant_names)]
3421 enum GeneratedField {
3422 Epoch,
3423 Metadata,
3424 }
3425 impl<'de> serde::Deserialize<'de> for GeneratedField {
3426 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3427 where
3428 D: serde::Deserializer<'de>,
3429 {
3430 struct GeneratedVisitor;
3431
3432 impl serde::de::Visitor<'_> for GeneratedVisitor {
3433 type Value = GeneratedField;
3434
3435 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3436 write!(formatter, "expected one of: {:?}", &FIELDS)
3437 }
3438
3439 #[allow(unused_variables)]
3440 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3441 where
3442 E: serde::de::Error,
3443 {
3444 match value {
3445 "epoch" => Ok(GeneratedField::Epoch),
3446 "metadata" => Ok(GeneratedField::Metadata),
3447 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3448 }
3449 }
3450 }
3451 deserializer.deserialize_identifier(GeneratedVisitor)
3452 }
3453 }
3454 struct GeneratedVisitor;
3455 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3456 type Value = sink_writer_stream_response::CommitResponse;
3457
3458 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3459 formatter.write_str("struct connector_service.SinkWriterStreamResponse.CommitResponse")
3460 }
3461
3462 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_writer_stream_response::CommitResponse, V::Error>
3463 where
3464 V: serde::de::MapAccess<'de>,
3465 {
3466 let mut epoch__ = None;
3467 let mut metadata__ = None;
3468 while let Some(k) = map_.next_key()? {
3469 match k {
3470 GeneratedField::Epoch => {
3471 if epoch__.is_some() {
3472 return Err(serde::de::Error::duplicate_field("epoch"));
3473 }
3474 epoch__ =
3475 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3476 ;
3477 }
3478 GeneratedField::Metadata => {
3479 if metadata__.is_some() {
3480 return Err(serde::de::Error::duplicate_field("metadata"));
3481 }
3482 metadata__ = map_.next_value()?;
3483 }
3484 }
3485 }
3486 Ok(sink_writer_stream_response::CommitResponse {
3487 epoch: epoch__.unwrap_or_default(),
3488 metadata: metadata__,
3489 })
3490 }
3491 }
3492 deserializer.deserialize_struct("connector_service.SinkWriterStreamResponse.CommitResponse", FIELDS, GeneratedVisitor)
3493 }
3494}
3495impl serde::Serialize for sink_writer_stream_response::StartResponse {
3496 #[allow(deprecated)]
3497 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3498 where
3499 S: serde::Serializer,
3500 {
3501 use serde::ser::SerializeStruct;
3502 let len = 0;
3503 let struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamResponse.StartResponse", len)?;
3504 struct_ser.end()
3505 }
3506}
3507impl<'de> serde::Deserialize<'de> for sink_writer_stream_response::StartResponse {
3508 #[allow(deprecated)]
3509 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3510 where
3511 D: serde::Deserializer<'de>,
3512 {
3513 const FIELDS: &[&str] = &[
3514 ];
3515
3516 #[allow(clippy::enum_variant_names)]
3517 enum GeneratedField {
3518 }
3519 impl<'de> serde::Deserialize<'de> for GeneratedField {
3520 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3521 where
3522 D: serde::Deserializer<'de>,
3523 {
3524 struct GeneratedVisitor;
3525
3526 impl serde::de::Visitor<'_> for GeneratedVisitor {
3527 type Value = GeneratedField;
3528
3529 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3530 write!(formatter, "expected one of: {:?}", &FIELDS)
3531 }
3532
3533 #[allow(unused_variables)]
3534 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3535 where
3536 E: serde::de::Error,
3537 {
3538 Err(serde::de::Error::unknown_field(value, FIELDS))
3539 }
3540 }
3541 deserializer.deserialize_identifier(GeneratedVisitor)
3542 }
3543 }
3544 struct GeneratedVisitor;
3545 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3546 type Value = sink_writer_stream_response::StartResponse;
3547
3548 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3549 formatter.write_str("struct connector_service.SinkWriterStreamResponse.StartResponse")
3550 }
3551
3552 fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_writer_stream_response::StartResponse, V::Error>
3553 where
3554 V: serde::de::MapAccess<'de>,
3555 {
3556 while map_.next_key::<GeneratedField>()?.is_some() {
3557 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3558 }
3559 Ok(sink_writer_stream_response::StartResponse {
3560 })
3561 }
3562 }
3563 deserializer.deserialize_struct("connector_service.SinkWriterStreamResponse.StartResponse", FIELDS, GeneratedVisitor)
3564 }
3565}
3566impl serde::Serialize for SourceType {
3567 #[allow(deprecated)]
3568 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3569 where
3570 S: serde::Serializer,
3571 {
3572 let variant = match self {
3573 Self::Unspecified => "UNSPECIFIED",
3574 Self::Mysql => "MYSQL",
3575 Self::Postgres => "POSTGRES",
3576 Self::Citus => "CITUS",
3577 Self::Mongodb => "MONGODB",
3578 Self::SqlServer => "SQL_SERVER",
3579 };
3580 serializer.serialize_str(variant)
3581 }
3582}
3583impl<'de> serde::Deserialize<'de> for SourceType {
3584 #[allow(deprecated)]
3585 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3586 where
3587 D: serde::Deserializer<'de>,
3588 {
3589 const FIELDS: &[&str] = &[
3590 "UNSPECIFIED",
3591 "MYSQL",
3592 "POSTGRES",
3593 "CITUS",
3594 "MONGODB",
3595 "SQL_SERVER",
3596 ];
3597
3598 struct GeneratedVisitor;
3599
3600 impl serde::de::Visitor<'_> for GeneratedVisitor {
3601 type Value = SourceType;
3602
3603 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3604 write!(formatter, "expected one of: {:?}", &FIELDS)
3605 }
3606
3607 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3608 where
3609 E: serde::de::Error,
3610 {
3611 i32::try_from(v)
3612 .ok()
3613 .and_then(|x| x.try_into().ok())
3614 .ok_or_else(|| {
3615 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3616 })
3617 }
3618
3619 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3620 where
3621 E: serde::de::Error,
3622 {
3623 i32::try_from(v)
3624 .ok()
3625 .and_then(|x| x.try_into().ok())
3626 .ok_or_else(|| {
3627 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3628 })
3629 }
3630
3631 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3632 where
3633 E: serde::de::Error,
3634 {
3635 match value {
3636 "UNSPECIFIED" => Ok(SourceType::Unspecified),
3637 "MYSQL" => Ok(SourceType::Mysql),
3638 "POSTGRES" => Ok(SourceType::Postgres),
3639 "CITUS" => Ok(SourceType::Citus),
3640 "MONGODB" => Ok(SourceType::Mongodb),
3641 "SQL_SERVER" => Ok(SourceType::SqlServer),
3642 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3643 }
3644 }
3645 }
3646 deserializer.deserialize_any(GeneratedVisitor)
3647 }
3648}
3649impl serde::Serialize for TableSchema {
3650 #[allow(deprecated)]
3651 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3652 where
3653 S: serde::Serializer,
3654 {
3655 use serde::ser::SerializeStruct;
3656 let mut len = 0;
3657 if !self.columns.is_empty() {
3658 len += 1;
3659 }
3660 if !self.pk_indices.is_empty() {
3661 len += 1;
3662 }
3663 let mut struct_ser = serializer.serialize_struct("connector_service.TableSchema", len)?;
3664 if !self.columns.is_empty() {
3665 struct_ser.serialize_field("columns", &self.columns)?;
3666 }
3667 if !self.pk_indices.is_empty() {
3668 struct_ser.serialize_field("pkIndices", &self.pk_indices)?;
3669 }
3670 struct_ser.end()
3671 }
3672}
3673impl<'de> serde::Deserialize<'de> for TableSchema {
3674 #[allow(deprecated)]
3675 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3676 where
3677 D: serde::Deserializer<'de>,
3678 {
3679 const FIELDS: &[&str] = &[
3680 "columns",
3681 "pk_indices",
3682 "pkIndices",
3683 ];
3684
3685 #[allow(clippy::enum_variant_names)]
3686 enum GeneratedField {
3687 Columns,
3688 PkIndices,
3689 }
3690 impl<'de> serde::Deserialize<'de> for GeneratedField {
3691 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3692 where
3693 D: serde::Deserializer<'de>,
3694 {
3695 struct GeneratedVisitor;
3696
3697 impl serde::de::Visitor<'_> for GeneratedVisitor {
3698 type Value = GeneratedField;
3699
3700 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3701 write!(formatter, "expected one of: {:?}", &FIELDS)
3702 }
3703
3704 #[allow(unused_variables)]
3705 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3706 where
3707 E: serde::de::Error,
3708 {
3709 match value {
3710 "columns" => Ok(GeneratedField::Columns),
3711 "pkIndices" | "pk_indices" => Ok(GeneratedField::PkIndices),
3712 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3713 }
3714 }
3715 }
3716 deserializer.deserialize_identifier(GeneratedVisitor)
3717 }
3718 }
3719 struct GeneratedVisitor;
3720 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3721 type Value = TableSchema;
3722
3723 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3724 formatter.write_str("struct connector_service.TableSchema")
3725 }
3726
3727 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchema, V::Error>
3728 where
3729 V: serde::de::MapAccess<'de>,
3730 {
3731 let mut columns__ = None;
3732 let mut pk_indices__ = None;
3733 while let Some(k) = map_.next_key()? {
3734 match k {
3735 GeneratedField::Columns => {
3736 if columns__.is_some() {
3737 return Err(serde::de::Error::duplicate_field("columns"));
3738 }
3739 columns__ = Some(map_.next_value()?);
3740 }
3741 GeneratedField::PkIndices => {
3742 if pk_indices__.is_some() {
3743 return Err(serde::de::Error::duplicate_field("pkIndices"));
3744 }
3745 pk_indices__ =
3746 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3747 .into_iter().map(|x| x.0).collect())
3748 ;
3749 }
3750 }
3751 }
3752 Ok(TableSchema {
3753 columns: columns__.unwrap_or_default(),
3754 pk_indices: pk_indices__.unwrap_or_default(),
3755 })
3756 }
3757 }
3758 deserializer.deserialize_struct("connector_service.TableSchema", FIELDS, GeneratedVisitor)
3759 }
3760}
3761impl serde::Serialize for ValidateSinkRequest {
3762 #[allow(deprecated)]
3763 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3764 where
3765 S: serde::Serializer,
3766 {
3767 use serde::ser::SerializeStruct;
3768 let mut len = 0;
3769 if self.sink_param.is_some() {
3770 len += 1;
3771 }
3772 let mut struct_ser = serializer.serialize_struct("connector_service.ValidateSinkRequest", len)?;
3773 if let Some(v) = self.sink_param.as_ref() {
3774 struct_ser.serialize_field("sinkParam", v)?;
3775 }
3776 struct_ser.end()
3777 }
3778}
3779impl<'de> serde::Deserialize<'de> for ValidateSinkRequest {
3780 #[allow(deprecated)]
3781 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3782 where
3783 D: serde::Deserializer<'de>,
3784 {
3785 const FIELDS: &[&str] = &[
3786 "sink_param",
3787 "sinkParam",
3788 ];
3789
3790 #[allow(clippy::enum_variant_names)]
3791 enum GeneratedField {
3792 SinkParam,
3793 }
3794 impl<'de> serde::Deserialize<'de> for GeneratedField {
3795 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3796 where
3797 D: serde::Deserializer<'de>,
3798 {
3799 struct GeneratedVisitor;
3800
3801 impl serde::de::Visitor<'_> for GeneratedVisitor {
3802 type Value = GeneratedField;
3803
3804 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3805 write!(formatter, "expected one of: {:?}", &FIELDS)
3806 }
3807
3808 #[allow(unused_variables)]
3809 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3810 where
3811 E: serde::de::Error,
3812 {
3813 match value {
3814 "sinkParam" | "sink_param" => Ok(GeneratedField::SinkParam),
3815 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3816 }
3817 }
3818 }
3819 deserializer.deserialize_identifier(GeneratedVisitor)
3820 }
3821 }
3822 struct GeneratedVisitor;
3823 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3824 type Value = ValidateSinkRequest;
3825
3826 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3827 formatter.write_str("struct connector_service.ValidateSinkRequest")
3828 }
3829
3830 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidateSinkRequest, V::Error>
3831 where
3832 V: serde::de::MapAccess<'de>,
3833 {
3834 let mut sink_param__ = None;
3835 while let Some(k) = map_.next_key()? {
3836 match k {
3837 GeneratedField::SinkParam => {
3838 if sink_param__.is_some() {
3839 return Err(serde::de::Error::duplicate_field("sinkParam"));
3840 }
3841 sink_param__ = map_.next_value()?;
3842 }
3843 }
3844 }
3845 Ok(ValidateSinkRequest {
3846 sink_param: sink_param__,
3847 })
3848 }
3849 }
3850 deserializer.deserialize_struct("connector_service.ValidateSinkRequest", FIELDS, GeneratedVisitor)
3851 }
3852}
3853impl serde::Serialize for ValidateSinkResponse {
3854 #[allow(deprecated)]
3855 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3856 where
3857 S: serde::Serializer,
3858 {
3859 use serde::ser::SerializeStruct;
3860 let mut len = 0;
3861 if self.error.is_some() {
3862 len += 1;
3863 }
3864 let mut struct_ser = serializer.serialize_struct("connector_service.ValidateSinkResponse", len)?;
3865 if let Some(v) = self.error.as_ref() {
3866 struct_ser.serialize_field("error", v)?;
3867 }
3868 struct_ser.end()
3869 }
3870}
3871impl<'de> serde::Deserialize<'de> for ValidateSinkResponse {
3872 #[allow(deprecated)]
3873 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3874 where
3875 D: serde::Deserializer<'de>,
3876 {
3877 const FIELDS: &[&str] = &[
3878 "error",
3879 ];
3880
3881 #[allow(clippy::enum_variant_names)]
3882 enum GeneratedField {
3883 Error,
3884 }
3885 impl<'de> serde::Deserialize<'de> for GeneratedField {
3886 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3887 where
3888 D: serde::Deserializer<'de>,
3889 {
3890 struct GeneratedVisitor;
3891
3892 impl serde::de::Visitor<'_> for GeneratedVisitor {
3893 type Value = GeneratedField;
3894
3895 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3896 write!(formatter, "expected one of: {:?}", &FIELDS)
3897 }
3898
3899 #[allow(unused_variables)]
3900 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3901 where
3902 E: serde::de::Error,
3903 {
3904 match value {
3905 "error" => Ok(GeneratedField::Error),
3906 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3907 }
3908 }
3909 }
3910 deserializer.deserialize_identifier(GeneratedVisitor)
3911 }
3912 }
3913 struct GeneratedVisitor;
3914 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3915 type Value = ValidateSinkResponse;
3916
3917 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3918 formatter.write_str("struct connector_service.ValidateSinkResponse")
3919 }
3920
3921 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidateSinkResponse, V::Error>
3922 where
3923 V: serde::de::MapAccess<'de>,
3924 {
3925 let mut error__ = None;
3926 while let Some(k) = map_.next_key()? {
3927 match k {
3928 GeneratedField::Error => {
3929 if error__.is_some() {
3930 return Err(serde::de::Error::duplicate_field("error"));
3931 }
3932 error__ = map_.next_value()?;
3933 }
3934 }
3935 }
3936 Ok(ValidateSinkResponse {
3937 error: error__,
3938 })
3939 }
3940 }
3941 deserializer.deserialize_struct("connector_service.ValidateSinkResponse", FIELDS, GeneratedVisitor)
3942 }
3943}
3944impl serde::Serialize for ValidateSourceRequest {
3945 #[allow(deprecated)]
3946 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3947 where
3948 S: serde::Serializer,
3949 {
3950 use serde::ser::SerializeStruct;
3951 let mut len = 0;
3952 if self.source_id != 0 {
3953 len += 1;
3954 }
3955 if self.source_type != 0 {
3956 len += 1;
3957 }
3958 if !self.properties.is_empty() {
3959 len += 1;
3960 }
3961 if self.table_schema.is_some() {
3962 len += 1;
3963 }
3964 if self.is_source_job {
3965 len += 1;
3966 }
3967 if self.is_backfill_table {
3968 len += 1;
3969 }
3970 let mut struct_ser = serializer.serialize_struct("connector_service.ValidateSourceRequest", len)?;
3971 if self.source_id != 0 {
3972 #[allow(clippy::needless_borrow)]
3973 #[allow(clippy::needless_borrows_for_generic_args)]
3974 struct_ser.serialize_field("sourceId", ToString::to_string(&self.source_id).as_str())?;
3975 }
3976 if self.source_type != 0 {
3977 let v = SourceType::try_from(self.source_type)
3978 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.source_type)))?;
3979 struct_ser.serialize_field("sourceType", &v)?;
3980 }
3981 if !self.properties.is_empty() {
3982 struct_ser.serialize_field("properties", &self.properties)?;
3983 }
3984 if let Some(v) = self.table_schema.as_ref() {
3985 struct_ser.serialize_field("tableSchema", v)?;
3986 }
3987 if self.is_source_job {
3988 struct_ser.serialize_field("isSourceJob", &self.is_source_job)?;
3989 }
3990 if self.is_backfill_table {
3991 struct_ser.serialize_field("isBackfillTable", &self.is_backfill_table)?;
3992 }
3993 struct_ser.end()
3994 }
3995}
3996impl<'de> serde::Deserialize<'de> for ValidateSourceRequest {
3997 #[allow(deprecated)]
3998 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3999 where
4000 D: serde::Deserializer<'de>,
4001 {
4002 const FIELDS: &[&str] = &[
4003 "source_id",
4004 "sourceId",
4005 "source_type",
4006 "sourceType",
4007 "properties",
4008 "table_schema",
4009 "tableSchema",
4010 "is_source_job",
4011 "isSourceJob",
4012 "is_backfill_table",
4013 "isBackfillTable",
4014 ];
4015
4016 #[allow(clippy::enum_variant_names)]
4017 enum GeneratedField {
4018 SourceId,
4019 SourceType,
4020 Properties,
4021 TableSchema,
4022 IsSourceJob,
4023 IsBackfillTable,
4024 }
4025 impl<'de> serde::Deserialize<'de> for GeneratedField {
4026 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4027 where
4028 D: serde::Deserializer<'de>,
4029 {
4030 struct GeneratedVisitor;
4031
4032 impl serde::de::Visitor<'_> for GeneratedVisitor {
4033 type Value = GeneratedField;
4034
4035 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4036 write!(formatter, "expected one of: {:?}", &FIELDS)
4037 }
4038
4039 #[allow(unused_variables)]
4040 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4041 where
4042 E: serde::de::Error,
4043 {
4044 match value {
4045 "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
4046 "sourceType" | "source_type" => Ok(GeneratedField::SourceType),
4047 "properties" => Ok(GeneratedField::Properties),
4048 "tableSchema" | "table_schema" => Ok(GeneratedField::TableSchema),
4049 "isSourceJob" | "is_source_job" => Ok(GeneratedField::IsSourceJob),
4050 "isBackfillTable" | "is_backfill_table" => Ok(GeneratedField::IsBackfillTable),
4051 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4052 }
4053 }
4054 }
4055 deserializer.deserialize_identifier(GeneratedVisitor)
4056 }
4057 }
4058 struct GeneratedVisitor;
4059 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4060 type Value = ValidateSourceRequest;
4061
4062 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4063 formatter.write_str("struct connector_service.ValidateSourceRequest")
4064 }
4065
4066 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidateSourceRequest, V::Error>
4067 where
4068 V: serde::de::MapAccess<'de>,
4069 {
4070 let mut source_id__ = None;
4071 let mut source_type__ = None;
4072 let mut properties__ = None;
4073 let mut table_schema__ = None;
4074 let mut is_source_job__ = None;
4075 let mut is_backfill_table__ = None;
4076 while let Some(k) = map_.next_key()? {
4077 match k {
4078 GeneratedField::SourceId => {
4079 if source_id__.is_some() {
4080 return Err(serde::de::Error::duplicate_field("sourceId"));
4081 }
4082 source_id__ =
4083 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4084 ;
4085 }
4086 GeneratedField::SourceType => {
4087 if source_type__.is_some() {
4088 return Err(serde::de::Error::duplicate_field("sourceType"));
4089 }
4090 source_type__ = Some(map_.next_value::<SourceType>()? as i32);
4091 }
4092 GeneratedField::Properties => {
4093 if properties__.is_some() {
4094 return Err(serde::de::Error::duplicate_field("properties"));
4095 }
4096 properties__ = Some(
4097 map_.next_value::<std::collections::BTreeMap<_, _>>()?
4098 );
4099 }
4100 GeneratedField::TableSchema => {
4101 if table_schema__.is_some() {
4102 return Err(serde::de::Error::duplicate_field("tableSchema"));
4103 }
4104 table_schema__ = map_.next_value()?;
4105 }
4106 GeneratedField::IsSourceJob => {
4107 if is_source_job__.is_some() {
4108 return Err(serde::de::Error::duplicate_field("isSourceJob"));
4109 }
4110 is_source_job__ = Some(map_.next_value()?);
4111 }
4112 GeneratedField::IsBackfillTable => {
4113 if is_backfill_table__.is_some() {
4114 return Err(serde::de::Error::duplicate_field("isBackfillTable"));
4115 }
4116 is_backfill_table__ = Some(map_.next_value()?);
4117 }
4118 }
4119 }
4120 Ok(ValidateSourceRequest {
4121 source_id: source_id__.unwrap_or_default(),
4122 source_type: source_type__.unwrap_or_default(),
4123 properties: properties__.unwrap_or_default(),
4124 table_schema: table_schema__,
4125 is_source_job: is_source_job__.unwrap_or_default(),
4126 is_backfill_table: is_backfill_table__.unwrap_or_default(),
4127 })
4128 }
4129 }
4130 deserializer.deserialize_struct("connector_service.ValidateSourceRequest", FIELDS, GeneratedVisitor)
4131 }
4132}
4133impl serde::Serialize for ValidateSourceResponse {
4134 #[allow(deprecated)]
4135 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4136 where
4137 S: serde::Serializer,
4138 {
4139 use serde::ser::SerializeStruct;
4140 let mut len = 0;
4141 if self.error.is_some() {
4142 len += 1;
4143 }
4144 let mut struct_ser = serializer.serialize_struct("connector_service.ValidateSourceResponse", len)?;
4145 if let Some(v) = self.error.as_ref() {
4146 struct_ser.serialize_field("error", v)?;
4147 }
4148 struct_ser.end()
4149 }
4150}
4151impl<'de> serde::Deserialize<'de> for ValidateSourceResponse {
4152 #[allow(deprecated)]
4153 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4154 where
4155 D: serde::Deserializer<'de>,
4156 {
4157 const FIELDS: &[&str] = &[
4158 "error",
4159 ];
4160
4161 #[allow(clippy::enum_variant_names)]
4162 enum GeneratedField {
4163 Error,
4164 }
4165 impl<'de> serde::Deserialize<'de> for GeneratedField {
4166 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4167 where
4168 D: serde::Deserializer<'de>,
4169 {
4170 struct GeneratedVisitor;
4171
4172 impl serde::de::Visitor<'_> for GeneratedVisitor {
4173 type Value = GeneratedField;
4174
4175 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4176 write!(formatter, "expected one of: {:?}", &FIELDS)
4177 }
4178
4179 #[allow(unused_variables)]
4180 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4181 where
4182 E: serde::de::Error,
4183 {
4184 match value {
4185 "error" => Ok(GeneratedField::Error),
4186 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4187 }
4188 }
4189 }
4190 deserializer.deserialize_identifier(GeneratedVisitor)
4191 }
4192 }
4193 struct GeneratedVisitor;
4194 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4195 type Value = ValidateSourceResponse;
4196
4197 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4198 formatter.write_str("struct connector_service.ValidateSourceResponse")
4199 }
4200
4201 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidateSourceResponse, V::Error>
4202 where
4203 V: serde::de::MapAccess<'de>,
4204 {
4205 let mut error__ = None;
4206 while let Some(k) = map_.next_key()? {
4207 match k {
4208 GeneratedField::Error => {
4209 if error__.is_some() {
4210 return Err(serde::de::Error::duplicate_field("error"));
4211 }
4212 error__ = map_.next_value()?;
4213 }
4214 }
4215 }
4216 Ok(ValidateSourceResponse {
4217 error: error__,
4218 })
4219 }
4220 }
4221 deserializer.deserialize_struct("connector_service.ValidateSourceResponse", FIELDS, GeneratedVisitor)
4222 }
4223}
4224impl serde::Serialize for ValidationError {
4225 #[allow(deprecated)]
4226 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4227 where
4228 S: serde::Serializer,
4229 {
4230 use serde::ser::SerializeStruct;
4231 let mut len = 0;
4232 if !self.error_message.is_empty() {
4233 len += 1;
4234 }
4235 let mut struct_ser = serializer.serialize_struct("connector_service.ValidationError", len)?;
4236 if !self.error_message.is_empty() {
4237 struct_ser.serialize_field("errorMessage", &self.error_message)?;
4238 }
4239 struct_ser.end()
4240 }
4241}
4242impl<'de> serde::Deserialize<'de> for ValidationError {
4243 #[allow(deprecated)]
4244 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4245 where
4246 D: serde::Deserializer<'de>,
4247 {
4248 const FIELDS: &[&str] = &[
4249 "error_message",
4250 "errorMessage",
4251 ];
4252
4253 #[allow(clippy::enum_variant_names)]
4254 enum GeneratedField {
4255 ErrorMessage,
4256 }
4257 impl<'de> serde::Deserialize<'de> for GeneratedField {
4258 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4259 where
4260 D: serde::Deserializer<'de>,
4261 {
4262 struct GeneratedVisitor;
4263
4264 impl serde::de::Visitor<'_> for GeneratedVisitor {
4265 type Value = GeneratedField;
4266
4267 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4268 write!(formatter, "expected one of: {:?}", &FIELDS)
4269 }
4270
4271 #[allow(unused_variables)]
4272 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4273 where
4274 E: serde::de::Error,
4275 {
4276 match value {
4277 "errorMessage" | "error_message" => Ok(GeneratedField::ErrorMessage),
4278 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4279 }
4280 }
4281 }
4282 deserializer.deserialize_identifier(GeneratedVisitor)
4283 }
4284 }
4285 struct GeneratedVisitor;
4286 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4287 type Value = ValidationError;
4288
4289 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4290 formatter.write_str("struct connector_service.ValidationError")
4291 }
4292
4293 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidationError, V::Error>
4294 where
4295 V: serde::de::MapAccess<'de>,
4296 {
4297 let mut error_message__ = None;
4298 while let Some(k) = map_.next_key()? {
4299 match k {
4300 GeneratedField::ErrorMessage => {
4301 if error_message__.is_some() {
4302 return Err(serde::de::Error::duplicate_field("errorMessage"));
4303 }
4304 error_message__ = Some(map_.next_value()?);
4305 }
4306 }
4307 }
4308 Ok(ValidationError {
4309 error_message: error_message__.unwrap_or_default(),
4310 })
4311 }
4312 }
4313 deserializer.deserialize_struct("connector_service.ValidationError", FIELDS, GeneratedVisitor)
4314 }
4315}