1#![allow(clippy::useless_conversion)]
2#![allow(clippy::useless_borrows_in_formatting)]
3use crate::task_service::*;
4impl serde::Serialize for CancelTaskRequest {
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.task_id.is_some() {
13 len += 1;
14 }
15 let mut struct_ser = serializer.serialize_struct("task_service.CancelTaskRequest", len)?;
16 if let Some(v) = self.task_id.as_ref() {
17 struct_ser.serialize_field("taskId", v)?;
18 }
19 struct_ser.end()
20 }
21}
22impl<'de> serde::Deserialize<'de> for CancelTaskRequest {
23 #[allow(deprecated)]
24 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
25 where
26 D: serde::Deserializer<'de>,
27 {
28 const FIELDS: &[&str] = &[
29 "task_id",
30 "taskId",
31 ];
32
33 #[allow(clippy::enum_variant_names)]
34 enum GeneratedField {
35 TaskId,
36 }
37 impl<'de> serde::Deserialize<'de> for GeneratedField {
38 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
39 where
40 D: serde::Deserializer<'de>,
41 {
42 struct GeneratedVisitor;
43
44 impl serde::de::Visitor<'_> for GeneratedVisitor {
45 type Value = GeneratedField;
46
47 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
48 write!(formatter, "expected one of: {:?}", &FIELDS)
49 }
50
51 #[allow(unused_variables)]
52 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
53 where
54 E: serde::de::Error,
55 {
56 match value {
57 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
58 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
59 }
60 }
61 }
62 deserializer.deserialize_identifier(GeneratedVisitor)
63 }
64 }
65 struct GeneratedVisitor;
66 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
67 type Value = CancelTaskRequest;
68
69 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
70 formatter.write_str("struct task_service.CancelTaskRequest")
71 }
72
73 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelTaskRequest, V::Error>
74 where
75 V: serde::de::MapAccess<'de>,
76 {
77 let mut task_id__ = None;
78 while let Some(k) = map_.next_key()? {
79 match k {
80 GeneratedField::TaskId => {
81 if task_id__.is_some() {
82 return Err(serde::de::Error::duplicate_field("taskId"));
83 }
84 task_id__ = map_.next_value()?;
85 }
86 }
87 }
88 Ok(CancelTaskRequest {
89 task_id: task_id__,
90 })
91 }
92 }
93 deserializer.deserialize_struct("task_service.CancelTaskRequest", FIELDS, GeneratedVisitor)
94 }
95}
96impl serde::Serialize for CancelTaskResponse {
97 #[allow(deprecated)]
98 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
99 where
100 S: serde::Serializer,
101 {
102 use serde::ser::SerializeStruct;
103 let mut len = 0;
104 if self.status.is_some() {
105 len += 1;
106 }
107 let mut struct_ser = serializer.serialize_struct("task_service.CancelTaskResponse", len)?;
108 if let Some(v) = self.status.as_ref() {
109 struct_ser.serialize_field("status", v)?;
110 }
111 struct_ser.end()
112 }
113}
114impl<'de> serde::Deserialize<'de> for CancelTaskResponse {
115 #[allow(deprecated)]
116 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
117 where
118 D: serde::Deserializer<'de>,
119 {
120 const FIELDS: &[&str] = &[
121 "status",
122 ];
123
124 #[allow(clippy::enum_variant_names)]
125 enum GeneratedField {
126 Status,
127 }
128 impl<'de> serde::Deserialize<'de> for GeneratedField {
129 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
130 where
131 D: serde::Deserializer<'de>,
132 {
133 struct GeneratedVisitor;
134
135 impl serde::de::Visitor<'_> for GeneratedVisitor {
136 type Value = GeneratedField;
137
138 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
139 write!(formatter, "expected one of: {:?}", &FIELDS)
140 }
141
142 #[allow(unused_variables)]
143 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
144 where
145 E: serde::de::Error,
146 {
147 match value {
148 "status" => Ok(GeneratedField::Status),
149 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
150 }
151 }
152 }
153 deserializer.deserialize_identifier(GeneratedVisitor)
154 }
155 }
156 struct GeneratedVisitor;
157 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
158 type Value = CancelTaskResponse;
159
160 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
161 formatter.write_str("struct task_service.CancelTaskResponse")
162 }
163
164 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelTaskResponse, V::Error>
165 where
166 V: serde::de::MapAccess<'de>,
167 {
168 let mut status__ = None;
169 while let Some(k) = map_.next_key()? {
170 match k {
171 GeneratedField::Status => {
172 if status__.is_some() {
173 return Err(serde::de::Error::duplicate_field("status"));
174 }
175 status__ = map_.next_value()?;
176 }
177 }
178 }
179 Ok(CancelTaskResponse {
180 status: status__,
181 })
182 }
183 }
184 deserializer.deserialize_struct("task_service.CancelTaskResponse", FIELDS, GeneratedVisitor)
185 }
186}
187impl serde::Serialize for CreateTaskRequest {
188 #[allow(deprecated)]
189 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
190 where
191 S: serde::Serializer,
192 {
193 use serde::ser::SerializeStruct;
194 let mut len = 0;
195 if self.task_id.is_some() {
196 len += 1;
197 }
198 if self.plan.is_some() {
199 len += 1;
200 }
201 if !self.tracing_context.is_empty() {
202 len += 1;
203 }
204 if self.expr_context.is_some() {
205 len += 1;
206 }
207 let mut struct_ser = serializer.serialize_struct("task_service.CreateTaskRequest", len)?;
208 if let Some(v) = self.task_id.as_ref() {
209 struct_ser.serialize_field("taskId", v)?;
210 }
211 if let Some(v) = self.plan.as_ref() {
212 struct_ser.serialize_field("plan", v)?;
213 }
214 if !self.tracing_context.is_empty() {
215 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
216 }
217 if let Some(v) = self.expr_context.as_ref() {
218 struct_ser.serialize_field("exprContext", v)?;
219 }
220 struct_ser.end()
221 }
222}
223impl<'de> serde::Deserialize<'de> for CreateTaskRequest {
224 #[allow(deprecated)]
225 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
226 where
227 D: serde::Deserializer<'de>,
228 {
229 const FIELDS: &[&str] = &[
230 "task_id",
231 "taskId",
232 "plan",
233 "tracing_context",
234 "tracingContext",
235 "expr_context",
236 "exprContext",
237 ];
238
239 #[allow(clippy::enum_variant_names)]
240 enum GeneratedField {
241 TaskId,
242 Plan,
243 TracingContext,
244 ExprContext,
245 }
246 impl<'de> serde::Deserialize<'de> for GeneratedField {
247 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
248 where
249 D: serde::Deserializer<'de>,
250 {
251 struct GeneratedVisitor;
252
253 impl serde::de::Visitor<'_> for GeneratedVisitor {
254 type Value = GeneratedField;
255
256 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
257 write!(formatter, "expected one of: {:?}", &FIELDS)
258 }
259
260 #[allow(unused_variables)]
261 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
262 where
263 E: serde::de::Error,
264 {
265 match value {
266 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
267 "plan" => Ok(GeneratedField::Plan),
268 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
269 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
270 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
271 }
272 }
273 }
274 deserializer.deserialize_identifier(GeneratedVisitor)
275 }
276 }
277 struct GeneratedVisitor;
278 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
279 type Value = CreateTaskRequest;
280
281 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
282 formatter.write_str("struct task_service.CreateTaskRequest")
283 }
284
285 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTaskRequest, V::Error>
286 where
287 V: serde::de::MapAccess<'de>,
288 {
289 let mut task_id__ = None;
290 let mut plan__ = None;
291 let mut tracing_context__ = None;
292 let mut expr_context__ = None;
293 while let Some(k) = map_.next_key()? {
294 match k {
295 GeneratedField::TaskId => {
296 if task_id__.is_some() {
297 return Err(serde::de::Error::duplicate_field("taskId"));
298 }
299 task_id__ = map_.next_value()?;
300 }
301 GeneratedField::Plan => {
302 if plan__.is_some() {
303 return Err(serde::de::Error::duplicate_field("plan"));
304 }
305 plan__ = map_.next_value()?;
306 }
307 GeneratedField::TracingContext => {
308 if tracing_context__.is_some() {
309 return Err(serde::de::Error::duplicate_field("tracingContext"));
310 }
311 tracing_context__ = Some(
312 map_.next_value::<std::collections::HashMap<_, _>>()?
313 );
314 }
315 GeneratedField::ExprContext => {
316 if expr_context__.is_some() {
317 return Err(serde::de::Error::duplicate_field("exprContext"));
318 }
319 expr_context__ = map_.next_value()?;
320 }
321 }
322 }
323 Ok(CreateTaskRequest {
324 task_id: task_id__,
325 plan: plan__,
326 tracing_context: tracing_context__.unwrap_or_default(),
327 expr_context: expr_context__,
328 })
329 }
330 }
331 deserializer.deserialize_struct("task_service.CreateTaskRequest", FIELDS, GeneratedVisitor)
332 }
333}
334impl serde::Serialize for ExecuteRequest {
335 #[allow(deprecated)]
336 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
337 where
338 S: serde::Serializer,
339 {
340 use serde::ser::SerializeStruct;
341 let mut len = 0;
342 if self.task_id.is_some() {
343 len += 1;
344 }
345 if self.plan.is_some() {
346 len += 1;
347 }
348 if !self.tracing_context.is_empty() {
349 len += 1;
350 }
351 if self.expr_context.is_some() {
352 len += 1;
353 }
354 let mut struct_ser = serializer.serialize_struct("task_service.ExecuteRequest", len)?;
355 if let Some(v) = self.task_id.as_ref() {
356 struct_ser.serialize_field("taskId", v)?;
357 }
358 if let Some(v) = self.plan.as_ref() {
359 struct_ser.serialize_field("plan", v)?;
360 }
361 if !self.tracing_context.is_empty() {
362 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
363 }
364 if let Some(v) = self.expr_context.as_ref() {
365 struct_ser.serialize_field("exprContext", v)?;
366 }
367 struct_ser.end()
368 }
369}
370impl<'de> serde::Deserialize<'de> for ExecuteRequest {
371 #[allow(deprecated)]
372 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
373 where
374 D: serde::Deserializer<'de>,
375 {
376 const FIELDS: &[&str] = &[
377 "task_id",
378 "taskId",
379 "plan",
380 "tracing_context",
381 "tracingContext",
382 "expr_context",
383 "exprContext",
384 ];
385
386 #[allow(clippy::enum_variant_names)]
387 enum GeneratedField {
388 TaskId,
389 Plan,
390 TracingContext,
391 ExprContext,
392 }
393 impl<'de> serde::Deserialize<'de> for GeneratedField {
394 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
395 where
396 D: serde::Deserializer<'de>,
397 {
398 struct GeneratedVisitor;
399
400 impl serde::de::Visitor<'_> for GeneratedVisitor {
401 type Value = GeneratedField;
402
403 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
404 write!(formatter, "expected one of: {:?}", &FIELDS)
405 }
406
407 #[allow(unused_variables)]
408 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
409 where
410 E: serde::de::Error,
411 {
412 match value {
413 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
414 "plan" => Ok(GeneratedField::Plan),
415 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
416 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
417 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
418 }
419 }
420 }
421 deserializer.deserialize_identifier(GeneratedVisitor)
422 }
423 }
424 struct GeneratedVisitor;
425 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
426 type Value = ExecuteRequest;
427
428 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
429 formatter.write_str("struct task_service.ExecuteRequest")
430 }
431
432 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExecuteRequest, V::Error>
433 where
434 V: serde::de::MapAccess<'de>,
435 {
436 let mut task_id__ = None;
437 let mut plan__ = None;
438 let mut tracing_context__ = None;
439 let mut expr_context__ = None;
440 while let Some(k) = map_.next_key()? {
441 match k {
442 GeneratedField::TaskId => {
443 if task_id__.is_some() {
444 return Err(serde::de::Error::duplicate_field("taskId"));
445 }
446 task_id__ = map_.next_value()?;
447 }
448 GeneratedField::Plan => {
449 if plan__.is_some() {
450 return Err(serde::de::Error::duplicate_field("plan"));
451 }
452 plan__ = map_.next_value()?;
453 }
454 GeneratedField::TracingContext => {
455 if tracing_context__.is_some() {
456 return Err(serde::de::Error::duplicate_field("tracingContext"));
457 }
458 tracing_context__ = Some(
459 map_.next_value::<std::collections::HashMap<_, _>>()?
460 );
461 }
462 GeneratedField::ExprContext => {
463 if expr_context__.is_some() {
464 return Err(serde::de::Error::duplicate_field("exprContext"));
465 }
466 expr_context__ = map_.next_value()?;
467 }
468 }
469 }
470 Ok(ExecuteRequest {
471 task_id: task_id__,
472 plan: plan__,
473 tracing_context: tracing_context__.unwrap_or_default(),
474 expr_context: expr_context__,
475 })
476 }
477 }
478 deserializer.deserialize_struct("task_service.ExecuteRequest", FIELDS, GeneratedVisitor)
479 }
480}
481impl serde::Serialize for FastInsertRequest {
482 #[allow(deprecated)]
483 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
484 where
485 S: serde::Serializer,
486 {
487 use serde::ser::SerializeStruct;
488 let mut len = 0;
489 if self.table_id != 0 {
490 len += 1;
491 }
492 if self.table_version_id != 0 {
493 len += 1;
494 }
495 if self.data_chunk.is_some() {
496 len += 1;
497 }
498 if self.row_id_index.is_some() {
499 len += 1;
500 }
501 if self.request_id != 0 {
502 len += 1;
503 }
504 if self.wait_for_persistence {
505 len += 1;
506 }
507 let mut struct_ser = serializer.serialize_struct("task_service.FastInsertRequest", len)?;
508 if self.table_id != 0 {
509 struct_ser.serialize_field("tableId", &self.table_id)?;
510 }
511 if self.table_version_id != 0 {
512 #[allow(clippy::needless_borrow)]
513 #[allow(clippy::needless_borrows_for_generic_args)]
514 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
515 }
516 if let Some(v) = self.data_chunk.as_ref() {
517 struct_ser.serialize_field("dataChunk", v)?;
518 }
519 if let Some(v) = self.row_id_index.as_ref() {
520 struct_ser.serialize_field("rowIdIndex", v)?;
521 }
522 if self.request_id != 0 {
523 struct_ser.serialize_field("requestId", &self.request_id)?;
524 }
525 if self.wait_for_persistence {
526 struct_ser.serialize_field("waitForPersistence", &self.wait_for_persistence)?;
527 }
528 struct_ser.end()
529 }
530}
531impl<'de> serde::Deserialize<'de> for FastInsertRequest {
532 #[allow(deprecated)]
533 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
534 where
535 D: serde::Deserializer<'de>,
536 {
537 const FIELDS: &[&str] = &[
538 "table_id",
539 "tableId",
540 "table_version_id",
541 "tableVersionId",
542 "data_chunk",
543 "dataChunk",
544 "row_id_index",
545 "rowIdIndex",
546 "request_id",
547 "requestId",
548 "wait_for_persistence",
549 "waitForPersistence",
550 ];
551
552 #[allow(clippy::enum_variant_names)]
553 enum GeneratedField {
554 TableId,
555 TableVersionId,
556 DataChunk,
557 RowIdIndex,
558 RequestId,
559 WaitForPersistence,
560 }
561 impl<'de> serde::Deserialize<'de> for GeneratedField {
562 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
563 where
564 D: serde::Deserializer<'de>,
565 {
566 struct GeneratedVisitor;
567
568 impl serde::de::Visitor<'_> for GeneratedVisitor {
569 type Value = GeneratedField;
570
571 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
572 write!(formatter, "expected one of: {:?}", &FIELDS)
573 }
574
575 #[allow(unused_variables)]
576 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
577 where
578 E: serde::de::Error,
579 {
580 match value {
581 "tableId" | "table_id" => Ok(GeneratedField::TableId),
582 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
583 "dataChunk" | "data_chunk" => Ok(GeneratedField::DataChunk),
584 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
585 "requestId" | "request_id" => Ok(GeneratedField::RequestId),
586 "waitForPersistence" | "wait_for_persistence" => Ok(GeneratedField::WaitForPersistence),
587 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
588 }
589 }
590 }
591 deserializer.deserialize_identifier(GeneratedVisitor)
592 }
593 }
594 struct GeneratedVisitor;
595 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
596 type Value = FastInsertRequest;
597
598 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
599 formatter.write_str("struct task_service.FastInsertRequest")
600 }
601
602 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FastInsertRequest, V::Error>
603 where
604 V: serde::de::MapAccess<'de>,
605 {
606 let mut table_id__ = None;
607 let mut table_version_id__ = None;
608 let mut data_chunk__ = None;
609 let mut row_id_index__ = None;
610 let mut request_id__ = None;
611 let mut wait_for_persistence__ = None;
612 while let Some(k) = map_.next_key()? {
613 match k {
614 GeneratedField::TableId => {
615 if table_id__.is_some() {
616 return Err(serde::de::Error::duplicate_field("tableId"));
617 }
618 table_id__ =
619 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
620 ;
621 }
622 GeneratedField::TableVersionId => {
623 if table_version_id__.is_some() {
624 return Err(serde::de::Error::duplicate_field("tableVersionId"));
625 }
626 table_version_id__ =
627 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
628 ;
629 }
630 GeneratedField::DataChunk => {
631 if data_chunk__.is_some() {
632 return Err(serde::de::Error::duplicate_field("dataChunk"));
633 }
634 data_chunk__ = map_.next_value()?;
635 }
636 GeneratedField::RowIdIndex => {
637 if row_id_index__.is_some() {
638 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
639 }
640 row_id_index__ =
641 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
642 ;
643 }
644 GeneratedField::RequestId => {
645 if request_id__.is_some() {
646 return Err(serde::de::Error::duplicate_field("requestId"));
647 }
648 request_id__ =
649 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
650 ;
651 }
652 GeneratedField::WaitForPersistence => {
653 if wait_for_persistence__.is_some() {
654 return Err(serde::de::Error::duplicate_field("waitForPersistence"));
655 }
656 wait_for_persistence__ = Some(map_.next_value()?);
657 }
658 }
659 }
660 Ok(FastInsertRequest {
661 table_id: table_id__.unwrap_or_default(),
662 table_version_id: table_version_id__.unwrap_or_default(),
663 data_chunk: data_chunk__,
664 row_id_index: row_id_index__,
665 request_id: request_id__.unwrap_or_default(),
666 wait_for_persistence: wait_for_persistence__.unwrap_or_default(),
667 })
668 }
669 }
670 deserializer.deserialize_struct("task_service.FastInsertRequest", FIELDS, GeneratedVisitor)
671 }
672}
673impl serde::Serialize for FastInsertResponse {
674 #[allow(deprecated)]
675 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
676 where
677 S: serde::Serializer,
678 {
679 use serde::ser::SerializeStruct;
680 let mut len = 0;
681 if self.status != 0 {
682 len += 1;
683 }
684 if !self.error_message.is_empty() {
685 len += 1;
686 }
687 let mut struct_ser = serializer.serialize_struct("task_service.FastInsertResponse", len)?;
688 if self.status != 0 {
689 let v = fast_insert_response::Status::try_from(self.status)
690 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.status)))?;
691 struct_ser.serialize_field("status", &v)?;
692 }
693 if !self.error_message.is_empty() {
694 struct_ser.serialize_field("errorMessage", &self.error_message)?;
695 }
696 struct_ser.end()
697 }
698}
699impl<'de> serde::Deserialize<'de> for FastInsertResponse {
700 #[allow(deprecated)]
701 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
702 where
703 D: serde::Deserializer<'de>,
704 {
705 const FIELDS: &[&str] = &[
706 "status",
707 "error_message",
708 "errorMessage",
709 ];
710
711 #[allow(clippy::enum_variant_names)]
712 enum GeneratedField {
713 Status,
714 ErrorMessage,
715 }
716 impl<'de> serde::Deserialize<'de> for GeneratedField {
717 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
718 where
719 D: serde::Deserializer<'de>,
720 {
721 struct GeneratedVisitor;
722
723 impl serde::de::Visitor<'_> for GeneratedVisitor {
724 type Value = GeneratedField;
725
726 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
727 write!(formatter, "expected one of: {:?}", &FIELDS)
728 }
729
730 #[allow(unused_variables)]
731 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
732 where
733 E: serde::de::Error,
734 {
735 match value {
736 "status" => Ok(GeneratedField::Status),
737 "errorMessage" | "error_message" => Ok(GeneratedField::ErrorMessage),
738 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
739 }
740 }
741 }
742 deserializer.deserialize_identifier(GeneratedVisitor)
743 }
744 }
745 struct GeneratedVisitor;
746 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
747 type Value = FastInsertResponse;
748
749 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
750 formatter.write_str("struct task_service.FastInsertResponse")
751 }
752
753 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FastInsertResponse, V::Error>
754 where
755 V: serde::de::MapAccess<'de>,
756 {
757 let mut status__ = None;
758 let mut error_message__ = None;
759 while let Some(k) = map_.next_key()? {
760 match k {
761 GeneratedField::Status => {
762 if status__.is_some() {
763 return Err(serde::de::Error::duplicate_field("status"));
764 }
765 status__ = Some(map_.next_value::<fast_insert_response::Status>()? as i32);
766 }
767 GeneratedField::ErrorMessage => {
768 if error_message__.is_some() {
769 return Err(serde::de::Error::duplicate_field("errorMessage"));
770 }
771 error_message__ = Some(map_.next_value()?);
772 }
773 }
774 }
775 Ok(FastInsertResponse {
776 status: status__.unwrap_or_default(),
777 error_message: error_message__.unwrap_or_default(),
778 })
779 }
780 }
781 deserializer.deserialize_struct("task_service.FastInsertResponse", FIELDS, GeneratedVisitor)
782 }
783}
784impl serde::Serialize for fast_insert_response::Status {
785 #[allow(deprecated)]
786 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
787 where
788 S: serde::Serializer,
789 {
790 let variant = match self {
791 Self::Unspecified => "UNSPECIFIED",
792 Self::Succeeded => "SUCCEEDED",
793 Self::DmlFailed => "DML_FAILED",
794 };
795 serializer.serialize_str(variant)
796 }
797}
798impl<'de> serde::Deserialize<'de> for fast_insert_response::Status {
799 #[allow(deprecated)]
800 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
801 where
802 D: serde::Deserializer<'de>,
803 {
804 const FIELDS: &[&str] = &[
805 "UNSPECIFIED",
806 "SUCCEEDED",
807 "DML_FAILED",
808 ];
809
810 struct GeneratedVisitor;
811
812 impl serde::de::Visitor<'_> for GeneratedVisitor {
813 type Value = fast_insert_response::Status;
814
815 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
816 write!(formatter, "expected one of: {:?}", &FIELDS)
817 }
818
819 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
820 where
821 E: serde::de::Error,
822 {
823 i32::try_from(v)
824 .ok()
825 .and_then(|x| x.try_into().ok())
826 .ok_or_else(|| {
827 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
828 })
829 }
830
831 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
832 where
833 E: serde::de::Error,
834 {
835 i32::try_from(v)
836 .ok()
837 .and_then(|x| x.try_into().ok())
838 .ok_or_else(|| {
839 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
840 })
841 }
842
843 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
844 where
845 E: serde::de::Error,
846 {
847 match value {
848 "UNSPECIFIED" => Ok(fast_insert_response::Status::Unspecified),
849 "SUCCEEDED" => Ok(fast_insert_response::Status::Succeeded),
850 "DML_FAILED" => Ok(fast_insert_response::Status::DmlFailed),
851 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
852 }
853 }
854 }
855 deserializer.deserialize_any(GeneratedVisitor)
856 }
857}
858impl serde::Serialize for GetDataRequest {
859 #[allow(deprecated)]
860 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
861 where
862 S: serde::Serializer,
863 {
864 use serde::ser::SerializeStruct;
865 let mut len = 0;
866 if self.task_output_id.is_some() {
867 len += 1;
868 }
869 let mut struct_ser = serializer.serialize_struct("task_service.GetDataRequest", len)?;
870 if let Some(v) = self.task_output_id.as_ref() {
871 struct_ser.serialize_field("taskOutputId", v)?;
872 }
873 struct_ser.end()
874 }
875}
876impl<'de> serde::Deserialize<'de> for GetDataRequest {
877 #[allow(deprecated)]
878 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
879 where
880 D: serde::Deserializer<'de>,
881 {
882 const FIELDS: &[&str] = &[
883 "task_output_id",
884 "taskOutputId",
885 ];
886
887 #[allow(clippy::enum_variant_names)]
888 enum GeneratedField {
889 TaskOutputId,
890 }
891 impl<'de> serde::Deserialize<'de> for GeneratedField {
892 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
893 where
894 D: serde::Deserializer<'de>,
895 {
896 struct GeneratedVisitor;
897
898 impl serde::de::Visitor<'_> for GeneratedVisitor {
899 type Value = GeneratedField;
900
901 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
902 write!(formatter, "expected one of: {:?}", &FIELDS)
903 }
904
905 #[allow(unused_variables)]
906 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
907 where
908 E: serde::de::Error,
909 {
910 match value {
911 "taskOutputId" | "task_output_id" => Ok(GeneratedField::TaskOutputId),
912 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
913 }
914 }
915 }
916 deserializer.deserialize_identifier(GeneratedVisitor)
917 }
918 }
919 struct GeneratedVisitor;
920 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
921 type Value = GetDataRequest;
922
923 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
924 formatter.write_str("struct task_service.GetDataRequest")
925 }
926
927 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDataRequest, V::Error>
928 where
929 V: serde::de::MapAccess<'de>,
930 {
931 let mut task_output_id__ = None;
932 while let Some(k) = map_.next_key()? {
933 match k {
934 GeneratedField::TaskOutputId => {
935 if task_output_id__.is_some() {
936 return Err(serde::de::Error::duplicate_field("taskOutputId"));
937 }
938 task_output_id__ = map_.next_value()?;
939 }
940 }
941 }
942 Ok(GetDataRequest {
943 task_output_id: task_output_id__,
944 })
945 }
946 }
947 deserializer.deserialize_struct("task_service.GetDataRequest", FIELDS, GeneratedVisitor)
948 }
949}
950impl serde::Serialize for GetDataResponse {
951 #[allow(deprecated)]
952 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
953 where
954 S: serde::Serializer,
955 {
956 use serde::ser::SerializeStruct;
957 let mut len = 0;
958 if self.record_batch.is_some() {
959 len += 1;
960 }
961 let mut struct_ser = serializer.serialize_struct("task_service.GetDataResponse", len)?;
962 if let Some(v) = self.record_batch.as_ref() {
963 struct_ser.serialize_field("recordBatch", v)?;
964 }
965 struct_ser.end()
966 }
967}
968impl<'de> serde::Deserialize<'de> for GetDataResponse {
969 #[allow(deprecated)]
970 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
971 where
972 D: serde::Deserializer<'de>,
973 {
974 const FIELDS: &[&str] = &[
975 "record_batch",
976 "recordBatch",
977 ];
978
979 #[allow(clippy::enum_variant_names)]
980 enum GeneratedField {
981 RecordBatch,
982 }
983 impl<'de> serde::Deserialize<'de> for GeneratedField {
984 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
985 where
986 D: serde::Deserializer<'de>,
987 {
988 struct GeneratedVisitor;
989
990 impl serde::de::Visitor<'_> for GeneratedVisitor {
991 type Value = GeneratedField;
992
993 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
994 write!(formatter, "expected one of: {:?}", &FIELDS)
995 }
996
997 #[allow(unused_variables)]
998 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
999 where
1000 E: serde::de::Error,
1001 {
1002 match value {
1003 "recordBatch" | "record_batch" => Ok(GeneratedField::RecordBatch),
1004 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1005 }
1006 }
1007 }
1008 deserializer.deserialize_identifier(GeneratedVisitor)
1009 }
1010 }
1011 struct GeneratedVisitor;
1012 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1013 type Value = GetDataResponse;
1014
1015 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1016 formatter.write_str("struct task_service.GetDataResponse")
1017 }
1018
1019 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDataResponse, V::Error>
1020 where
1021 V: serde::de::MapAccess<'de>,
1022 {
1023 let mut record_batch__ = None;
1024 while let Some(k) = map_.next_key()? {
1025 match k {
1026 GeneratedField::RecordBatch => {
1027 if record_batch__.is_some() {
1028 return Err(serde::de::Error::duplicate_field("recordBatch"));
1029 }
1030 record_batch__ = map_.next_value()?;
1031 }
1032 }
1033 }
1034 Ok(GetDataResponse {
1035 record_batch: record_batch__,
1036 })
1037 }
1038 }
1039 deserializer.deserialize_struct("task_service.GetDataResponse", FIELDS, GeneratedVisitor)
1040 }
1041}
1042impl serde::Serialize for GetStreamRequest {
1043 #[allow(deprecated)]
1044 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1045 where
1046 S: serde::Serializer,
1047 {
1048 use serde::ser::SerializeStruct;
1049 let mut len = 0;
1050 if self.value.is_some() {
1051 len += 1;
1052 }
1053 let mut struct_ser = serializer.serialize_struct("task_service.GetStreamRequest", len)?;
1054 if let Some(v) = self.value.as_ref() {
1055 match v {
1056 get_stream_request::Value::Get(v) => {
1057 struct_ser.serialize_field("get", v)?;
1058 }
1059 get_stream_request::Value::AddPermits(v) => {
1060 struct_ser.serialize_field("addPermits", v)?;
1061 }
1062 }
1063 }
1064 struct_ser.end()
1065 }
1066}
1067impl<'de> serde::Deserialize<'de> for GetStreamRequest {
1068 #[allow(deprecated)]
1069 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1070 where
1071 D: serde::Deserializer<'de>,
1072 {
1073 const FIELDS: &[&str] = &[
1074 "get",
1075 "add_permits",
1076 "addPermits",
1077 ];
1078
1079 #[allow(clippy::enum_variant_names)]
1080 enum GeneratedField {
1081 Get,
1082 AddPermits,
1083 }
1084 impl<'de> serde::Deserialize<'de> for GeneratedField {
1085 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1086 where
1087 D: serde::Deserializer<'de>,
1088 {
1089 struct GeneratedVisitor;
1090
1091 impl serde::de::Visitor<'_> for GeneratedVisitor {
1092 type Value = GeneratedField;
1093
1094 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1095 write!(formatter, "expected one of: {:?}", &FIELDS)
1096 }
1097
1098 #[allow(unused_variables)]
1099 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1100 where
1101 E: serde::de::Error,
1102 {
1103 match value {
1104 "get" => Ok(GeneratedField::Get),
1105 "addPermits" | "add_permits" => Ok(GeneratedField::AddPermits),
1106 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1107 }
1108 }
1109 }
1110 deserializer.deserialize_identifier(GeneratedVisitor)
1111 }
1112 }
1113 struct GeneratedVisitor;
1114 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1115 type Value = GetStreamRequest;
1116
1117 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1118 formatter.write_str("struct task_service.GetStreamRequest")
1119 }
1120
1121 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetStreamRequest, V::Error>
1122 where
1123 V: serde::de::MapAccess<'de>,
1124 {
1125 let mut value__ = None;
1126 while let Some(k) = map_.next_key()? {
1127 match k {
1128 GeneratedField::Get => {
1129 if value__.is_some() {
1130 return Err(serde::de::Error::duplicate_field("get"));
1131 }
1132 value__ = map_.next_value::<::std::option::Option<_>>()?.map(get_stream_request::Value::Get)
1133;
1134 }
1135 GeneratedField::AddPermits => {
1136 if value__.is_some() {
1137 return Err(serde::de::Error::duplicate_field("addPermits"));
1138 }
1139 value__ = map_.next_value::<::std::option::Option<_>>()?.map(get_stream_request::Value::AddPermits)
1140;
1141 }
1142 }
1143 }
1144 Ok(GetStreamRequest {
1145 value: value__,
1146 })
1147 }
1148 }
1149 deserializer.deserialize_struct("task_service.GetStreamRequest", FIELDS, GeneratedVisitor)
1150 }
1151}
1152impl serde::Serialize for get_stream_request::Get {
1153 #[allow(deprecated)]
1154 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1155 where
1156 S: serde::Serializer,
1157 {
1158 use serde::ser::SerializeStruct;
1159 let mut len = 0;
1160 if self.up_actor_id != 0 {
1161 len += 1;
1162 }
1163 if self.down_actor_id != 0 {
1164 len += 1;
1165 }
1166 if self.up_fragment_id != 0 {
1167 len += 1;
1168 }
1169 if self.down_fragment_id != 0 {
1170 len += 1;
1171 }
1172 if self.up_partial_graph_id != 0 {
1173 len += 1;
1174 }
1175 if !self.term_id.is_empty() {
1176 len += 1;
1177 }
1178 let mut struct_ser = serializer.serialize_struct("task_service.GetStreamRequest.Get", len)?;
1179 if self.up_actor_id != 0 {
1180 struct_ser.serialize_field("upActorId", &self.up_actor_id)?;
1181 }
1182 if self.down_actor_id != 0 {
1183 struct_ser.serialize_field("downActorId", &self.down_actor_id)?;
1184 }
1185 if self.up_fragment_id != 0 {
1186 struct_ser.serialize_field("upFragmentId", &self.up_fragment_id)?;
1187 }
1188 if self.down_fragment_id != 0 {
1189 struct_ser.serialize_field("downFragmentId", &self.down_fragment_id)?;
1190 }
1191 if self.up_partial_graph_id != 0 {
1192 #[allow(clippy::needless_borrow)]
1193 #[allow(clippy::needless_borrows_for_generic_args)]
1194 struct_ser.serialize_field("upPartialGraphId", ToString::to_string(&self.up_partial_graph_id).as_str())?;
1195 }
1196 if !self.term_id.is_empty() {
1197 struct_ser.serialize_field("termId", &self.term_id)?;
1198 }
1199 struct_ser.end()
1200 }
1201}
1202impl<'de> serde::Deserialize<'de> for get_stream_request::Get {
1203 #[allow(deprecated)]
1204 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1205 where
1206 D: serde::Deserializer<'de>,
1207 {
1208 const FIELDS: &[&str] = &[
1209 "up_actor_id",
1210 "upActorId",
1211 "down_actor_id",
1212 "downActorId",
1213 "up_fragment_id",
1214 "upFragmentId",
1215 "down_fragment_id",
1216 "downFragmentId",
1217 "up_partial_graph_id",
1218 "upPartialGraphId",
1219 "term_id",
1220 "termId",
1221 ];
1222
1223 #[allow(clippy::enum_variant_names)]
1224 enum GeneratedField {
1225 UpActorId,
1226 DownActorId,
1227 UpFragmentId,
1228 DownFragmentId,
1229 UpPartialGraphId,
1230 TermId,
1231 }
1232 impl<'de> serde::Deserialize<'de> for GeneratedField {
1233 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1234 where
1235 D: serde::Deserializer<'de>,
1236 {
1237 struct GeneratedVisitor;
1238
1239 impl serde::de::Visitor<'_> for GeneratedVisitor {
1240 type Value = GeneratedField;
1241
1242 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1243 write!(formatter, "expected one of: {:?}", &FIELDS)
1244 }
1245
1246 #[allow(unused_variables)]
1247 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1248 where
1249 E: serde::de::Error,
1250 {
1251 match value {
1252 "upActorId" | "up_actor_id" => Ok(GeneratedField::UpActorId),
1253 "downActorId" | "down_actor_id" => Ok(GeneratedField::DownActorId),
1254 "upFragmentId" | "up_fragment_id" => Ok(GeneratedField::UpFragmentId),
1255 "downFragmentId" | "down_fragment_id" => Ok(GeneratedField::DownFragmentId),
1256 "upPartialGraphId" | "up_partial_graph_id" => Ok(GeneratedField::UpPartialGraphId),
1257 "termId" | "term_id" => Ok(GeneratedField::TermId),
1258 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1259 }
1260 }
1261 }
1262 deserializer.deserialize_identifier(GeneratedVisitor)
1263 }
1264 }
1265 struct GeneratedVisitor;
1266 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1267 type Value = get_stream_request::Get;
1268
1269 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1270 formatter.write_str("struct task_service.GetStreamRequest.Get")
1271 }
1272
1273 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_stream_request::Get, V::Error>
1274 where
1275 V: serde::de::MapAccess<'de>,
1276 {
1277 let mut up_actor_id__ = None;
1278 let mut down_actor_id__ = None;
1279 let mut up_fragment_id__ = None;
1280 let mut down_fragment_id__ = None;
1281 let mut up_partial_graph_id__ = None;
1282 let mut term_id__ = None;
1283 while let Some(k) = map_.next_key()? {
1284 match k {
1285 GeneratedField::UpActorId => {
1286 if up_actor_id__.is_some() {
1287 return Err(serde::de::Error::duplicate_field("upActorId"));
1288 }
1289 up_actor_id__ =
1290 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1291 ;
1292 }
1293 GeneratedField::DownActorId => {
1294 if down_actor_id__.is_some() {
1295 return Err(serde::de::Error::duplicate_field("downActorId"));
1296 }
1297 down_actor_id__ =
1298 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1299 ;
1300 }
1301 GeneratedField::UpFragmentId => {
1302 if up_fragment_id__.is_some() {
1303 return Err(serde::de::Error::duplicate_field("upFragmentId"));
1304 }
1305 up_fragment_id__ =
1306 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1307 ;
1308 }
1309 GeneratedField::DownFragmentId => {
1310 if down_fragment_id__.is_some() {
1311 return Err(serde::de::Error::duplicate_field("downFragmentId"));
1312 }
1313 down_fragment_id__ =
1314 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1315 ;
1316 }
1317 GeneratedField::UpPartialGraphId => {
1318 if up_partial_graph_id__.is_some() {
1319 return Err(serde::de::Error::duplicate_field("upPartialGraphId"));
1320 }
1321 up_partial_graph_id__ =
1322 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1323 ;
1324 }
1325 GeneratedField::TermId => {
1326 if term_id__.is_some() {
1327 return Err(serde::de::Error::duplicate_field("termId"));
1328 }
1329 term_id__ = Some(map_.next_value()?);
1330 }
1331 }
1332 }
1333 Ok(get_stream_request::Get {
1334 up_actor_id: up_actor_id__.unwrap_or_default(),
1335 down_actor_id: down_actor_id__.unwrap_or_default(),
1336 up_fragment_id: up_fragment_id__.unwrap_or_default(),
1337 down_fragment_id: down_fragment_id__.unwrap_or_default(),
1338 up_partial_graph_id: up_partial_graph_id__.unwrap_or_default(),
1339 term_id: term_id__.unwrap_or_default(),
1340 })
1341 }
1342 }
1343 deserializer.deserialize_struct("task_service.GetStreamRequest.Get", FIELDS, GeneratedVisitor)
1344 }
1345}
1346impl serde::Serialize for GetStreamResponse {
1347 #[allow(deprecated)]
1348 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1349 where
1350 S: serde::Serializer,
1351 {
1352 use serde::ser::SerializeStruct;
1353 let mut len = 0;
1354 if self.message.is_some() {
1355 len += 1;
1356 }
1357 if self.permits.is_some() {
1358 len += 1;
1359 }
1360 let mut struct_ser = serializer.serialize_struct("task_service.GetStreamResponse", len)?;
1361 if let Some(v) = self.message.as_ref() {
1362 struct_ser.serialize_field("message", v)?;
1363 }
1364 if let Some(v) = self.permits.as_ref() {
1365 struct_ser.serialize_field("permits", v)?;
1366 }
1367 struct_ser.end()
1368 }
1369}
1370impl<'de> serde::Deserialize<'de> for GetStreamResponse {
1371 #[allow(deprecated)]
1372 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1373 where
1374 D: serde::Deserializer<'de>,
1375 {
1376 const FIELDS: &[&str] = &[
1377 "message",
1378 "permits",
1379 ];
1380
1381 #[allow(clippy::enum_variant_names)]
1382 enum GeneratedField {
1383 Message,
1384 Permits,
1385 }
1386 impl<'de> serde::Deserialize<'de> for GeneratedField {
1387 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1388 where
1389 D: serde::Deserializer<'de>,
1390 {
1391 struct GeneratedVisitor;
1392
1393 impl serde::de::Visitor<'_> for GeneratedVisitor {
1394 type Value = GeneratedField;
1395
1396 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1397 write!(formatter, "expected one of: {:?}", &FIELDS)
1398 }
1399
1400 #[allow(unused_variables)]
1401 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1402 where
1403 E: serde::de::Error,
1404 {
1405 match value {
1406 "message" => Ok(GeneratedField::Message),
1407 "permits" => Ok(GeneratedField::Permits),
1408 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1409 }
1410 }
1411 }
1412 deserializer.deserialize_identifier(GeneratedVisitor)
1413 }
1414 }
1415 struct GeneratedVisitor;
1416 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1417 type Value = GetStreamResponse;
1418
1419 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1420 formatter.write_str("struct task_service.GetStreamResponse")
1421 }
1422
1423 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetStreamResponse, V::Error>
1424 where
1425 V: serde::de::MapAccess<'de>,
1426 {
1427 let mut message__ = None;
1428 let mut permits__ = None;
1429 while let Some(k) = map_.next_key()? {
1430 match k {
1431 GeneratedField::Message => {
1432 if message__.is_some() {
1433 return Err(serde::de::Error::duplicate_field("message"));
1434 }
1435 message__ = map_.next_value()?;
1436 }
1437 GeneratedField::Permits => {
1438 if permits__.is_some() {
1439 return Err(serde::de::Error::duplicate_field("permits"));
1440 }
1441 permits__ = map_.next_value()?;
1442 }
1443 }
1444 }
1445 Ok(GetStreamResponse {
1446 message: message__,
1447 permits: permits__,
1448 })
1449 }
1450 }
1451 deserializer.deserialize_struct("task_service.GetStreamResponse", FIELDS, GeneratedVisitor)
1452 }
1453}
1454impl serde::Serialize for GetTaskInfoRequest {
1455 #[allow(deprecated)]
1456 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1457 where
1458 S: serde::Serializer,
1459 {
1460 use serde::ser::SerializeStruct;
1461 let mut len = 0;
1462 if self.task_id.is_some() {
1463 len += 1;
1464 }
1465 let mut struct_ser = serializer.serialize_struct("task_service.GetTaskInfoRequest", len)?;
1466 if let Some(v) = self.task_id.as_ref() {
1467 struct_ser.serialize_field("taskId", v)?;
1468 }
1469 struct_ser.end()
1470 }
1471}
1472impl<'de> serde::Deserialize<'de> for GetTaskInfoRequest {
1473 #[allow(deprecated)]
1474 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1475 where
1476 D: serde::Deserializer<'de>,
1477 {
1478 const FIELDS: &[&str] = &[
1479 "task_id",
1480 "taskId",
1481 ];
1482
1483 #[allow(clippy::enum_variant_names)]
1484 enum GeneratedField {
1485 TaskId,
1486 }
1487 impl<'de> serde::Deserialize<'de> for GeneratedField {
1488 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1489 where
1490 D: serde::Deserializer<'de>,
1491 {
1492 struct GeneratedVisitor;
1493
1494 impl serde::de::Visitor<'_> for GeneratedVisitor {
1495 type Value = GeneratedField;
1496
1497 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1498 write!(formatter, "expected one of: {:?}", &FIELDS)
1499 }
1500
1501 #[allow(unused_variables)]
1502 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1503 where
1504 E: serde::de::Error,
1505 {
1506 match value {
1507 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
1508 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1509 }
1510 }
1511 }
1512 deserializer.deserialize_identifier(GeneratedVisitor)
1513 }
1514 }
1515 struct GeneratedVisitor;
1516 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1517 type Value = GetTaskInfoRequest;
1518
1519 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1520 formatter.write_str("struct task_service.GetTaskInfoRequest")
1521 }
1522
1523 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTaskInfoRequest, V::Error>
1524 where
1525 V: serde::de::MapAccess<'de>,
1526 {
1527 let mut task_id__ = None;
1528 while let Some(k) = map_.next_key()? {
1529 match k {
1530 GeneratedField::TaskId => {
1531 if task_id__.is_some() {
1532 return Err(serde::de::Error::duplicate_field("taskId"));
1533 }
1534 task_id__ = map_.next_value()?;
1535 }
1536 }
1537 }
1538 Ok(GetTaskInfoRequest {
1539 task_id: task_id__,
1540 })
1541 }
1542 }
1543 deserializer.deserialize_struct("task_service.GetTaskInfoRequest", FIELDS, GeneratedVisitor)
1544 }
1545}
1546impl serde::Serialize for IngestDmlAckResponse {
1547 #[allow(deprecated)]
1548 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1549 where
1550 S: serde::Serializer,
1551 {
1552 use serde::ser::SerializeStruct;
1553 let mut len = 0;
1554 if self.dml_batch_id != 0 {
1555 len += 1;
1556 }
1557 let mut struct_ser = serializer.serialize_struct("task_service.IngestDmlAckResponse", len)?;
1558 if self.dml_batch_id != 0 {
1559 #[allow(clippy::needless_borrow)]
1560 #[allow(clippy::needless_borrows_for_generic_args)]
1561 struct_ser.serialize_field("dmlBatchId", ToString::to_string(&self.dml_batch_id).as_str())?;
1562 }
1563 struct_ser.end()
1564 }
1565}
1566impl<'de> serde::Deserialize<'de> for IngestDmlAckResponse {
1567 #[allow(deprecated)]
1568 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1569 where
1570 D: serde::Deserializer<'de>,
1571 {
1572 const FIELDS: &[&str] = &[
1573 "dml_batch_id",
1574 "dmlBatchId",
1575 ];
1576
1577 #[allow(clippy::enum_variant_names)]
1578 enum GeneratedField {
1579 DmlBatchId,
1580 }
1581 impl<'de> serde::Deserialize<'de> for GeneratedField {
1582 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1583 where
1584 D: serde::Deserializer<'de>,
1585 {
1586 struct GeneratedVisitor;
1587
1588 impl serde::de::Visitor<'_> for GeneratedVisitor {
1589 type Value = GeneratedField;
1590
1591 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1592 write!(formatter, "expected one of: {:?}", &FIELDS)
1593 }
1594
1595 #[allow(unused_variables)]
1596 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1597 where
1598 E: serde::de::Error,
1599 {
1600 match value {
1601 "dmlBatchId" | "dml_batch_id" => Ok(GeneratedField::DmlBatchId),
1602 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1603 }
1604 }
1605 }
1606 deserializer.deserialize_identifier(GeneratedVisitor)
1607 }
1608 }
1609 struct GeneratedVisitor;
1610 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1611 type Value = IngestDmlAckResponse;
1612
1613 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1614 formatter.write_str("struct task_service.IngestDmlAckResponse")
1615 }
1616
1617 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IngestDmlAckResponse, V::Error>
1618 where
1619 V: serde::de::MapAccess<'de>,
1620 {
1621 let mut dml_batch_id__ = None;
1622 while let Some(k) = map_.next_key()? {
1623 match k {
1624 GeneratedField::DmlBatchId => {
1625 if dml_batch_id__.is_some() {
1626 return Err(serde::de::Error::duplicate_field("dmlBatchId"));
1627 }
1628 dml_batch_id__ =
1629 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1630 ;
1631 }
1632 }
1633 }
1634 Ok(IngestDmlAckResponse {
1635 dml_batch_id: dml_batch_id__.unwrap_or_default(),
1636 })
1637 }
1638 }
1639 deserializer.deserialize_struct("task_service.IngestDmlAckResponse", FIELDS, GeneratedVisitor)
1640 }
1641}
1642impl serde::Serialize for IngestDmlInitRequest {
1643 #[allow(deprecated)]
1644 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1645 where
1646 S: serde::Serializer,
1647 {
1648 use serde::ser::SerializeStruct;
1649 let mut len = 0;
1650 if self.table_id != 0 {
1651 len += 1;
1652 }
1653 if self.table_version_id != 0 {
1654 len += 1;
1655 }
1656 if self.request_id != 0 {
1657 len += 1;
1658 }
1659 if self.row_id_index.is_some() {
1660 len += 1;
1661 }
1662 let mut struct_ser = serializer.serialize_struct("task_service.IngestDmlInitRequest", len)?;
1663 if self.table_id != 0 {
1664 struct_ser.serialize_field("tableId", &self.table_id)?;
1665 }
1666 if self.table_version_id != 0 {
1667 #[allow(clippy::needless_borrow)]
1668 #[allow(clippy::needless_borrows_for_generic_args)]
1669 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
1670 }
1671 if self.request_id != 0 {
1672 struct_ser.serialize_field("requestId", &self.request_id)?;
1673 }
1674 if let Some(v) = self.row_id_index.as_ref() {
1675 struct_ser.serialize_field("rowIdIndex", v)?;
1676 }
1677 struct_ser.end()
1678 }
1679}
1680impl<'de> serde::Deserialize<'de> for IngestDmlInitRequest {
1681 #[allow(deprecated)]
1682 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1683 where
1684 D: serde::Deserializer<'de>,
1685 {
1686 const FIELDS: &[&str] = &[
1687 "table_id",
1688 "tableId",
1689 "table_version_id",
1690 "tableVersionId",
1691 "request_id",
1692 "requestId",
1693 "row_id_index",
1694 "rowIdIndex",
1695 ];
1696
1697 #[allow(clippy::enum_variant_names)]
1698 enum GeneratedField {
1699 TableId,
1700 TableVersionId,
1701 RequestId,
1702 RowIdIndex,
1703 }
1704 impl<'de> serde::Deserialize<'de> for GeneratedField {
1705 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1706 where
1707 D: serde::Deserializer<'de>,
1708 {
1709 struct GeneratedVisitor;
1710
1711 impl serde::de::Visitor<'_> for GeneratedVisitor {
1712 type Value = GeneratedField;
1713
1714 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1715 write!(formatter, "expected one of: {:?}", &FIELDS)
1716 }
1717
1718 #[allow(unused_variables)]
1719 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1720 where
1721 E: serde::de::Error,
1722 {
1723 match value {
1724 "tableId" | "table_id" => Ok(GeneratedField::TableId),
1725 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
1726 "requestId" | "request_id" => Ok(GeneratedField::RequestId),
1727 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
1728 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1729 }
1730 }
1731 }
1732 deserializer.deserialize_identifier(GeneratedVisitor)
1733 }
1734 }
1735 struct GeneratedVisitor;
1736 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1737 type Value = IngestDmlInitRequest;
1738
1739 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1740 formatter.write_str("struct task_service.IngestDmlInitRequest")
1741 }
1742
1743 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IngestDmlInitRequest, V::Error>
1744 where
1745 V: serde::de::MapAccess<'de>,
1746 {
1747 let mut table_id__ = None;
1748 let mut table_version_id__ = None;
1749 let mut request_id__ = None;
1750 let mut row_id_index__ = None;
1751 while let Some(k) = map_.next_key()? {
1752 match k {
1753 GeneratedField::TableId => {
1754 if table_id__.is_some() {
1755 return Err(serde::de::Error::duplicate_field("tableId"));
1756 }
1757 table_id__ =
1758 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1759 ;
1760 }
1761 GeneratedField::TableVersionId => {
1762 if table_version_id__.is_some() {
1763 return Err(serde::de::Error::duplicate_field("tableVersionId"));
1764 }
1765 table_version_id__ =
1766 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1767 ;
1768 }
1769 GeneratedField::RequestId => {
1770 if request_id__.is_some() {
1771 return Err(serde::de::Error::duplicate_field("requestId"));
1772 }
1773 request_id__ =
1774 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1775 ;
1776 }
1777 GeneratedField::RowIdIndex => {
1778 if row_id_index__.is_some() {
1779 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
1780 }
1781 row_id_index__ =
1782 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1783 ;
1784 }
1785 }
1786 }
1787 Ok(IngestDmlInitRequest {
1788 table_id: table_id__.unwrap_or_default(),
1789 table_version_id: table_version_id__.unwrap_or_default(),
1790 request_id: request_id__.unwrap_or_default(),
1791 row_id_index: row_id_index__,
1792 })
1793 }
1794 }
1795 deserializer.deserialize_struct("task_service.IngestDmlInitRequest", FIELDS, GeneratedVisitor)
1796 }
1797}
1798impl serde::Serialize for IngestDmlInitResponse {
1799 #[allow(deprecated)]
1800 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1801 where
1802 S: serde::Serializer,
1803 {
1804 use serde::ser::SerializeStruct;
1805 let len = 0;
1806 let struct_ser = serializer.serialize_struct("task_service.IngestDmlInitResponse", len)?;
1807 struct_ser.end()
1808 }
1809}
1810impl<'de> serde::Deserialize<'de> for IngestDmlInitResponse {
1811 #[allow(deprecated)]
1812 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1813 where
1814 D: serde::Deserializer<'de>,
1815 {
1816 const FIELDS: &[&str] = &[
1817 ];
1818
1819 #[allow(clippy::enum_variant_names)]
1820 enum GeneratedField {
1821 }
1822 impl<'de> serde::Deserialize<'de> for GeneratedField {
1823 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1824 where
1825 D: serde::Deserializer<'de>,
1826 {
1827 struct GeneratedVisitor;
1828
1829 impl serde::de::Visitor<'_> for GeneratedVisitor {
1830 type Value = GeneratedField;
1831
1832 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1833 write!(formatter, "expected one of: {:?}", &FIELDS)
1834 }
1835
1836 #[allow(unused_variables)]
1837 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1838 where
1839 E: serde::de::Error,
1840 {
1841 Err(serde::de::Error::unknown_field(value, FIELDS))
1842 }
1843 }
1844 deserializer.deserialize_identifier(GeneratedVisitor)
1845 }
1846 }
1847 struct GeneratedVisitor;
1848 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1849 type Value = IngestDmlInitResponse;
1850
1851 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1852 formatter.write_str("struct task_service.IngestDmlInitResponse")
1853 }
1854
1855 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IngestDmlInitResponse, V::Error>
1856 where
1857 V: serde::de::MapAccess<'de>,
1858 {
1859 while map_.next_key::<GeneratedField>()?.is_some() {
1860 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1861 }
1862 Ok(IngestDmlInitResponse {
1863 })
1864 }
1865 }
1866 deserializer.deserialize_struct("task_service.IngestDmlInitResponse", FIELDS, GeneratedVisitor)
1867 }
1868}
1869impl serde::Serialize for IngestDmlPayloadRequest {
1870 #[allow(deprecated)]
1871 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1872 where
1873 S: serde::Serializer,
1874 {
1875 use serde::ser::SerializeStruct;
1876 let mut len = 0;
1877 if self.dml_batch_id != 0 {
1878 len += 1;
1879 }
1880 if self.chunk.is_some() {
1881 len += 1;
1882 }
1883 let mut struct_ser = serializer.serialize_struct("task_service.IngestDmlPayloadRequest", len)?;
1884 if self.dml_batch_id != 0 {
1885 #[allow(clippy::needless_borrow)]
1886 #[allow(clippy::needless_borrows_for_generic_args)]
1887 struct_ser.serialize_field("dmlBatchId", ToString::to_string(&self.dml_batch_id).as_str())?;
1888 }
1889 if let Some(v) = self.chunk.as_ref() {
1890 struct_ser.serialize_field("chunk", v)?;
1891 }
1892 struct_ser.end()
1893 }
1894}
1895impl<'de> serde::Deserialize<'de> for IngestDmlPayloadRequest {
1896 #[allow(deprecated)]
1897 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1898 where
1899 D: serde::Deserializer<'de>,
1900 {
1901 const FIELDS: &[&str] = &[
1902 "dml_batch_id",
1903 "dmlBatchId",
1904 "chunk",
1905 ];
1906
1907 #[allow(clippy::enum_variant_names)]
1908 enum GeneratedField {
1909 DmlBatchId,
1910 Chunk,
1911 }
1912 impl<'de> serde::Deserialize<'de> for GeneratedField {
1913 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1914 where
1915 D: serde::Deserializer<'de>,
1916 {
1917 struct GeneratedVisitor;
1918
1919 impl serde::de::Visitor<'_> for GeneratedVisitor {
1920 type Value = GeneratedField;
1921
1922 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1923 write!(formatter, "expected one of: {:?}", &FIELDS)
1924 }
1925
1926 #[allow(unused_variables)]
1927 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1928 where
1929 E: serde::de::Error,
1930 {
1931 match value {
1932 "dmlBatchId" | "dml_batch_id" => Ok(GeneratedField::DmlBatchId),
1933 "chunk" => Ok(GeneratedField::Chunk),
1934 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1935 }
1936 }
1937 }
1938 deserializer.deserialize_identifier(GeneratedVisitor)
1939 }
1940 }
1941 struct GeneratedVisitor;
1942 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1943 type Value = IngestDmlPayloadRequest;
1944
1945 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1946 formatter.write_str("struct task_service.IngestDmlPayloadRequest")
1947 }
1948
1949 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IngestDmlPayloadRequest, V::Error>
1950 where
1951 V: serde::de::MapAccess<'de>,
1952 {
1953 let mut dml_batch_id__ = None;
1954 let mut chunk__ = None;
1955 while let Some(k) = map_.next_key()? {
1956 match k {
1957 GeneratedField::DmlBatchId => {
1958 if dml_batch_id__.is_some() {
1959 return Err(serde::de::Error::duplicate_field("dmlBatchId"));
1960 }
1961 dml_batch_id__ =
1962 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1963 ;
1964 }
1965 GeneratedField::Chunk => {
1966 if chunk__.is_some() {
1967 return Err(serde::de::Error::duplicate_field("chunk"));
1968 }
1969 chunk__ = map_.next_value()?;
1970 }
1971 }
1972 }
1973 Ok(IngestDmlPayloadRequest {
1974 dml_batch_id: dml_batch_id__.unwrap_or_default(),
1975 chunk: chunk__,
1976 })
1977 }
1978 }
1979 deserializer.deserialize_struct("task_service.IngestDmlPayloadRequest", FIELDS, GeneratedVisitor)
1980 }
1981}
1982impl serde::Serialize for IngestDmlRequest {
1983 #[allow(deprecated)]
1984 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1985 where
1986 S: serde::Serializer,
1987 {
1988 use serde::ser::SerializeStruct;
1989 let mut len = 0;
1990 if self.request.is_some() {
1991 len += 1;
1992 }
1993 let mut struct_ser = serializer.serialize_struct("task_service.IngestDmlRequest", len)?;
1994 if let Some(v) = self.request.as_ref() {
1995 match v {
1996 ingest_dml_request::Request::Init(v) => {
1997 struct_ser.serialize_field("init", v)?;
1998 }
1999 ingest_dml_request::Request::Payload(v) => {
2000 struct_ser.serialize_field("payload", v)?;
2001 }
2002 }
2003 }
2004 struct_ser.end()
2005 }
2006}
2007impl<'de> serde::Deserialize<'de> for IngestDmlRequest {
2008 #[allow(deprecated)]
2009 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2010 where
2011 D: serde::Deserializer<'de>,
2012 {
2013 const FIELDS: &[&str] = &[
2014 "init",
2015 "payload",
2016 ];
2017
2018 #[allow(clippy::enum_variant_names)]
2019 enum GeneratedField {
2020 Init,
2021 Payload,
2022 }
2023 impl<'de> serde::Deserialize<'de> for GeneratedField {
2024 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2025 where
2026 D: serde::Deserializer<'de>,
2027 {
2028 struct GeneratedVisitor;
2029
2030 impl serde::de::Visitor<'_> for GeneratedVisitor {
2031 type Value = GeneratedField;
2032
2033 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2034 write!(formatter, "expected one of: {:?}", &FIELDS)
2035 }
2036
2037 #[allow(unused_variables)]
2038 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2039 where
2040 E: serde::de::Error,
2041 {
2042 match value {
2043 "init" => Ok(GeneratedField::Init),
2044 "payload" => Ok(GeneratedField::Payload),
2045 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2046 }
2047 }
2048 }
2049 deserializer.deserialize_identifier(GeneratedVisitor)
2050 }
2051 }
2052 struct GeneratedVisitor;
2053 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2054 type Value = IngestDmlRequest;
2055
2056 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2057 formatter.write_str("struct task_service.IngestDmlRequest")
2058 }
2059
2060 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IngestDmlRequest, V::Error>
2061 where
2062 V: serde::de::MapAccess<'de>,
2063 {
2064 let mut request__ = None;
2065 while let Some(k) = map_.next_key()? {
2066 match k {
2067 GeneratedField::Init => {
2068 if request__.is_some() {
2069 return Err(serde::de::Error::duplicate_field("init"));
2070 }
2071 request__ = map_.next_value::<::std::option::Option<_>>()?.map(ingest_dml_request::Request::Init)
2072;
2073 }
2074 GeneratedField::Payload => {
2075 if request__.is_some() {
2076 return Err(serde::de::Error::duplicate_field("payload"));
2077 }
2078 request__ = map_.next_value::<::std::option::Option<_>>()?.map(ingest_dml_request::Request::Payload)
2079;
2080 }
2081 }
2082 }
2083 Ok(IngestDmlRequest {
2084 request: request__,
2085 })
2086 }
2087 }
2088 deserializer.deserialize_struct("task_service.IngestDmlRequest", FIELDS, GeneratedVisitor)
2089 }
2090}
2091impl serde::Serialize for IngestDmlResponse {
2092 #[allow(deprecated)]
2093 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2094 where
2095 S: serde::Serializer,
2096 {
2097 use serde::ser::SerializeStruct;
2098 let mut len = 0;
2099 if self.response.is_some() {
2100 len += 1;
2101 }
2102 let mut struct_ser = serializer.serialize_struct("task_service.IngestDmlResponse", len)?;
2103 if let Some(v) = self.response.as_ref() {
2104 match v {
2105 ingest_dml_response::Response::Init(v) => {
2106 struct_ser.serialize_field("init", v)?;
2107 }
2108 ingest_dml_response::Response::Ack(v) => {
2109 struct_ser.serialize_field("ack", v)?;
2110 }
2111 }
2112 }
2113 struct_ser.end()
2114 }
2115}
2116impl<'de> serde::Deserialize<'de> for IngestDmlResponse {
2117 #[allow(deprecated)]
2118 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2119 where
2120 D: serde::Deserializer<'de>,
2121 {
2122 const FIELDS: &[&str] = &[
2123 "init",
2124 "ack",
2125 ];
2126
2127 #[allow(clippy::enum_variant_names)]
2128 enum GeneratedField {
2129 Init,
2130 Ack,
2131 }
2132 impl<'de> serde::Deserialize<'de> for GeneratedField {
2133 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2134 where
2135 D: serde::Deserializer<'de>,
2136 {
2137 struct GeneratedVisitor;
2138
2139 impl serde::de::Visitor<'_> for GeneratedVisitor {
2140 type Value = GeneratedField;
2141
2142 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2143 write!(formatter, "expected one of: {:?}", &FIELDS)
2144 }
2145
2146 #[allow(unused_variables)]
2147 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2148 where
2149 E: serde::de::Error,
2150 {
2151 match value {
2152 "init" => Ok(GeneratedField::Init),
2153 "ack" => Ok(GeneratedField::Ack),
2154 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2155 }
2156 }
2157 }
2158 deserializer.deserialize_identifier(GeneratedVisitor)
2159 }
2160 }
2161 struct GeneratedVisitor;
2162 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2163 type Value = IngestDmlResponse;
2164
2165 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2166 formatter.write_str("struct task_service.IngestDmlResponse")
2167 }
2168
2169 fn visit_map<V>(self, mut map_: V) -> std::result::Result<IngestDmlResponse, V::Error>
2170 where
2171 V: serde::de::MapAccess<'de>,
2172 {
2173 let mut response__ = None;
2174 while let Some(k) = map_.next_key()? {
2175 match k {
2176 GeneratedField::Init => {
2177 if response__.is_some() {
2178 return Err(serde::de::Error::duplicate_field("init"));
2179 }
2180 response__ = map_.next_value::<::std::option::Option<_>>()?.map(ingest_dml_response::Response::Init)
2181;
2182 }
2183 GeneratedField::Ack => {
2184 if response__.is_some() {
2185 return Err(serde::de::Error::duplicate_field("ack"));
2186 }
2187 response__ = map_.next_value::<::std::option::Option<_>>()?.map(ingest_dml_response::Response::Ack)
2188;
2189 }
2190 }
2191 }
2192 Ok(IngestDmlResponse {
2193 response: response__,
2194 })
2195 }
2196 }
2197 deserializer.deserialize_struct("task_service.IngestDmlResponse", FIELDS, GeneratedVisitor)
2198 }
2199}
2200impl serde::Serialize for Permits {
2201 #[allow(deprecated)]
2202 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2203 where
2204 S: serde::Serializer,
2205 {
2206 use serde::ser::SerializeStruct;
2207 let mut len = 0;
2208 if self.value.is_some() {
2209 len += 1;
2210 }
2211 let mut struct_ser = serializer.serialize_struct("task_service.Permits", len)?;
2212 if let Some(v) = self.value.as_ref() {
2213 match v {
2214 permits::Value::Record(v) => {
2215 struct_ser.serialize_field("record", v)?;
2216 }
2217 permits::Value::Barrier(v) => {
2218 struct_ser.serialize_field("barrier", v)?;
2219 }
2220 }
2221 }
2222 struct_ser.end()
2223 }
2224}
2225impl<'de> serde::Deserialize<'de> for Permits {
2226 #[allow(deprecated)]
2227 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2228 where
2229 D: serde::Deserializer<'de>,
2230 {
2231 const FIELDS: &[&str] = &[
2232 "record",
2233 "barrier",
2234 ];
2235
2236 #[allow(clippy::enum_variant_names)]
2237 enum GeneratedField {
2238 Record,
2239 Barrier,
2240 }
2241 impl<'de> serde::Deserialize<'de> for GeneratedField {
2242 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2243 where
2244 D: serde::Deserializer<'de>,
2245 {
2246 struct GeneratedVisitor;
2247
2248 impl serde::de::Visitor<'_> for GeneratedVisitor {
2249 type Value = GeneratedField;
2250
2251 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2252 write!(formatter, "expected one of: {:?}", &FIELDS)
2253 }
2254
2255 #[allow(unused_variables)]
2256 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2257 where
2258 E: serde::de::Error,
2259 {
2260 match value {
2261 "record" => Ok(GeneratedField::Record),
2262 "barrier" => Ok(GeneratedField::Barrier),
2263 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2264 }
2265 }
2266 }
2267 deserializer.deserialize_identifier(GeneratedVisitor)
2268 }
2269 }
2270 struct GeneratedVisitor;
2271 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2272 type Value = Permits;
2273
2274 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2275 formatter.write_str("struct task_service.Permits")
2276 }
2277
2278 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Permits, V::Error>
2279 where
2280 V: serde::de::MapAccess<'de>,
2281 {
2282 let mut value__ = None;
2283 while let Some(k) = map_.next_key()? {
2284 match k {
2285 GeneratedField::Record => {
2286 if value__.is_some() {
2287 return Err(serde::de::Error::duplicate_field("record"));
2288 }
2289 value__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| permits::Value::Record(x.0));
2290 }
2291 GeneratedField::Barrier => {
2292 if value__.is_some() {
2293 return Err(serde::de::Error::duplicate_field("barrier"));
2294 }
2295 value__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| permits::Value::Barrier(x.0));
2296 }
2297 }
2298 }
2299 Ok(Permits {
2300 value: value__,
2301 })
2302 }
2303 }
2304 deserializer.deserialize_struct("task_service.Permits", FIELDS, GeneratedVisitor)
2305 }
2306}
2307impl serde::Serialize for TaskId {
2308 #[allow(deprecated)]
2309 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2310 where
2311 S: serde::Serializer,
2312 {
2313 use serde::ser::SerializeStruct;
2314 let mut len = 0;
2315 if !self.query_id.is_empty() {
2316 len += 1;
2317 }
2318 if self.stage_id != 0 {
2319 len += 1;
2320 }
2321 if self.task_id != 0 {
2322 len += 1;
2323 }
2324 let mut struct_ser = serializer.serialize_struct("task_service.TaskId", len)?;
2325 if !self.query_id.is_empty() {
2326 struct_ser.serialize_field("queryId", &self.query_id)?;
2327 }
2328 if self.stage_id != 0 {
2329 struct_ser.serialize_field("stageId", &self.stage_id)?;
2330 }
2331 if self.task_id != 0 {
2332 struct_ser.serialize_field("taskId", &self.task_id)?;
2333 }
2334 struct_ser.end()
2335 }
2336}
2337impl<'de> serde::Deserialize<'de> for TaskId {
2338 #[allow(deprecated)]
2339 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2340 where
2341 D: serde::Deserializer<'de>,
2342 {
2343 const FIELDS: &[&str] = &[
2344 "query_id",
2345 "queryId",
2346 "stage_id",
2347 "stageId",
2348 "task_id",
2349 "taskId",
2350 ];
2351
2352 #[allow(clippy::enum_variant_names)]
2353 enum GeneratedField {
2354 QueryId,
2355 StageId,
2356 TaskId,
2357 }
2358 impl<'de> serde::Deserialize<'de> for GeneratedField {
2359 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2360 where
2361 D: serde::Deserializer<'de>,
2362 {
2363 struct GeneratedVisitor;
2364
2365 impl serde::de::Visitor<'_> for GeneratedVisitor {
2366 type Value = GeneratedField;
2367
2368 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2369 write!(formatter, "expected one of: {:?}", &FIELDS)
2370 }
2371
2372 #[allow(unused_variables)]
2373 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2374 where
2375 E: serde::de::Error,
2376 {
2377 match value {
2378 "queryId" | "query_id" => Ok(GeneratedField::QueryId),
2379 "stageId" | "stage_id" => Ok(GeneratedField::StageId),
2380 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
2381 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2382 }
2383 }
2384 }
2385 deserializer.deserialize_identifier(GeneratedVisitor)
2386 }
2387 }
2388 struct GeneratedVisitor;
2389 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2390 type Value = TaskId;
2391
2392 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2393 formatter.write_str("struct task_service.TaskId")
2394 }
2395
2396 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskId, V::Error>
2397 where
2398 V: serde::de::MapAccess<'de>,
2399 {
2400 let mut query_id__ = None;
2401 let mut stage_id__ = None;
2402 let mut task_id__ = None;
2403 while let Some(k) = map_.next_key()? {
2404 match k {
2405 GeneratedField::QueryId => {
2406 if query_id__.is_some() {
2407 return Err(serde::de::Error::duplicate_field("queryId"));
2408 }
2409 query_id__ = Some(map_.next_value()?);
2410 }
2411 GeneratedField::StageId => {
2412 if stage_id__.is_some() {
2413 return Err(serde::de::Error::duplicate_field("stageId"));
2414 }
2415 stage_id__ =
2416 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2417 ;
2418 }
2419 GeneratedField::TaskId => {
2420 if task_id__.is_some() {
2421 return Err(serde::de::Error::duplicate_field("taskId"));
2422 }
2423 task_id__ =
2424 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2425 ;
2426 }
2427 }
2428 }
2429 Ok(TaskId {
2430 query_id: query_id__.unwrap_or_default(),
2431 stage_id: stage_id__.unwrap_or_default(),
2432 task_id: task_id__.unwrap_or_default(),
2433 })
2434 }
2435 }
2436 deserializer.deserialize_struct("task_service.TaskId", FIELDS, GeneratedVisitor)
2437 }
2438}
2439impl serde::Serialize for TaskInfoResponse {
2440 #[allow(deprecated)]
2441 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2442 where
2443 S: serde::Serializer,
2444 {
2445 use serde::ser::SerializeStruct;
2446 let mut len = 0;
2447 if self.task_id.is_some() {
2448 len += 1;
2449 }
2450 if self.task_status != 0 {
2451 len += 1;
2452 }
2453 if !self.error_message.is_empty() {
2454 len += 1;
2455 }
2456 let mut struct_ser = serializer.serialize_struct("task_service.TaskInfoResponse", len)?;
2457 if let Some(v) = self.task_id.as_ref() {
2458 struct_ser.serialize_field("taskId", v)?;
2459 }
2460 if self.task_status != 0 {
2461 let v = task_info_response::TaskStatus::try_from(self.task_status)
2462 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
2463 struct_ser.serialize_field("taskStatus", &v)?;
2464 }
2465 if !self.error_message.is_empty() {
2466 struct_ser.serialize_field("errorMessage", &self.error_message)?;
2467 }
2468 struct_ser.end()
2469 }
2470}
2471impl<'de> serde::Deserialize<'de> for TaskInfoResponse {
2472 #[allow(deprecated)]
2473 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2474 where
2475 D: serde::Deserializer<'de>,
2476 {
2477 const FIELDS: &[&str] = &[
2478 "task_id",
2479 "taskId",
2480 "task_status",
2481 "taskStatus",
2482 "error_message",
2483 "errorMessage",
2484 ];
2485
2486 #[allow(clippy::enum_variant_names)]
2487 enum GeneratedField {
2488 TaskId,
2489 TaskStatus,
2490 ErrorMessage,
2491 }
2492 impl<'de> serde::Deserialize<'de> for GeneratedField {
2493 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2494 where
2495 D: serde::Deserializer<'de>,
2496 {
2497 struct GeneratedVisitor;
2498
2499 impl serde::de::Visitor<'_> for GeneratedVisitor {
2500 type Value = GeneratedField;
2501
2502 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2503 write!(formatter, "expected one of: {:?}", &FIELDS)
2504 }
2505
2506 #[allow(unused_variables)]
2507 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2508 where
2509 E: serde::de::Error,
2510 {
2511 match value {
2512 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
2513 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
2514 "errorMessage" | "error_message" => Ok(GeneratedField::ErrorMessage),
2515 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2516 }
2517 }
2518 }
2519 deserializer.deserialize_identifier(GeneratedVisitor)
2520 }
2521 }
2522 struct GeneratedVisitor;
2523 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2524 type Value = TaskInfoResponse;
2525
2526 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2527 formatter.write_str("struct task_service.TaskInfoResponse")
2528 }
2529
2530 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskInfoResponse, V::Error>
2531 where
2532 V: serde::de::MapAccess<'de>,
2533 {
2534 let mut task_id__ = None;
2535 let mut task_status__ = None;
2536 let mut error_message__ = None;
2537 while let Some(k) = map_.next_key()? {
2538 match k {
2539 GeneratedField::TaskId => {
2540 if task_id__.is_some() {
2541 return Err(serde::de::Error::duplicate_field("taskId"));
2542 }
2543 task_id__ = map_.next_value()?;
2544 }
2545 GeneratedField::TaskStatus => {
2546 if task_status__.is_some() {
2547 return Err(serde::de::Error::duplicate_field("taskStatus"));
2548 }
2549 task_status__ = Some(map_.next_value::<task_info_response::TaskStatus>()? as i32);
2550 }
2551 GeneratedField::ErrorMessage => {
2552 if error_message__.is_some() {
2553 return Err(serde::de::Error::duplicate_field("errorMessage"));
2554 }
2555 error_message__ = Some(map_.next_value()?);
2556 }
2557 }
2558 }
2559 Ok(TaskInfoResponse {
2560 task_id: task_id__,
2561 task_status: task_status__.unwrap_or_default(),
2562 error_message: error_message__.unwrap_or_default(),
2563 })
2564 }
2565 }
2566 deserializer.deserialize_struct("task_service.TaskInfoResponse", FIELDS, GeneratedVisitor)
2567 }
2568}
2569impl serde::Serialize for task_info_response::TaskStatus {
2570 #[allow(deprecated)]
2571 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2572 where
2573 S: serde::Serializer,
2574 {
2575 let variant = match self {
2576 Self::Unspecified => "UNSPECIFIED",
2577 Self::Pending => "PENDING",
2578 Self::Running => "RUNNING",
2579 Self::Finished => "FINISHED",
2580 Self::Failed => "FAILED",
2581 Self::Aborted => "ABORTED",
2582 Self::Cancelled => "CANCELLED",
2583 Self::Ping => "PING",
2584 };
2585 serializer.serialize_str(variant)
2586 }
2587}
2588impl<'de> serde::Deserialize<'de> for task_info_response::TaskStatus {
2589 #[allow(deprecated)]
2590 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2591 where
2592 D: serde::Deserializer<'de>,
2593 {
2594 const FIELDS: &[&str] = &[
2595 "UNSPECIFIED",
2596 "PENDING",
2597 "RUNNING",
2598 "FINISHED",
2599 "FAILED",
2600 "ABORTED",
2601 "CANCELLED",
2602 "PING",
2603 ];
2604
2605 struct GeneratedVisitor;
2606
2607 impl serde::de::Visitor<'_> for GeneratedVisitor {
2608 type Value = task_info_response::TaskStatus;
2609
2610 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2611 write!(formatter, "expected one of: {:?}", &FIELDS)
2612 }
2613
2614 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2615 where
2616 E: serde::de::Error,
2617 {
2618 i32::try_from(v)
2619 .ok()
2620 .and_then(|x| x.try_into().ok())
2621 .ok_or_else(|| {
2622 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2623 })
2624 }
2625
2626 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2627 where
2628 E: serde::de::Error,
2629 {
2630 i32::try_from(v)
2631 .ok()
2632 .and_then(|x| x.try_into().ok())
2633 .ok_or_else(|| {
2634 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2635 })
2636 }
2637
2638 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2639 where
2640 E: serde::de::Error,
2641 {
2642 match value {
2643 "UNSPECIFIED" => Ok(task_info_response::TaskStatus::Unspecified),
2644 "PENDING" => Ok(task_info_response::TaskStatus::Pending),
2645 "RUNNING" => Ok(task_info_response::TaskStatus::Running),
2646 "FINISHED" => Ok(task_info_response::TaskStatus::Finished),
2647 "FAILED" => Ok(task_info_response::TaskStatus::Failed),
2648 "ABORTED" => Ok(task_info_response::TaskStatus::Aborted),
2649 "CANCELLED" => Ok(task_info_response::TaskStatus::Cancelled),
2650 "PING" => Ok(task_info_response::TaskStatus::Ping),
2651 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2652 }
2653 }
2654 }
2655 deserializer.deserialize_any(GeneratedVisitor)
2656 }
2657}