1use crate::task_service::*;
2impl serde::Serialize for CancelTaskRequest {
3 #[allow(deprecated)]
4 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5 where
6 S: serde::Serializer,
7 {
8 use serde::ser::SerializeStruct;
9 let mut len = 0;
10 if self.task_id.is_some() {
11 len += 1;
12 }
13 let mut struct_ser = serializer.serialize_struct("task_service.CancelTaskRequest", len)?;
14 if let Some(v) = self.task_id.as_ref() {
15 struct_ser.serialize_field("taskId", v)?;
16 }
17 struct_ser.end()
18 }
19}
20impl<'de> serde::Deserialize<'de> for CancelTaskRequest {
21 #[allow(deprecated)]
22 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
23 where
24 D: serde::Deserializer<'de>,
25 {
26 const FIELDS: &[&str] = &[
27 "task_id",
28 "taskId",
29 ];
30
31 #[allow(clippy::enum_variant_names)]
32 enum GeneratedField {
33 TaskId,
34 }
35 impl<'de> serde::Deserialize<'de> for GeneratedField {
36 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
37 where
38 D: serde::Deserializer<'de>,
39 {
40 struct GeneratedVisitor;
41
42 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
43 type Value = GeneratedField;
44
45 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
46 write!(formatter, "expected one of: {:?}", &FIELDS)
47 }
48
49 #[allow(unused_variables)]
50 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
51 where
52 E: serde::de::Error,
53 {
54 match value {
55 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
56 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
57 }
58 }
59 }
60 deserializer.deserialize_identifier(GeneratedVisitor)
61 }
62 }
63 struct GeneratedVisitor;
64 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
65 type Value = CancelTaskRequest;
66
67 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
68 formatter.write_str("struct task_service.CancelTaskRequest")
69 }
70
71 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelTaskRequest, V::Error>
72 where
73 V: serde::de::MapAccess<'de>,
74 {
75 let mut task_id__ = None;
76 while let Some(k) = map_.next_key()? {
77 match k {
78 GeneratedField::TaskId => {
79 if task_id__.is_some() {
80 return Err(serde::de::Error::duplicate_field("taskId"));
81 }
82 task_id__ = map_.next_value()?;
83 }
84 }
85 }
86 Ok(CancelTaskRequest {
87 task_id: task_id__,
88 })
89 }
90 }
91 deserializer.deserialize_struct("task_service.CancelTaskRequest", FIELDS, GeneratedVisitor)
92 }
93}
94impl serde::Serialize for CancelTaskResponse {
95 #[allow(deprecated)]
96 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
97 where
98 S: serde::Serializer,
99 {
100 use serde::ser::SerializeStruct;
101 let mut len = 0;
102 if self.status.is_some() {
103 len += 1;
104 }
105 let mut struct_ser = serializer.serialize_struct("task_service.CancelTaskResponse", len)?;
106 if let Some(v) = self.status.as_ref() {
107 struct_ser.serialize_field("status", v)?;
108 }
109 struct_ser.end()
110 }
111}
112impl<'de> serde::Deserialize<'de> for CancelTaskResponse {
113 #[allow(deprecated)]
114 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
115 where
116 D: serde::Deserializer<'de>,
117 {
118 const FIELDS: &[&str] = &[
119 "status",
120 ];
121
122 #[allow(clippy::enum_variant_names)]
123 enum GeneratedField {
124 Status,
125 }
126 impl<'de> serde::Deserialize<'de> for GeneratedField {
127 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
128 where
129 D: serde::Deserializer<'de>,
130 {
131 struct GeneratedVisitor;
132
133 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
134 type Value = GeneratedField;
135
136 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
137 write!(formatter, "expected one of: {:?}", &FIELDS)
138 }
139
140 #[allow(unused_variables)]
141 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
142 where
143 E: serde::de::Error,
144 {
145 match value {
146 "status" => Ok(GeneratedField::Status),
147 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
148 }
149 }
150 }
151 deserializer.deserialize_identifier(GeneratedVisitor)
152 }
153 }
154 struct GeneratedVisitor;
155 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
156 type Value = CancelTaskResponse;
157
158 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
159 formatter.write_str("struct task_service.CancelTaskResponse")
160 }
161
162 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelTaskResponse, V::Error>
163 where
164 V: serde::de::MapAccess<'de>,
165 {
166 let mut status__ = None;
167 while let Some(k) = map_.next_key()? {
168 match k {
169 GeneratedField::Status => {
170 if status__.is_some() {
171 return Err(serde::de::Error::duplicate_field("status"));
172 }
173 status__ = map_.next_value()?;
174 }
175 }
176 }
177 Ok(CancelTaskResponse {
178 status: status__,
179 })
180 }
181 }
182 deserializer.deserialize_struct("task_service.CancelTaskResponse", FIELDS, GeneratedVisitor)
183 }
184}
185impl serde::Serialize for CreateTaskRequest {
186 #[allow(deprecated)]
187 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
188 where
189 S: serde::Serializer,
190 {
191 use serde::ser::SerializeStruct;
192 let mut len = 0;
193 if self.task_id.is_some() {
194 len += 1;
195 }
196 if self.plan.is_some() {
197 len += 1;
198 }
199 if !self.tracing_context.is_empty() {
200 len += 1;
201 }
202 if self.expr_context.is_some() {
203 len += 1;
204 }
205 let mut struct_ser = serializer.serialize_struct("task_service.CreateTaskRequest", len)?;
206 if let Some(v) = self.task_id.as_ref() {
207 struct_ser.serialize_field("taskId", v)?;
208 }
209 if let Some(v) = self.plan.as_ref() {
210 struct_ser.serialize_field("plan", v)?;
211 }
212 if !self.tracing_context.is_empty() {
213 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
214 }
215 if let Some(v) = self.expr_context.as_ref() {
216 struct_ser.serialize_field("exprContext", v)?;
217 }
218 struct_ser.end()
219 }
220}
221impl<'de> serde::Deserialize<'de> for CreateTaskRequest {
222 #[allow(deprecated)]
223 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
224 where
225 D: serde::Deserializer<'de>,
226 {
227 const FIELDS: &[&str] = &[
228 "task_id",
229 "taskId",
230 "plan",
231 "tracing_context",
232 "tracingContext",
233 "expr_context",
234 "exprContext",
235 ];
236
237 #[allow(clippy::enum_variant_names)]
238 enum GeneratedField {
239 TaskId,
240 Plan,
241 TracingContext,
242 ExprContext,
243 }
244 impl<'de> serde::Deserialize<'de> for GeneratedField {
245 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
246 where
247 D: serde::Deserializer<'de>,
248 {
249 struct GeneratedVisitor;
250
251 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
252 type Value = GeneratedField;
253
254 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
255 write!(formatter, "expected one of: {:?}", &FIELDS)
256 }
257
258 #[allow(unused_variables)]
259 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
260 where
261 E: serde::de::Error,
262 {
263 match value {
264 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
265 "plan" => Ok(GeneratedField::Plan),
266 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
267 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
268 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
269 }
270 }
271 }
272 deserializer.deserialize_identifier(GeneratedVisitor)
273 }
274 }
275 struct GeneratedVisitor;
276 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
277 type Value = CreateTaskRequest;
278
279 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
280 formatter.write_str("struct task_service.CreateTaskRequest")
281 }
282
283 fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateTaskRequest, V::Error>
284 where
285 V: serde::de::MapAccess<'de>,
286 {
287 let mut task_id__ = None;
288 let mut plan__ = None;
289 let mut tracing_context__ = None;
290 let mut expr_context__ = None;
291 while let Some(k) = map_.next_key()? {
292 match k {
293 GeneratedField::TaskId => {
294 if task_id__.is_some() {
295 return Err(serde::de::Error::duplicate_field("taskId"));
296 }
297 task_id__ = map_.next_value()?;
298 }
299 GeneratedField::Plan => {
300 if plan__.is_some() {
301 return Err(serde::de::Error::duplicate_field("plan"));
302 }
303 plan__ = map_.next_value()?;
304 }
305 GeneratedField::TracingContext => {
306 if tracing_context__.is_some() {
307 return Err(serde::de::Error::duplicate_field("tracingContext"));
308 }
309 tracing_context__ = Some(
310 map_.next_value::<std::collections::HashMap<_, _>>()?
311 );
312 }
313 GeneratedField::ExprContext => {
314 if expr_context__.is_some() {
315 return Err(serde::de::Error::duplicate_field("exprContext"));
316 }
317 expr_context__ = map_.next_value()?;
318 }
319 }
320 }
321 Ok(CreateTaskRequest {
322 task_id: task_id__,
323 plan: plan__,
324 tracing_context: tracing_context__.unwrap_or_default(),
325 expr_context: expr_context__,
326 })
327 }
328 }
329 deserializer.deserialize_struct("task_service.CreateTaskRequest", FIELDS, GeneratedVisitor)
330 }
331}
332impl serde::Serialize for ExecuteRequest {
333 #[allow(deprecated)]
334 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
335 where
336 S: serde::Serializer,
337 {
338 use serde::ser::SerializeStruct;
339 let mut len = 0;
340 if self.task_id.is_some() {
341 len += 1;
342 }
343 if self.plan.is_some() {
344 len += 1;
345 }
346 if !self.tracing_context.is_empty() {
347 len += 1;
348 }
349 if self.expr_context.is_some() {
350 len += 1;
351 }
352 let mut struct_ser = serializer.serialize_struct("task_service.ExecuteRequest", len)?;
353 if let Some(v) = self.task_id.as_ref() {
354 struct_ser.serialize_field("taskId", v)?;
355 }
356 if let Some(v) = self.plan.as_ref() {
357 struct_ser.serialize_field("plan", v)?;
358 }
359 if !self.tracing_context.is_empty() {
360 struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
361 }
362 if let Some(v) = self.expr_context.as_ref() {
363 struct_ser.serialize_field("exprContext", v)?;
364 }
365 struct_ser.end()
366 }
367}
368impl<'de> serde::Deserialize<'de> for ExecuteRequest {
369 #[allow(deprecated)]
370 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
371 where
372 D: serde::Deserializer<'de>,
373 {
374 const FIELDS: &[&str] = &[
375 "task_id",
376 "taskId",
377 "plan",
378 "tracing_context",
379 "tracingContext",
380 "expr_context",
381 "exprContext",
382 ];
383
384 #[allow(clippy::enum_variant_names)]
385 enum GeneratedField {
386 TaskId,
387 Plan,
388 TracingContext,
389 ExprContext,
390 }
391 impl<'de> serde::Deserialize<'de> for GeneratedField {
392 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
393 where
394 D: serde::Deserializer<'de>,
395 {
396 struct GeneratedVisitor;
397
398 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
399 type Value = GeneratedField;
400
401 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
402 write!(formatter, "expected one of: {:?}", &FIELDS)
403 }
404
405 #[allow(unused_variables)]
406 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
407 where
408 E: serde::de::Error,
409 {
410 match value {
411 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
412 "plan" => Ok(GeneratedField::Plan),
413 "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
414 "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
415 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
416 }
417 }
418 }
419 deserializer.deserialize_identifier(GeneratedVisitor)
420 }
421 }
422 struct GeneratedVisitor;
423 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
424 type Value = ExecuteRequest;
425
426 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
427 formatter.write_str("struct task_service.ExecuteRequest")
428 }
429
430 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExecuteRequest, V::Error>
431 where
432 V: serde::de::MapAccess<'de>,
433 {
434 let mut task_id__ = None;
435 let mut plan__ = None;
436 let mut tracing_context__ = None;
437 let mut expr_context__ = None;
438 while let Some(k) = map_.next_key()? {
439 match k {
440 GeneratedField::TaskId => {
441 if task_id__.is_some() {
442 return Err(serde::de::Error::duplicate_field("taskId"));
443 }
444 task_id__ = map_.next_value()?;
445 }
446 GeneratedField::Plan => {
447 if plan__.is_some() {
448 return Err(serde::de::Error::duplicate_field("plan"));
449 }
450 plan__ = map_.next_value()?;
451 }
452 GeneratedField::TracingContext => {
453 if tracing_context__.is_some() {
454 return Err(serde::de::Error::duplicate_field("tracingContext"));
455 }
456 tracing_context__ = Some(
457 map_.next_value::<std::collections::HashMap<_, _>>()?
458 );
459 }
460 GeneratedField::ExprContext => {
461 if expr_context__.is_some() {
462 return Err(serde::de::Error::duplicate_field("exprContext"));
463 }
464 expr_context__ = map_.next_value()?;
465 }
466 }
467 }
468 Ok(ExecuteRequest {
469 task_id: task_id__,
470 plan: plan__,
471 tracing_context: tracing_context__.unwrap_or_default(),
472 expr_context: expr_context__,
473 })
474 }
475 }
476 deserializer.deserialize_struct("task_service.ExecuteRequest", FIELDS, GeneratedVisitor)
477 }
478}
479impl serde::Serialize for FastInsertRequest {
480 #[allow(deprecated)]
481 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
482 where
483 S: serde::Serializer,
484 {
485 use serde::ser::SerializeStruct;
486 let mut len = 0;
487 if self.table_id != 0 {
488 len += 1;
489 }
490 if self.table_version_id != 0 {
491 len += 1;
492 }
493 if !self.column_indices.is_empty() {
494 len += 1;
495 }
496 if self.data_chunk.is_some() {
497 len += 1;
498 }
499 if self.row_id_index.is_some() {
500 len += 1;
501 }
502 if self.request_id != 0 {
503 len += 1;
504 }
505 if self.wait_for_persistence {
506 len += 1;
507 }
508 let mut struct_ser = serializer.serialize_struct("task_service.FastInsertRequest", len)?;
509 if self.table_id != 0 {
510 struct_ser.serialize_field("tableId", &self.table_id)?;
511 }
512 if self.table_version_id != 0 {
513 #[allow(clippy::needless_borrow)]
514 #[allow(clippy::needless_borrows_for_generic_args)]
515 struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
516 }
517 if !self.column_indices.is_empty() {
518 struct_ser.serialize_field("columnIndices", &self.column_indices)?;
519 }
520 if let Some(v) = self.data_chunk.as_ref() {
521 struct_ser.serialize_field("dataChunk", v)?;
522 }
523 if let Some(v) = self.row_id_index.as_ref() {
524 struct_ser.serialize_field("rowIdIndex", v)?;
525 }
526 if self.request_id != 0 {
527 struct_ser.serialize_field("requestId", &self.request_id)?;
528 }
529 if self.wait_for_persistence {
530 struct_ser.serialize_field("waitForPersistence", &self.wait_for_persistence)?;
531 }
532 struct_ser.end()
533 }
534}
535impl<'de> serde::Deserialize<'de> for FastInsertRequest {
536 #[allow(deprecated)]
537 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
538 where
539 D: serde::Deserializer<'de>,
540 {
541 const FIELDS: &[&str] = &[
542 "table_id",
543 "tableId",
544 "table_version_id",
545 "tableVersionId",
546 "column_indices",
547 "columnIndices",
548 "data_chunk",
549 "dataChunk",
550 "row_id_index",
551 "rowIdIndex",
552 "request_id",
553 "requestId",
554 "wait_for_persistence",
555 "waitForPersistence",
556 ];
557
558 #[allow(clippy::enum_variant_names)]
559 enum GeneratedField {
560 TableId,
561 TableVersionId,
562 ColumnIndices,
563 DataChunk,
564 RowIdIndex,
565 RequestId,
566 WaitForPersistence,
567 }
568 impl<'de> serde::Deserialize<'de> for GeneratedField {
569 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
570 where
571 D: serde::Deserializer<'de>,
572 {
573 struct GeneratedVisitor;
574
575 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
576 type Value = GeneratedField;
577
578 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
579 write!(formatter, "expected one of: {:?}", &FIELDS)
580 }
581
582 #[allow(unused_variables)]
583 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
584 where
585 E: serde::de::Error,
586 {
587 match value {
588 "tableId" | "table_id" => Ok(GeneratedField::TableId),
589 "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
590 "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
591 "dataChunk" | "data_chunk" => Ok(GeneratedField::DataChunk),
592 "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
593 "requestId" | "request_id" => Ok(GeneratedField::RequestId),
594 "waitForPersistence" | "wait_for_persistence" => Ok(GeneratedField::WaitForPersistence),
595 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
596 }
597 }
598 }
599 deserializer.deserialize_identifier(GeneratedVisitor)
600 }
601 }
602 struct GeneratedVisitor;
603 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
604 type Value = FastInsertRequest;
605
606 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
607 formatter.write_str("struct task_service.FastInsertRequest")
608 }
609
610 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FastInsertRequest, V::Error>
611 where
612 V: serde::de::MapAccess<'de>,
613 {
614 let mut table_id__ = None;
615 let mut table_version_id__ = None;
616 let mut column_indices__ = None;
617 let mut data_chunk__ = None;
618 let mut row_id_index__ = None;
619 let mut request_id__ = None;
620 let mut wait_for_persistence__ = None;
621 while let Some(k) = map_.next_key()? {
622 match k {
623 GeneratedField::TableId => {
624 if table_id__.is_some() {
625 return Err(serde::de::Error::duplicate_field("tableId"));
626 }
627 table_id__ =
628 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
629 ;
630 }
631 GeneratedField::TableVersionId => {
632 if table_version_id__.is_some() {
633 return Err(serde::de::Error::duplicate_field("tableVersionId"));
634 }
635 table_version_id__ =
636 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
637 ;
638 }
639 GeneratedField::ColumnIndices => {
640 if column_indices__.is_some() {
641 return Err(serde::de::Error::duplicate_field("columnIndices"));
642 }
643 column_indices__ =
644 Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
645 .into_iter().map(|x| x.0).collect())
646 ;
647 }
648 GeneratedField::DataChunk => {
649 if data_chunk__.is_some() {
650 return Err(serde::de::Error::duplicate_field("dataChunk"));
651 }
652 data_chunk__ = map_.next_value()?;
653 }
654 GeneratedField::RowIdIndex => {
655 if row_id_index__.is_some() {
656 return Err(serde::de::Error::duplicate_field("rowIdIndex"));
657 }
658 row_id_index__ =
659 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
660 ;
661 }
662 GeneratedField::RequestId => {
663 if request_id__.is_some() {
664 return Err(serde::de::Error::duplicate_field("requestId"));
665 }
666 request_id__ =
667 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
668 ;
669 }
670 GeneratedField::WaitForPersistence => {
671 if wait_for_persistence__.is_some() {
672 return Err(serde::de::Error::duplicate_field("waitForPersistence"));
673 }
674 wait_for_persistence__ = Some(map_.next_value()?);
675 }
676 }
677 }
678 Ok(FastInsertRequest {
679 table_id: table_id__.unwrap_or_default(),
680 table_version_id: table_version_id__.unwrap_or_default(),
681 column_indices: column_indices__.unwrap_or_default(),
682 data_chunk: data_chunk__,
683 row_id_index: row_id_index__,
684 request_id: request_id__.unwrap_or_default(),
685 wait_for_persistence: wait_for_persistence__.unwrap_or_default(),
686 })
687 }
688 }
689 deserializer.deserialize_struct("task_service.FastInsertRequest", FIELDS, GeneratedVisitor)
690 }
691}
692impl serde::Serialize for FastInsertResponse {
693 #[allow(deprecated)]
694 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
695 where
696 S: serde::Serializer,
697 {
698 use serde::ser::SerializeStruct;
699 let mut len = 0;
700 if self.status != 0 {
701 len += 1;
702 }
703 if !self.error_message.is_empty() {
704 len += 1;
705 }
706 let mut struct_ser = serializer.serialize_struct("task_service.FastInsertResponse", len)?;
707 if self.status != 0 {
708 let v = fast_insert_response::Status::try_from(self.status)
709 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.status)))?;
710 struct_ser.serialize_field("status", &v)?;
711 }
712 if !self.error_message.is_empty() {
713 struct_ser.serialize_field("errorMessage", &self.error_message)?;
714 }
715 struct_ser.end()
716 }
717}
718impl<'de> serde::Deserialize<'de> for FastInsertResponse {
719 #[allow(deprecated)]
720 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
721 where
722 D: serde::Deserializer<'de>,
723 {
724 const FIELDS: &[&str] = &[
725 "status",
726 "error_message",
727 "errorMessage",
728 ];
729
730 #[allow(clippy::enum_variant_names)]
731 enum GeneratedField {
732 Status,
733 ErrorMessage,
734 }
735 impl<'de> serde::Deserialize<'de> for GeneratedField {
736 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
737 where
738 D: serde::Deserializer<'de>,
739 {
740 struct GeneratedVisitor;
741
742 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
743 type Value = GeneratedField;
744
745 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
746 write!(formatter, "expected one of: {:?}", &FIELDS)
747 }
748
749 #[allow(unused_variables)]
750 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
751 where
752 E: serde::de::Error,
753 {
754 match value {
755 "status" => Ok(GeneratedField::Status),
756 "errorMessage" | "error_message" => Ok(GeneratedField::ErrorMessage),
757 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
758 }
759 }
760 }
761 deserializer.deserialize_identifier(GeneratedVisitor)
762 }
763 }
764 struct GeneratedVisitor;
765 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
766 type Value = FastInsertResponse;
767
768 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
769 formatter.write_str("struct task_service.FastInsertResponse")
770 }
771
772 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FastInsertResponse, V::Error>
773 where
774 V: serde::de::MapAccess<'de>,
775 {
776 let mut status__ = None;
777 let mut error_message__ = None;
778 while let Some(k) = map_.next_key()? {
779 match k {
780 GeneratedField::Status => {
781 if status__.is_some() {
782 return Err(serde::de::Error::duplicate_field("status"));
783 }
784 status__ = Some(map_.next_value::<fast_insert_response::Status>()? as i32);
785 }
786 GeneratedField::ErrorMessage => {
787 if error_message__.is_some() {
788 return Err(serde::de::Error::duplicate_field("errorMessage"));
789 }
790 error_message__ = Some(map_.next_value()?);
791 }
792 }
793 }
794 Ok(FastInsertResponse {
795 status: status__.unwrap_or_default(),
796 error_message: error_message__.unwrap_or_default(),
797 })
798 }
799 }
800 deserializer.deserialize_struct("task_service.FastInsertResponse", FIELDS, GeneratedVisitor)
801 }
802}
803impl serde::Serialize for fast_insert_response::Status {
804 #[allow(deprecated)]
805 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
806 where
807 S: serde::Serializer,
808 {
809 let variant = match self {
810 Self::Unspecified => "UNSPECIFIED",
811 Self::Succeeded => "SUCCEEDED",
812 Self::DmlFailed => "DML_FAILED",
813 };
814 serializer.serialize_str(variant)
815 }
816}
817impl<'de> serde::Deserialize<'de> for fast_insert_response::Status {
818 #[allow(deprecated)]
819 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
820 where
821 D: serde::Deserializer<'de>,
822 {
823 const FIELDS: &[&str] = &[
824 "UNSPECIFIED",
825 "SUCCEEDED",
826 "DML_FAILED",
827 ];
828
829 struct GeneratedVisitor;
830
831 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
832 type Value = fast_insert_response::Status;
833
834 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
835 write!(formatter, "expected one of: {:?}", &FIELDS)
836 }
837
838 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
839 where
840 E: serde::de::Error,
841 {
842 i32::try_from(v)
843 .ok()
844 .and_then(|x| x.try_into().ok())
845 .ok_or_else(|| {
846 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
847 })
848 }
849
850 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
851 where
852 E: serde::de::Error,
853 {
854 i32::try_from(v)
855 .ok()
856 .and_then(|x| x.try_into().ok())
857 .ok_or_else(|| {
858 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
859 })
860 }
861
862 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
863 where
864 E: serde::de::Error,
865 {
866 match value {
867 "UNSPECIFIED" => Ok(fast_insert_response::Status::Unspecified),
868 "SUCCEEDED" => Ok(fast_insert_response::Status::Succeeded),
869 "DML_FAILED" => Ok(fast_insert_response::Status::DmlFailed),
870 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
871 }
872 }
873 }
874 deserializer.deserialize_any(GeneratedVisitor)
875 }
876}
877impl serde::Serialize for GetDataRequest {
878 #[allow(deprecated)]
879 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
880 where
881 S: serde::Serializer,
882 {
883 use serde::ser::SerializeStruct;
884 let mut len = 0;
885 if self.task_output_id.is_some() {
886 len += 1;
887 }
888 let mut struct_ser = serializer.serialize_struct("task_service.GetDataRequest", len)?;
889 if let Some(v) = self.task_output_id.as_ref() {
890 struct_ser.serialize_field("taskOutputId", v)?;
891 }
892 struct_ser.end()
893 }
894}
895impl<'de> serde::Deserialize<'de> for GetDataRequest {
896 #[allow(deprecated)]
897 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
898 where
899 D: serde::Deserializer<'de>,
900 {
901 const FIELDS: &[&str] = &[
902 "task_output_id",
903 "taskOutputId",
904 ];
905
906 #[allow(clippy::enum_variant_names)]
907 enum GeneratedField {
908 TaskOutputId,
909 }
910 impl<'de> serde::Deserialize<'de> for GeneratedField {
911 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
912 where
913 D: serde::Deserializer<'de>,
914 {
915 struct GeneratedVisitor;
916
917 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
918 type Value = GeneratedField;
919
920 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
921 write!(formatter, "expected one of: {:?}", &FIELDS)
922 }
923
924 #[allow(unused_variables)]
925 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
926 where
927 E: serde::de::Error,
928 {
929 match value {
930 "taskOutputId" | "task_output_id" => Ok(GeneratedField::TaskOutputId),
931 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
932 }
933 }
934 }
935 deserializer.deserialize_identifier(GeneratedVisitor)
936 }
937 }
938 struct GeneratedVisitor;
939 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
940 type Value = GetDataRequest;
941
942 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
943 formatter.write_str("struct task_service.GetDataRequest")
944 }
945
946 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDataRequest, V::Error>
947 where
948 V: serde::de::MapAccess<'de>,
949 {
950 let mut task_output_id__ = None;
951 while let Some(k) = map_.next_key()? {
952 match k {
953 GeneratedField::TaskOutputId => {
954 if task_output_id__.is_some() {
955 return Err(serde::de::Error::duplicate_field("taskOutputId"));
956 }
957 task_output_id__ = map_.next_value()?;
958 }
959 }
960 }
961 Ok(GetDataRequest {
962 task_output_id: task_output_id__,
963 })
964 }
965 }
966 deserializer.deserialize_struct("task_service.GetDataRequest", FIELDS, GeneratedVisitor)
967 }
968}
969impl serde::Serialize for GetDataResponse {
970 #[allow(deprecated)]
971 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
972 where
973 S: serde::Serializer,
974 {
975 use serde::ser::SerializeStruct;
976 let mut len = 0;
977 if self.record_batch.is_some() {
978 len += 1;
979 }
980 let mut struct_ser = serializer.serialize_struct("task_service.GetDataResponse", len)?;
981 if let Some(v) = self.record_batch.as_ref() {
982 struct_ser.serialize_field("recordBatch", v)?;
983 }
984 struct_ser.end()
985 }
986}
987impl<'de> serde::Deserialize<'de> for GetDataResponse {
988 #[allow(deprecated)]
989 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
990 where
991 D: serde::Deserializer<'de>,
992 {
993 const FIELDS: &[&str] = &[
994 "record_batch",
995 "recordBatch",
996 ];
997
998 #[allow(clippy::enum_variant_names)]
999 enum GeneratedField {
1000 RecordBatch,
1001 }
1002 impl<'de> serde::Deserialize<'de> for GeneratedField {
1003 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1004 where
1005 D: serde::Deserializer<'de>,
1006 {
1007 struct GeneratedVisitor;
1008
1009 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1010 type Value = GeneratedField;
1011
1012 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1013 write!(formatter, "expected one of: {:?}", &FIELDS)
1014 }
1015
1016 #[allow(unused_variables)]
1017 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1018 where
1019 E: serde::de::Error,
1020 {
1021 match value {
1022 "recordBatch" | "record_batch" => Ok(GeneratedField::RecordBatch),
1023 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1024 }
1025 }
1026 }
1027 deserializer.deserialize_identifier(GeneratedVisitor)
1028 }
1029 }
1030 struct GeneratedVisitor;
1031 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1032 type Value = GetDataResponse;
1033
1034 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1035 formatter.write_str("struct task_service.GetDataResponse")
1036 }
1037
1038 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDataResponse, V::Error>
1039 where
1040 V: serde::de::MapAccess<'de>,
1041 {
1042 let mut record_batch__ = None;
1043 while let Some(k) = map_.next_key()? {
1044 match k {
1045 GeneratedField::RecordBatch => {
1046 if record_batch__.is_some() {
1047 return Err(serde::de::Error::duplicate_field("recordBatch"));
1048 }
1049 record_batch__ = map_.next_value()?;
1050 }
1051 }
1052 }
1053 Ok(GetDataResponse {
1054 record_batch: record_batch__,
1055 })
1056 }
1057 }
1058 deserializer.deserialize_struct("task_service.GetDataResponse", FIELDS, GeneratedVisitor)
1059 }
1060}
1061impl serde::Serialize for GetStreamRequest {
1062 #[allow(deprecated)]
1063 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1064 where
1065 S: serde::Serializer,
1066 {
1067 use serde::ser::SerializeStruct;
1068 let mut len = 0;
1069 if self.value.is_some() {
1070 len += 1;
1071 }
1072 let mut struct_ser = serializer.serialize_struct("task_service.GetStreamRequest", len)?;
1073 if let Some(v) = self.value.as_ref() {
1074 match v {
1075 get_stream_request::Value::Get(v) => {
1076 struct_ser.serialize_field("get", v)?;
1077 }
1078 get_stream_request::Value::AddPermits(v) => {
1079 struct_ser.serialize_field("addPermits", v)?;
1080 }
1081 }
1082 }
1083 struct_ser.end()
1084 }
1085}
1086impl<'de> serde::Deserialize<'de> for GetStreamRequest {
1087 #[allow(deprecated)]
1088 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1089 where
1090 D: serde::Deserializer<'de>,
1091 {
1092 const FIELDS: &[&str] = &[
1093 "get",
1094 "add_permits",
1095 "addPermits",
1096 ];
1097
1098 #[allow(clippy::enum_variant_names)]
1099 enum GeneratedField {
1100 Get,
1101 AddPermits,
1102 }
1103 impl<'de> serde::Deserialize<'de> for GeneratedField {
1104 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1105 where
1106 D: serde::Deserializer<'de>,
1107 {
1108 struct GeneratedVisitor;
1109
1110 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1111 type Value = GeneratedField;
1112
1113 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1114 write!(formatter, "expected one of: {:?}", &FIELDS)
1115 }
1116
1117 #[allow(unused_variables)]
1118 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1119 where
1120 E: serde::de::Error,
1121 {
1122 match value {
1123 "get" => Ok(GeneratedField::Get),
1124 "addPermits" | "add_permits" => Ok(GeneratedField::AddPermits),
1125 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1126 }
1127 }
1128 }
1129 deserializer.deserialize_identifier(GeneratedVisitor)
1130 }
1131 }
1132 struct GeneratedVisitor;
1133 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1134 type Value = GetStreamRequest;
1135
1136 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1137 formatter.write_str("struct task_service.GetStreamRequest")
1138 }
1139
1140 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetStreamRequest, V::Error>
1141 where
1142 V: serde::de::MapAccess<'de>,
1143 {
1144 let mut value__ = None;
1145 while let Some(k) = map_.next_key()? {
1146 match k {
1147 GeneratedField::Get => {
1148 if value__.is_some() {
1149 return Err(serde::de::Error::duplicate_field("get"));
1150 }
1151 value__ = map_.next_value::<::std::option::Option<_>>()?.map(get_stream_request::Value::Get)
1152;
1153 }
1154 GeneratedField::AddPermits => {
1155 if value__.is_some() {
1156 return Err(serde::de::Error::duplicate_field("addPermits"));
1157 }
1158 value__ = map_.next_value::<::std::option::Option<_>>()?.map(get_stream_request::Value::AddPermits)
1159;
1160 }
1161 }
1162 }
1163 Ok(GetStreamRequest {
1164 value: value__,
1165 })
1166 }
1167 }
1168 deserializer.deserialize_struct("task_service.GetStreamRequest", FIELDS, GeneratedVisitor)
1169 }
1170}
1171impl serde::Serialize for get_stream_request::Get {
1172 #[allow(deprecated)]
1173 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1174 where
1175 S: serde::Serializer,
1176 {
1177 use serde::ser::SerializeStruct;
1178 let mut len = 0;
1179 if self.up_actor_id != 0 {
1180 len += 1;
1181 }
1182 if self.down_actor_id != 0 {
1183 len += 1;
1184 }
1185 if self.up_fragment_id != 0 {
1186 len += 1;
1187 }
1188 if self.down_fragment_id != 0 {
1189 len += 1;
1190 }
1191 if self.database_id != 0 {
1192 len += 1;
1193 }
1194 if !self.term_id.is_empty() {
1195 len += 1;
1196 }
1197 let mut struct_ser = serializer.serialize_struct("task_service.GetStreamRequest.Get", len)?;
1198 if self.up_actor_id != 0 {
1199 struct_ser.serialize_field("upActorId", &self.up_actor_id)?;
1200 }
1201 if self.down_actor_id != 0 {
1202 struct_ser.serialize_field("downActorId", &self.down_actor_id)?;
1203 }
1204 if self.up_fragment_id != 0 {
1205 struct_ser.serialize_field("upFragmentId", &self.up_fragment_id)?;
1206 }
1207 if self.down_fragment_id != 0 {
1208 struct_ser.serialize_field("downFragmentId", &self.down_fragment_id)?;
1209 }
1210 if self.database_id != 0 {
1211 struct_ser.serialize_field("databaseId", &self.database_id)?;
1212 }
1213 if !self.term_id.is_empty() {
1214 struct_ser.serialize_field("termId", &self.term_id)?;
1215 }
1216 struct_ser.end()
1217 }
1218}
1219impl<'de> serde::Deserialize<'de> for get_stream_request::Get {
1220 #[allow(deprecated)]
1221 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1222 where
1223 D: serde::Deserializer<'de>,
1224 {
1225 const FIELDS: &[&str] = &[
1226 "up_actor_id",
1227 "upActorId",
1228 "down_actor_id",
1229 "downActorId",
1230 "up_fragment_id",
1231 "upFragmentId",
1232 "down_fragment_id",
1233 "downFragmentId",
1234 "database_id",
1235 "databaseId",
1236 "term_id",
1237 "termId",
1238 ];
1239
1240 #[allow(clippy::enum_variant_names)]
1241 enum GeneratedField {
1242 UpActorId,
1243 DownActorId,
1244 UpFragmentId,
1245 DownFragmentId,
1246 DatabaseId,
1247 TermId,
1248 }
1249 impl<'de> serde::Deserialize<'de> for GeneratedField {
1250 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1251 where
1252 D: serde::Deserializer<'de>,
1253 {
1254 struct GeneratedVisitor;
1255
1256 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1257 type Value = GeneratedField;
1258
1259 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1260 write!(formatter, "expected one of: {:?}", &FIELDS)
1261 }
1262
1263 #[allow(unused_variables)]
1264 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1265 where
1266 E: serde::de::Error,
1267 {
1268 match value {
1269 "upActorId" | "up_actor_id" => Ok(GeneratedField::UpActorId),
1270 "downActorId" | "down_actor_id" => Ok(GeneratedField::DownActorId),
1271 "upFragmentId" | "up_fragment_id" => Ok(GeneratedField::UpFragmentId),
1272 "downFragmentId" | "down_fragment_id" => Ok(GeneratedField::DownFragmentId),
1273 "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1274 "termId" | "term_id" => Ok(GeneratedField::TermId),
1275 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1276 }
1277 }
1278 }
1279 deserializer.deserialize_identifier(GeneratedVisitor)
1280 }
1281 }
1282 struct GeneratedVisitor;
1283 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1284 type Value = get_stream_request::Get;
1285
1286 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1287 formatter.write_str("struct task_service.GetStreamRequest.Get")
1288 }
1289
1290 fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_stream_request::Get, V::Error>
1291 where
1292 V: serde::de::MapAccess<'de>,
1293 {
1294 let mut up_actor_id__ = None;
1295 let mut down_actor_id__ = None;
1296 let mut up_fragment_id__ = None;
1297 let mut down_fragment_id__ = None;
1298 let mut database_id__ = None;
1299 let mut term_id__ = None;
1300 while let Some(k) = map_.next_key()? {
1301 match k {
1302 GeneratedField::UpActorId => {
1303 if up_actor_id__.is_some() {
1304 return Err(serde::de::Error::duplicate_field("upActorId"));
1305 }
1306 up_actor_id__ =
1307 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1308 ;
1309 }
1310 GeneratedField::DownActorId => {
1311 if down_actor_id__.is_some() {
1312 return Err(serde::de::Error::duplicate_field("downActorId"));
1313 }
1314 down_actor_id__ =
1315 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1316 ;
1317 }
1318 GeneratedField::UpFragmentId => {
1319 if up_fragment_id__.is_some() {
1320 return Err(serde::de::Error::duplicate_field("upFragmentId"));
1321 }
1322 up_fragment_id__ =
1323 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1324 ;
1325 }
1326 GeneratedField::DownFragmentId => {
1327 if down_fragment_id__.is_some() {
1328 return Err(serde::de::Error::duplicate_field("downFragmentId"));
1329 }
1330 down_fragment_id__ =
1331 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1332 ;
1333 }
1334 GeneratedField::DatabaseId => {
1335 if database_id__.is_some() {
1336 return Err(serde::de::Error::duplicate_field("databaseId"));
1337 }
1338 database_id__ =
1339 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1340 ;
1341 }
1342 GeneratedField::TermId => {
1343 if term_id__.is_some() {
1344 return Err(serde::de::Error::duplicate_field("termId"));
1345 }
1346 term_id__ = Some(map_.next_value()?);
1347 }
1348 }
1349 }
1350 Ok(get_stream_request::Get {
1351 up_actor_id: up_actor_id__.unwrap_or_default(),
1352 down_actor_id: down_actor_id__.unwrap_or_default(),
1353 up_fragment_id: up_fragment_id__.unwrap_or_default(),
1354 down_fragment_id: down_fragment_id__.unwrap_or_default(),
1355 database_id: database_id__.unwrap_or_default(),
1356 term_id: term_id__.unwrap_or_default(),
1357 })
1358 }
1359 }
1360 deserializer.deserialize_struct("task_service.GetStreamRequest.Get", FIELDS, GeneratedVisitor)
1361 }
1362}
1363impl serde::Serialize for GetStreamResponse {
1364 #[allow(deprecated)]
1365 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1366 where
1367 S: serde::Serializer,
1368 {
1369 use serde::ser::SerializeStruct;
1370 let mut len = 0;
1371 if self.message.is_some() {
1372 len += 1;
1373 }
1374 if self.permits.is_some() {
1375 len += 1;
1376 }
1377 let mut struct_ser = serializer.serialize_struct("task_service.GetStreamResponse", len)?;
1378 if let Some(v) = self.message.as_ref() {
1379 struct_ser.serialize_field("message", v)?;
1380 }
1381 if let Some(v) = self.permits.as_ref() {
1382 struct_ser.serialize_field("permits", v)?;
1383 }
1384 struct_ser.end()
1385 }
1386}
1387impl<'de> serde::Deserialize<'de> for GetStreamResponse {
1388 #[allow(deprecated)]
1389 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1390 where
1391 D: serde::Deserializer<'de>,
1392 {
1393 const FIELDS: &[&str] = &[
1394 "message",
1395 "permits",
1396 ];
1397
1398 #[allow(clippy::enum_variant_names)]
1399 enum GeneratedField {
1400 Message,
1401 Permits,
1402 }
1403 impl<'de> serde::Deserialize<'de> for GeneratedField {
1404 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1405 where
1406 D: serde::Deserializer<'de>,
1407 {
1408 struct GeneratedVisitor;
1409
1410 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1411 type Value = GeneratedField;
1412
1413 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1414 write!(formatter, "expected one of: {:?}", &FIELDS)
1415 }
1416
1417 #[allow(unused_variables)]
1418 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1419 where
1420 E: serde::de::Error,
1421 {
1422 match value {
1423 "message" => Ok(GeneratedField::Message),
1424 "permits" => Ok(GeneratedField::Permits),
1425 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1426 }
1427 }
1428 }
1429 deserializer.deserialize_identifier(GeneratedVisitor)
1430 }
1431 }
1432 struct GeneratedVisitor;
1433 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1434 type Value = GetStreamResponse;
1435
1436 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1437 formatter.write_str("struct task_service.GetStreamResponse")
1438 }
1439
1440 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetStreamResponse, V::Error>
1441 where
1442 V: serde::de::MapAccess<'de>,
1443 {
1444 let mut message__ = None;
1445 let mut permits__ = None;
1446 while let Some(k) = map_.next_key()? {
1447 match k {
1448 GeneratedField::Message => {
1449 if message__.is_some() {
1450 return Err(serde::de::Error::duplicate_field("message"));
1451 }
1452 message__ = map_.next_value()?;
1453 }
1454 GeneratedField::Permits => {
1455 if permits__.is_some() {
1456 return Err(serde::de::Error::duplicate_field("permits"));
1457 }
1458 permits__ = map_.next_value()?;
1459 }
1460 }
1461 }
1462 Ok(GetStreamResponse {
1463 message: message__,
1464 permits: permits__,
1465 })
1466 }
1467 }
1468 deserializer.deserialize_struct("task_service.GetStreamResponse", FIELDS, GeneratedVisitor)
1469 }
1470}
1471impl serde::Serialize for GetTaskInfoRequest {
1472 #[allow(deprecated)]
1473 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1474 where
1475 S: serde::Serializer,
1476 {
1477 use serde::ser::SerializeStruct;
1478 let mut len = 0;
1479 if self.task_id.is_some() {
1480 len += 1;
1481 }
1482 let mut struct_ser = serializer.serialize_struct("task_service.GetTaskInfoRequest", len)?;
1483 if let Some(v) = self.task_id.as_ref() {
1484 struct_ser.serialize_field("taskId", v)?;
1485 }
1486 struct_ser.end()
1487 }
1488}
1489impl<'de> serde::Deserialize<'de> for GetTaskInfoRequest {
1490 #[allow(deprecated)]
1491 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1492 where
1493 D: serde::Deserializer<'de>,
1494 {
1495 const FIELDS: &[&str] = &[
1496 "task_id",
1497 "taskId",
1498 ];
1499
1500 #[allow(clippy::enum_variant_names)]
1501 enum GeneratedField {
1502 TaskId,
1503 }
1504 impl<'de> serde::Deserialize<'de> for GeneratedField {
1505 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1506 where
1507 D: serde::Deserializer<'de>,
1508 {
1509 struct GeneratedVisitor;
1510
1511 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1512 type Value = GeneratedField;
1513
1514 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1515 write!(formatter, "expected one of: {:?}", &FIELDS)
1516 }
1517
1518 #[allow(unused_variables)]
1519 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1520 where
1521 E: serde::de::Error,
1522 {
1523 match value {
1524 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
1525 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1526 }
1527 }
1528 }
1529 deserializer.deserialize_identifier(GeneratedVisitor)
1530 }
1531 }
1532 struct GeneratedVisitor;
1533 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1534 type Value = GetTaskInfoRequest;
1535
1536 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1537 formatter.write_str("struct task_service.GetTaskInfoRequest")
1538 }
1539
1540 fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTaskInfoRequest, V::Error>
1541 where
1542 V: serde::de::MapAccess<'de>,
1543 {
1544 let mut task_id__ = None;
1545 while let Some(k) = map_.next_key()? {
1546 match k {
1547 GeneratedField::TaskId => {
1548 if task_id__.is_some() {
1549 return Err(serde::de::Error::duplicate_field("taskId"));
1550 }
1551 task_id__ = map_.next_value()?;
1552 }
1553 }
1554 }
1555 Ok(GetTaskInfoRequest {
1556 task_id: task_id__,
1557 })
1558 }
1559 }
1560 deserializer.deserialize_struct("task_service.GetTaskInfoRequest", FIELDS, GeneratedVisitor)
1561 }
1562}
1563impl serde::Serialize for Permits {
1564 #[allow(deprecated)]
1565 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1566 where
1567 S: serde::Serializer,
1568 {
1569 use serde::ser::SerializeStruct;
1570 let mut len = 0;
1571 if self.value.is_some() {
1572 len += 1;
1573 }
1574 let mut struct_ser = serializer.serialize_struct("task_service.Permits", len)?;
1575 if let Some(v) = self.value.as_ref() {
1576 match v {
1577 permits::Value::Record(v) => {
1578 struct_ser.serialize_field("record", v)?;
1579 }
1580 permits::Value::Barrier(v) => {
1581 struct_ser.serialize_field("barrier", v)?;
1582 }
1583 }
1584 }
1585 struct_ser.end()
1586 }
1587}
1588impl<'de> serde::Deserialize<'de> for Permits {
1589 #[allow(deprecated)]
1590 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1591 where
1592 D: serde::Deserializer<'de>,
1593 {
1594 const FIELDS: &[&str] = &[
1595 "record",
1596 "barrier",
1597 ];
1598
1599 #[allow(clippy::enum_variant_names)]
1600 enum GeneratedField {
1601 Record,
1602 Barrier,
1603 }
1604 impl<'de> serde::Deserialize<'de> for GeneratedField {
1605 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1606 where
1607 D: serde::Deserializer<'de>,
1608 {
1609 struct GeneratedVisitor;
1610
1611 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1612 type Value = GeneratedField;
1613
1614 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1615 write!(formatter, "expected one of: {:?}", &FIELDS)
1616 }
1617
1618 #[allow(unused_variables)]
1619 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1620 where
1621 E: serde::de::Error,
1622 {
1623 match value {
1624 "record" => Ok(GeneratedField::Record),
1625 "barrier" => Ok(GeneratedField::Barrier),
1626 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1627 }
1628 }
1629 }
1630 deserializer.deserialize_identifier(GeneratedVisitor)
1631 }
1632 }
1633 struct GeneratedVisitor;
1634 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1635 type Value = Permits;
1636
1637 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1638 formatter.write_str("struct task_service.Permits")
1639 }
1640
1641 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Permits, V::Error>
1642 where
1643 V: serde::de::MapAccess<'de>,
1644 {
1645 let mut value__ = None;
1646 while let Some(k) = map_.next_key()? {
1647 match k {
1648 GeneratedField::Record => {
1649 if value__.is_some() {
1650 return Err(serde::de::Error::duplicate_field("record"));
1651 }
1652 value__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| permits::Value::Record(x.0));
1653 }
1654 GeneratedField::Barrier => {
1655 if value__.is_some() {
1656 return Err(serde::de::Error::duplicate_field("barrier"));
1657 }
1658 value__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| permits::Value::Barrier(x.0));
1659 }
1660 }
1661 }
1662 Ok(Permits {
1663 value: value__,
1664 })
1665 }
1666 }
1667 deserializer.deserialize_struct("task_service.Permits", FIELDS, GeneratedVisitor)
1668 }
1669}
1670impl serde::Serialize for TaskId {
1671 #[allow(deprecated)]
1672 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1673 where
1674 S: serde::Serializer,
1675 {
1676 use serde::ser::SerializeStruct;
1677 let mut len = 0;
1678 if !self.query_id.is_empty() {
1679 len += 1;
1680 }
1681 if self.stage_id != 0 {
1682 len += 1;
1683 }
1684 if self.task_id != 0 {
1685 len += 1;
1686 }
1687 let mut struct_ser = serializer.serialize_struct("task_service.TaskId", len)?;
1688 if !self.query_id.is_empty() {
1689 struct_ser.serialize_field("queryId", &self.query_id)?;
1690 }
1691 if self.stage_id != 0 {
1692 struct_ser.serialize_field("stageId", &self.stage_id)?;
1693 }
1694 if self.task_id != 0 {
1695 struct_ser.serialize_field("taskId", &self.task_id)?;
1696 }
1697 struct_ser.end()
1698 }
1699}
1700impl<'de> serde::Deserialize<'de> for TaskId {
1701 #[allow(deprecated)]
1702 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1703 where
1704 D: serde::Deserializer<'de>,
1705 {
1706 const FIELDS: &[&str] = &[
1707 "query_id",
1708 "queryId",
1709 "stage_id",
1710 "stageId",
1711 "task_id",
1712 "taskId",
1713 ];
1714
1715 #[allow(clippy::enum_variant_names)]
1716 enum GeneratedField {
1717 QueryId,
1718 StageId,
1719 TaskId,
1720 }
1721 impl<'de> serde::Deserialize<'de> for GeneratedField {
1722 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1723 where
1724 D: serde::Deserializer<'de>,
1725 {
1726 struct GeneratedVisitor;
1727
1728 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1729 type Value = GeneratedField;
1730
1731 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1732 write!(formatter, "expected one of: {:?}", &FIELDS)
1733 }
1734
1735 #[allow(unused_variables)]
1736 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1737 where
1738 E: serde::de::Error,
1739 {
1740 match value {
1741 "queryId" | "query_id" => Ok(GeneratedField::QueryId),
1742 "stageId" | "stage_id" => Ok(GeneratedField::StageId),
1743 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
1744 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1745 }
1746 }
1747 }
1748 deserializer.deserialize_identifier(GeneratedVisitor)
1749 }
1750 }
1751 struct GeneratedVisitor;
1752 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1753 type Value = TaskId;
1754
1755 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1756 formatter.write_str("struct task_service.TaskId")
1757 }
1758
1759 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskId, V::Error>
1760 where
1761 V: serde::de::MapAccess<'de>,
1762 {
1763 let mut query_id__ = None;
1764 let mut stage_id__ = None;
1765 let mut task_id__ = None;
1766 while let Some(k) = map_.next_key()? {
1767 match k {
1768 GeneratedField::QueryId => {
1769 if query_id__.is_some() {
1770 return Err(serde::de::Error::duplicate_field("queryId"));
1771 }
1772 query_id__ = Some(map_.next_value()?);
1773 }
1774 GeneratedField::StageId => {
1775 if stage_id__.is_some() {
1776 return Err(serde::de::Error::duplicate_field("stageId"));
1777 }
1778 stage_id__ =
1779 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1780 ;
1781 }
1782 GeneratedField::TaskId => {
1783 if task_id__.is_some() {
1784 return Err(serde::de::Error::duplicate_field("taskId"));
1785 }
1786 task_id__ =
1787 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1788 ;
1789 }
1790 }
1791 }
1792 Ok(TaskId {
1793 query_id: query_id__.unwrap_or_default(),
1794 stage_id: stage_id__.unwrap_or_default(),
1795 task_id: task_id__.unwrap_or_default(),
1796 })
1797 }
1798 }
1799 deserializer.deserialize_struct("task_service.TaskId", FIELDS, GeneratedVisitor)
1800 }
1801}
1802impl serde::Serialize for TaskInfoResponse {
1803 #[allow(deprecated)]
1804 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1805 where
1806 S: serde::Serializer,
1807 {
1808 use serde::ser::SerializeStruct;
1809 let mut len = 0;
1810 if self.task_id.is_some() {
1811 len += 1;
1812 }
1813 if self.task_status != 0 {
1814 len += 1;
1815 }
1816 if !self.error_message.is_empty() {
1817 len += 1;
1818 }
1819 let mut struct_ser = serializer.serialize_struct("task_service.TaskInfoResponse", len)?;
1820 if let Some(v) = self.task_id.as_ref() {
1821 struct_ser.serialize_field("taskId", v)?;
1822 }
1823 if self.task_status != 0 {
1824 let v = task_info_response::TaskStatus::try_from(self.task_status)
1825 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.task_status)))?;
1826 struct_ser.serialize_field("taskStatus", &v)?;
1827 }
1828 if !self.error_message.is_empty() {
1829 struct_ser.serialize_field("errorMessage", &self.error_message)?;
1830 }
1831 struct_ser.end()
1832 }
1833}
1834impl<'de> serde::Deserialize<'de> for TaskInfoResponse {
1835 #[allow(deprecated)]
1836 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1837 where
1838 D: serde::Deserializer<'de>,
1839 {
1840 const FIELDS: &[&str] = &[
1841 "task_id",
1842 "taskId",
1843 "task_status",
1844 "taskStatus",
1845 "error_message",
1846 "errorMessage",
1847 ];
1848
1849 #[allow(clippy::enum_variant_names)]
1850 enum GeneratedField {
1851 TaskId,
1852 TaskStatus,
1853 ErrorMessage,
1854 }
1855 impl<'de> serde::Deserialize<'de> for GeneratedField {
1856 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1857 where
1858 D: serde::Deserializer<'de>,
1859 {
1860 struct GeneratedVisitor;
1861
1862 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1863 type Value = GeneratedField;
1864
1865 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1866 write!(formatter, "expected one of: {:?}", &FIELDS)
1867 }
1868
1869 #[allow(unused_variables)]
1870 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1871 where
1872 E: serde::de::Error,
1873 {
1874 match value {
1875 "taskId" | "task_id" => Ok(GeneratedField::TaskId),
1876 "taskStatus" | "task_status" => Ok(GeneratedField::TaskStatus),
1877 "errorMessage" | "error_message" => Ok(GeneratedField::ErrorMessage),
1878 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1879 }
1880 }
1881 }
1882 deserializer.deserialize_identifier(GeneratedVisitor)
1883 }
1884 }
1885 struct GeneratedVisitor;
1886 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1887 type Value = TaskInfoResponse;
1888
1889 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1890 formatter.write_str("struct task_service.TaskInfoResponse")
1891 }
1892
1893 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskInfoResponse, V::Error>
1894 where
1895 V: serde::de::MapAccess<'de>,
1896 {
1897 let mut task_id__ = None;
1898 let mut task_status__ = None;
1899 let mut error_message__ = None;
1900 while let Some(k) = map_.next_key()? {
1901 match k {
1902 GeneratedField::TaskId => {
1903 if task_id__.is_some() {
1904 return Err(serde::de::Error::duplicate_field("taskId"));
1905 }
1906 task_id__ = map_.next_value()?;
1907 }
1908 GeneratedField::TaskStatus => {
1909 if task_status__.is_some() {
1910 return Err(serde::de::Error::duplicate_field("taskStatus"));
1911 }
1912 task_status__ = Some(map_.next_value::<task_info_response::TaskStatus>()? as i32);
1913 }
1914 GeneratedField::ErrorMessage => {
1915 if error_message__.is_some() {
1916 return Err(serde::de::Error::duplicate_field("errorMessage"));
1917 }
1918 error_message__ = Some(map_.next_value()?);
1919 }
1920 }
1921 }
1922 Ok(TaskInfoResponse {
1923 task_id: task_id__,
1924 task_status: task_status__.unwrap_or_default(),
1925 error_message: error_message__.unwrap_or_default(),
1926 })
1927 }
1928 }
1929 deserializer.deserialize_struct("task_service.TaskInfoResponse", FIELDS, GeneratedVisitor)
1930 }
1931}
1932impl serde::Serialize for task_info_response::TaskStatus {
1933 #[allow(deprecated)]
1934 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1935 where
1936 S: serde::Serializer,
1937 {
1938 let variant = match self {
1939 Self::Unspecified => "UNSPECIFIED",
1940 Self::Pending => "PENDING",
1941 Self::Running => "RUNNING",
1942 Self::Finished => "FINISHED",
1943 Self::Failed => "FAILED",
1944 Self::Aborted => "ABORTED",
1945 Self::Cancelled => "CANCELLED",
1946 Self::Ping => "PING",
1947 };
1948 serializer.serialize_str(variant)
1949 }
1950}
1951impl<'de> serde::Deserialize<'de> for task_info_response::TaskStatus {
1952 #[allow(deprecated)]
1953 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1954 where
1955 D: serde::Deserializer<'de>,
1956 {
1957 const FIELDS: &[&str] = &[
1958 "UNSPECIFIED",
1959 "PENDING",
1960 "RUNNING",
1961 "FINISHED",
1962 "FAILED",
1963 "ABORTED",
1964 "CANCELLED",
1965 "PING",
1966 ];
1967
1968 struct GeneratedVisitor;
1969
1970 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1971 type Value = task_info_response::TaskStatus;
1972
1973 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1974 write!(formatter, "expected one of: {:?}", &FIELDS)
1975 }
1976
1977 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1978 where
1979 E: serde::de::Error,
1980 {
1981 i32::try_from(v)
1982 .ok()
1983 .and_then(|x| x.try_into().ok())
1984 .ok_or_else(|| {
1985 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1986 })
1987 }
1988
1989 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1990 where
1991 E: serde::de::Error,
1992 {
1993 i32::try_from(v)
1994 .ok()
1995 .and_then(|x| x.try_into().ok())
1996 .ok_or_else(|| {
1997 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1998 })
1999 }
2000
2001 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2002 where
2003 E: serde::de::Error,
2004 {
2005 match value {
2006 "UNSPECIFIED" => Ok(task_info_response::TaskStatus::Unspecified),
2007 "PENDING" => Ok(task_info_response::TaskStatus::Pending),
2008 "RUNNING" => Ok(task_info_response::TaskStatus::Running),
2009 "FINISHED" => Ok(task_info_response::TaskStatus::Finished),
2010 "FAILED" => Ok(task_info_response::TaskStatus::Failed),
2011 "ABORTED" => Ok(task_info_response::TaskStatus::Aborted),
2012 "CANCELLED" => Ok(task_info_response::TaskStatus::Cancelled),
2013 "PING" => Ok(task_info_response::TaskStatus::Ping),
2014 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2015 }
2016 }
2017 }
2018 deserializer.deserialize_any(GeneratedVisitor)
2019 }
2020}