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