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